Enum AlephTree

Source

pub enum AlephTree {
Show 218 variants    Unit,
    Break,
    Continue,
    Ellipsis,
    Int {
        value: String,
    },
    Float {
        value: String,
    },
    Bool {
        value: String,
    },
    String {
        value: String,
    },
    Ident {
        value: String,
    },
    Bytes {
        elems: Vec<u8>,
    },
    Complex {
        real: String,
        imag: String,
    },
    HexLiteral {
        value: String,
    },
    Figurative {
        figurative_type: String,
    },
    Tuple {
        elems: Vec<Box<AlephTree>>,
    },
    Array {
        elems: Vec<Box<AlephTree>>,
    },
    Record {
        fields: Vec<Box<AlephTree>>,
    },
    Field {
        name: String,
        value: Box<AlephTree>,
    },
    Neg {
        expr: Box<AlephTree>,
    },
    Not {
        bool_expr: Box<AlephTree>,
    },
    BitNot {
        expr: Box<AlephTree>,
    },
    Abs {
        expr: Box<AlephTree>,
    },
    Add {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Sub {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Mul {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Div {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    Mod {
        number_expr1: Box<AlephTree>,
        number_expr2: Box<AlephTree>,
    },
    DivMod {
        dividend: Box<AlephTree>,
        divisor: Box<AlephTree>,
    },
    MulDiv {
        n1: Box<AlephTree>,
        n2: Box<AlephTree>,
        n3: Box<AlephTree>,
    },
    MulDivMod {
        n1: Box<AlephTree>,
        n2: Box<AlephTree>,
        n3: Box<AlephTree>,
    },
    Pow {
        base: Box<AlephTree>,
        exponent: Box<AlephTree>,
    },
    Min {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    Max {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    And {
        bool_expr1: Box<AlephTree>,
        bool_expr2: Box<AlephTree>,
    },
    Or {
        bool_expr1: Box<AlephTree>,
        bool_expr2: Box<AlephTree>,
    },
    Xor {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    BitAnd {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    BitOr {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    BitXor {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    LShift {
        expr: Box<AlephTree>,
        amount: Box<AlephTree>,
    },
    RShift {
        expr: Box<AlephTree>,
        amount: Box<AlephTree>,
    },
    Eq {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    NotEq {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    LT {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    LE {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    GT {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    GE {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    In {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    If {
        condition: Box<AlephTree>,
        then: Box<AlephTree>,
        els: Box<AlephTree>,
    },
    While {
        init_expr: Box<AlephTree>,
        condition: Box<AlephTree>,
        loop_expr: Box<AlephTree>,
        post_expr: Box<AlephTree>,
    },
    For {
        var: String,
        start: Box<AlephTree>,
        end: Box<AlephTree>,
        step: Option<Box<AlephTree>>,
        body: Box<AlephTree>,
        reverse: bool,
    },
    Loop {
        name: Option<String>,
        body: Vec<Box<AlephTree>>,
    },
    DoLoop {
        loop_var: Option<String>,
        start: Option<Box<AlephTree>>,
        end: Option<Box<AlephTree>>,
        by: Option<Box<AlephTree>>,
        while_cond: Option<Box<AlephTree>>,
        until_cond: Option<Box<AlephTree>>,
        body: Vec<Box<AlephTree>>,
    },
    Case {
        expr: Box<AlephTree>,
        cases: Vec<Box<AlephTree>>,
        default_case: Option<Box<AlephTree>>,
    },
    CaseBranch {
        pattern: Box<AlephTree>,
        body: Vec<Box<AlephTree>>,
    },
    Match {
        expr: Box<AlephTree>,
        case_list: Vec<Box<AlephTree>>,
    },
    MatchLine {
        condition: Box<AlephTree>,
        case_expr: Box<AlephTree>,
    },
    ProcedureDef {
        name: String,
        proc_type: Option<String>,
        parameters: Vec<Box<AlephTree>>,
        return_type: Option<Box<AlephTree>>,
        attributes: Vec<String>,
        declarations: Vec<Box<AlephTree>>,
        body: Vec<Box<AlephTree>>,
    },
    Parameter {
        name: String,
        param_type: Option<Box<AlephTree>>,
        mode: Option<String>,
        default: Option<Box<AlephTree>>,
    },
    VarDecl {
        name: String,
        level: Option<String>,
        var_type: Option<Box<AlephTree>>,
        initial_value: Option<Box<AlephTree>>,
        is_constant: bool,
        is_aliased: bool,
        storage: Option<String>,
        occurs: Option<String>,
        usage: Option<String>,
        attributes: Vec<String>,
    },
    StructDecl {
        name: String,
        level: Option<String>,
        members: Vec<Box<AlephTree>>,
        attributes: Vec<String>,
    },
    TypeDecl {
        name: String,
        definition: Box<AlephTree>,
        attributes: Vec<String>,
    },
    Let {
        var: String,
        is_pointer: String,
        value: Box<AlephTree>,
        expr: Box<AlephTree>,
    },
    LetRec {
        name: String,
        args: Vec<Box<AlephTree>>,
        body: Box<AlephTree>,
    },
    Var {
        var: String,
        is_pointer: String,
    },
    TypeRef {
        name: String,
        qualifiers: Vec<String>,
    },
    ArrayType {
        element_type: Box<AlephTree>,
        dimensions: Vec<Box<AlephTree>>,
    },
    PointerType {
        target_type: Box<AlephTree>,
        is_all: bool,
    },
    RangeType {
        start: Box<AlephTree>,
        end: Box<AlephTree>,
    },
    EnumType {
        values: Vec<String>,
    },
    RecordType {
        fields: Vec<Box<AlephTree>>,
    },
    FieldDecl {
        name: String,
        field_type: Box<AlephTree>,
        attributes: Vec<String>,
    },
    SubtypeDecl {
        name: String,
        base_type: Box<AlephTree>,
        constraint: Option<Box<AlephTree>>,
    },
    Get {
        array_name: String,
        elem: Box<AlephTree>,
    },
    Put {
        array_name: String,
        elem: Box<AlephTree>,
        value: Box<AlephTree>,
        insert: String,
    },
    Remove {
        array_name: String,
        elem: Box<AlephTree>,
        is_value: String,
    },
    Length {
        var: String,
    },
    Slice {
        array: Box<AlephTree>,
        start: Option<Box<AlephTree>>,
        end: Option<Box<AlephTree>>,
    },
    Alloc {
        var: Box<AlephTree>,
        target: Option<Box<AlephTree>>,
    },
    Free {
        var: Box<AlephTree>,
    },
    Fetch {
        addr: Box<AlephTree>,
        fetch_type: Option<String>,
    },
    Store {
        value: Box<AlephTree>,
        addr: Box<AlephTree>,
        store_type: Option<String>,
    },
    StoreOp {
        value: Box<AlephTree>,
        addr: Box<AlephTree>,
        op: String,
    },
    App {
        object_name: String,
        fun: Box<AlephTree>,
        param_list: Vec<Box<AlephTree>>,
    },
    Call {
        target: Box<AlephTree>,
        parameters: Option<Vec<Box<AlephTree>>>,
        returning: Option<Box<AlephTree>>,
        on_error: Option<Box<AlephTree>>,
    },
    Stmts {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    Block {
        statements: Vec<Box<AlephTree>>,
    },
    Assignment {
        target: Box<AlephTree>,
        value: Box<AlephTree>,
    },
    Return {
        value: Box<AlephTree>,
    },
    GoTo {
        target: String,
        depending_on: Option<Box<AlephTree>>,
    },
    Label {
        name: String,
        label_type: Option<String>,
    },
    Exit,
    Move {
        source: Box<AlephTree>,
        targets: Vec<Box<AlephTree>>,
    },
    Compute {
        target: Box<AlephTree>,
        expression: Box<AlephTree>,
        on_error: Option<Box<AlephTree>>,
    },
    Print {
        items: Vec<Box<AlephTree>>,
        destination: Option<String>,
        format: Option<Vec<Box<AlephTree>>>,
        options: Vec<String>,
    },
    Input {
        targets: Vec<Box<AlephTree>>,
        source: Option<String>,
        options: Vec<String>,
    },
    FileOpen {
        file: String,
        mode: String,
        attributes: Vec<String>,
    },
    FileClose {
        files: Vec<String>,
    },
    FileRead {
        file_name: String,
        into: Option<Box<AlephTree>>,
        key: Option<Box<AlephTree>>,
        on_end: Option<Box<AlephTree>>,
        not_on_end: Option<Box<AlephTree>>,
    },
    FileWrite {
        record_name: String,
        from: Option<Box<AlephTree>>,
        options: Vec<String>,
    },
    StringOp {
        operation: String,
        sources: Vec<Box<AlephTree>>,
        delimiter: Option<Box<AlephTree>>,
        targets: Vec<Box<AlephTree>>,
        pointer: Option<Box<AlephTree>>,
        clauses: Vec<Box<AlephTree>>,
    },
    Iprt {
        name: String,
        items: Vec<String>,
    },
    Module {
        name: String,
        module_type: String,
        id: Option<String>,
        declarations: Vec<Box<AlephTree>>,
        body: Option<Vec<Box<AlephTree>>>,
        initialization: Option<Vec<Box<AlephTree>>>,
    },
    Division {
        division_type: String,
        sections: Vec<Box<AlephTree>>,
    },
    Section {
        name: String,
        section_type: Option<String>,
        content: Vec<Box<AlephTree>>,
    },
    Clss {
        name: String,
        attribute_list: Vec<String>,
        body: Box<AlephTree>,
    },
    TryCatch {
        try_block: Box<AlephTree>,
        catch_clauses: Vec<Box<AlephTree>>,
        finally_block: Option<Box<AlephTree>>,
    },
    CatchClause {
        exception_types: Vec<String>,
        var: Option<String>,
        body: Box<AlephTree>,
    },
    OnCondition {
        condition: String,
        options: Vec<String>,
        handler: Box<AlephTree>,
    },
    Raise {
        condition: Box<AlephTree>,
    },
    Signal {
        condition: String,
    },
    Revert {
        condition: String,
    },
    ExceptionDecl {
        name: String,
    },
    Comment {
        value: String,
    },
    CommentMulti {
        value: String,
    },
    Assert {
        condition: Box<AlephTree>,
        message: Box<AlephTree>,
    },
    Generic {
        name: String,
        generic_type: String,
        generic_params: Vec<Box<AlephTree>>,
        body: Box<AlephTree>,
    },
    GenericParam {
        name: String,
        param_kind: String,
        constraint: Option<Box<AlephTree>>,
        default: Option<Box<AlephTree>>,
    },
    Instantiation {
        name: String,
        generic_name: String,
        actual_params: Vec<Box<AlephTree>>,
    },
    Attribute {
        prefix: Box<AlephTree>,
        attribute: String,
        args: Option<Vec<Box<AlephTree>>>,
    },
    Pragma {
        name: String,
        args: Vec<Box<AlephTree>>,
    },
    RepresentationClause {
        name: String,
        clause_type: String,
        specification: Box<AlephTree>,
    },
    Renaming {
        new_name: String,
        old_name: Box<AlephTree>,
        rename_type: Option<Box<AlephTree>>,
    },
    Execute {
        target: Box<AlephTree>,
        exec_type: Option<String>,
    },
    Perform {
        target: Option<String>,
        from: Option<String>,
        through: Option<String>,
        times: Option<Box<AlephTree>>,
        until: Option<Box<AlephTree>>,
        varying: Option<Box<AlephTree>>,
        inline: Option<Vec<Box<AlephTree>>>,
    },
    PicClause {
        data_name: String,
        level_number: String,
        picture: String,
        initial_value: Option<Box<AlephTree>>,
        occurs_clause: Option<String>,
        usage: Option<String>,
    },
    FileDescription {
        file_name: String,
        record_description: Vec<Box<AlephTree>>,
        block_contains: Option<String>,
        record_contains: Option<String>,
    },
    SelectStatement {
        file_name: String,
        assign_to: String,
        access_mode: Option<String>,
        organization_mode: Option<String>,
    },
    Inspect {
        inspecting_item: Box<AlephTree>,
        tallying_clause: Option<Box<AlephTree>>,
        replacing_clause: Option<Box<AlephTree>>,
    },
    Accept {
        target: Box<AlephTree>,
        from_device: Option<String>,
    },
    Display {
        item_list: Vec<Box<AlephTree>>,
        upon_device: Option<String>,
    },
    Open {
        mode: String,
        file_list: Vec<String>,
    },
    Close {
        file_list: Vec<String>,
    },
    Read {
        file_name: String,
        into_clause: Option<Box<AlephTree>>,
        key_clause: Option<Box<AlephTree>>,
        at_end_clause: Option<Box<AlephTree>>,
        not_at_end_clause: Option<Box<AlephTree>>,
    },
    Write {
        record_name: String,
        from_clause: Option<Box<AlephTree>>,
        advancing_clause: Option<String>,
    },
    Stop {
        stop_type: String,
    },
    Paragraph {
        name: String,
        statements: Vec<Box<AlephTree>>,
    },
    Evaluate {
        selection_subject: Box<AlephTree>,
        when_clauses: Vec<Box<AlephTree>>,
        when_other: Option<Box<AlephTree>>,
    },
    WhenClause {
        selection_object: Box<AlephTree>,
        statements: Vec<Box<AlephTree>>,
    },
    StringStmt {
        source_items: Vec<Box<AlephTree>>,
        delimited_by: Box<AlephTree>,
        into_item: Box<AlephTree>,
        with_pointer: Option<Box<AlephTree>>,
        on_overflow: Option<Box<AlephTree>>,
    },
    Unstring {
        source_item: Box<AlephTree>,
        delimited_by: Box<AlephTree>,
        into_items: Vec<Box<AlephTree>>,
        with_pointer: Option<Box<AlephTree>>,
        on_overflow: Option<Box<AlephTree>>,
    },
    OnSizeError {
        statements: Vec<Box<AlephTree>>,
    },
    NotOnSizeError {
        statements: Vec<Box<AlephTree>>,
    },
    QualifiedName {
        data_name: String,
        qualifier_list: Vec<String>,
    },
    Subscript {
        data_name: String,
        subscript_list: Vec<Box<AlephTree>>,
    },
    ClassCondition {
        data_item: Box<AlephTree>,
        class_name: String,
    },
    SignCondition {
        data_item: Box<AlephTree>,
        sign: String,
    },
    OccursClause {
        min_occurs: Option<String>,
        max_occurs: String,
        depending_on: Option<String>,
        indexed_by: Option<Vec<String>>,
    },
    UsageClause {
        usage_type: String,
    },
    ForthProgram {
        definitions: Vec<Box<AlephTree>>,
    },
    ForthSequence {
        words: Vec<Box<AlephTree>>,
    },
    ForthDup,
    ForthDrop,
    ForthSwap,
    ForthOver,
    ForthRot,
    ForthMinusRot,
    ForthNip,
    ForthTuck,
    ForthPick {
        depth: Box<AlephTree>,
    },
    ForthRoll {
        depth: Box<AlephTree>,
    },
    ForthTwoDup,
    ForthTwoDrop,
    ForthTwoSwap,
    ForthTwoOver,
    ForthToR,
    ForthFromR,
    ForthRFetch,
    ForthCells {
        n: Box<AlephTree>,
    },
    ForthAllot {
        n: Box<AlephTree>,
    },
    ForthComma {
        value: Box<AlephTree>,
    },
    ForthCComma {
        value: Box<AlephTree>,
    },
    ForthHere,
    ForthDot {
        value: Box<AlephTree>,
    },
    ForthEmit {
        char: Box<AlephTree>,
    },
    ForthCR,
    ForthSpace,
    ForthSpaces {
        count: Box<AlephTree>,
    },
    ForthType {
        addr: Box<AlephTree>,
        count: Box<AlephTree>,
    },
    ForthKey,
    ForthAccept {
        addr: Box<AlephTree>,
        max_len: Box<AlephTree>,
    },
    ForthDotQuote {
        text: String,
    },
    ForthSQuote {
        text: String,
    },
    ForthBeginUntil {
        body: Vec<Box<AlephTree>>,
        condition: Box<AlephTree>,
    },
    ForthBeginWhileRepeat {
        condition: Box<AlephTree>,
        while_body: Vec<Box<AlephTree>>,
        repeat_body: Vec<Box<AlephTree>>,
    },
    ForthBeginAgain {
        body: Vec<Box<AlephTree>>,
    },
    ForthLeave,
    ForthI,
    ForthJ,
    ForthTick {
        word: String,
    },
    ForthBracketTick {
        word: String,
    },
    ForthLiteral {
        value: Box<AlephTree>,
    },
    ForthPostpone {
        word: String,
    },
    ForthBracket,
    ForthBracketClose,
    ForthImmediate,
    ForthRecursive,
    ForthForget {
        word: String,
    },
    ForthWords,
    ForthSee {
        word: String,
    },
    ForthEvaluate {
        addr: Box<AlephTree>,
        count: Box<AlephTree>,
    },
    ForthSToD {
        value: Box<AlephTree>,
    },
    ForthDToS {
        value: Box<AlephTree>,
    },
    ForthQuit,
    ForthAbort,
    ForthAbortQuote {
        message: String,
    },
    ForthCreate {
        name: String,
        allot_size: Option<Box<AlephTree>>,
        does_body: Option<Vec<Box<AlephTree>>>,
    },
    AdaTaskType {
        name: String,
        discriminants: Option<Vec<Box<AlephTree>>>,
        entries: Vec<Box<AlephTree>>,
        body: Vec<Box<AlephTree>>,
    },
    AdaProtectedType {
        name: String,
        discriminants: Option<Vec<Box<AlephTree>>>,
        declarations: Vec<Box<AlephTree>>,
    },
    AdaProtectedBody {
        name: String,
        bodies: Vec<Box<AlephTree>>,
    },
    AdaAccept {
        entry_name: String,
        parameters: Option<Vec<Box<AlephTree>>>,
        body: Option<Vec<Box<AlephTree>>>,
    },
    AdaSelect {
        alternatives: Vec<Box<AlephTree>>,
        else_clause: Option<Vec<Box<AlephTree>>>,
    },
    AdaSelectiveAccept {
        guard_condition: Option<Box<AlephTree>>,
        accept_stmt: Box<AlephTree>,
        statements: Vec<Box<AlephTree>>,
    },
    AdaDelay {
        delay_type: String,
        expression: Box<AlephTree>,
    },
    AdaAbort {
        tasks: Vec<String>,
    },
    AdaAggregate {
        components: Vec<Box<AlephTree>>,
    },
    AdaComponentAssoc {
        choices: Option<Vec<Box<AlephTree>>>,
        expression: Box<AlephTree>,
    },
    AdaQualified {
        type_name: Box<AlephTree>,
        expression: Box<AlephTree>,
    },
    AdaWith {
        packages: Vec<String>,
    },
}