Enum AlephTree

Source

pub enum AlephTree {
Show 82 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,
    },
    Tuple {
        elems: Vec<Box<AlephTree>>,
    },
    Array {
        elems: Vec<Box<AlephTree>>,
    },
    Neg {
        expr: Box<AlephTree>,
    },
    Not {
        bool_expr: Box<AlephTree>,
    },
    And {
        bool_expr1: Box<AlephTree>,
        bool_expr2: Box<AlephTree>,
    },
    Or {
        bool_expr1: Box<AlephTree>,
        bool_expr2: 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>,
    },
    Eq {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    LE {
        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>,
    },
    Let {
        var: String,
        is_pointer: String,
        value: Box<AlephTree>,
        expr: Box<AlephTree>,
    },
    LetRec {
        name: String,
        args: Vec<Box<AlephTree>>,
        body: 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,
    },
    Match {
        expr: Box<AlephTree>,
        case_list: Vec<Box<AlephTree>>,
    },
    MatchLine {
        condition: Box<AlephTree>,
        case_expr: Box<AlephTree>,
    },
    Var {
        var: String,
        is_pointer: String,
    },
    App {
        object_name: String,
        fun: Box<AlephTree>,
        param_list: Vec<Box<AlephTree>>,
    },
    Stmts {
        expr1: Box<AlephTree>,
        expr2: Box<AlephTree>,
    },
    Iprt {
        name: String,
    },
    Clss {
        name: String,
        attribute_list: Vec<String>,
        body: Box<AlephTree>,
    },
    Return {
        value: Box<AlephTree>,
    },
    Comment {
        value: String,
    },
    CommentMulti {
        value: String,
    },
    Assert {
        condition: Box<AlephTree>,
        message: Box<AlephTree>,
    },
    CobolProgram {
        program_id: String,
        environment_div: Option<Box<AlephTree>>,
        data_div: Option<Box<AlephTree>>,
        procedure_div: Box<AlephTree>,
    },
    EnvironmentDivision {
        config_section: Option<Box<AlephTree>>,
        io_control_section: Option<Box<AlephTree>>,
    },
    DataDivision {
        file_section: Option<Box<AlephTree>>,
        working_storage_section: Option<Box<AlephTree>>,
        linkage_section: Option<Box<AlephTree>>,
    },
    ProcedureDivision {
        using_clause: Option<Vec<String>>,
        statements: Vec<Box<AlephTree>>,
    },
    PicClause {
        data_name: String,
        level_number: String,
        picture: String,
        initial_value: Option<Box<AlephTree>>,
        occurs_clause: Option<String>,
        usage: Option<String>,
    },
    GroupItem {
        data_name: String,
        level_number: String,
        sub_items: Vec<Box<AlephTree>>,
    },
    Redefines {
        data_name: String,
        level_number: String,
        redefined_item: String,
        picture: 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>,
    },
    Move {
        source: Box<AlephTree>,
        target_list: Vec<Box<AlephTree>>,
    },
    Compute {
        target: Box<AlephTree>,
        expression: Box<AlephTree>,
        on_size_error: Option<Box<AlephTree>>,
    },
    Perform {
        target_paragraph: Option<String>,
        from_paragraph: Option<String>,
        through_paragraph: Option<String>,
        times_clause: Option<Box<AlephTree>>,
        until_clause: Option<Box<AlephTree>>,
        varying_clause: Option<Box<AlephTree>>,
        inline_statements: Option<Vec<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>,
    },
    GoTo {
        target_paragraph: String,
        depending_on: Option<Box<AlephTree>>,
    },
    Stop {
        stop_type: String,
    },
    Exit,
    Paragraph {
        name: String,
        statements: Vec<Box<AlephTree>>,
    },
    Section {
        name: String,
        paragraphs: 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>>,
    },
    Inspect {
        inspecting_item: Box<AlephTree>,
        tallying_clause: Option<Box<AlephTree>>,
        replacing_clause: Option<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>>,
    },
    Call {
        program_name: Box<AlephTree>,
        using_parameters: Option<Vec<Box<AlephTree>>>,
        giving_parameter: Option<Box<AlephTree>>,
        on_exception: Option<Box<AlephTree>>,
    },
    QualifiedName {
        data_name: String,
        qualifier_list: Vec<String>,
    },
    Subscript {
        data_name: String,
        subscript_list: Vec<Box<AlephTree>>,
    },
    Figurative {
        figurative_type: String,
    },
    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>>,
    },
    HexLiteral {
        value: String,
    },
    UsageClause {
        usage_type: String,
    },
}