Enum AlephTree

Source

pub enum AlephTree {
Show 180 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,
    },
    ForthDef {
        name: String,
        body: Vec<Box<AlephTree>>,
        is_immediate: bool,
    },
    ForthConst {
        name: String,
        value: Box<AlephTree>,
    },
    ForthVar {
        name: String,
    },
    ForthCreate {
        name: String,
        allot_size: Option<Box<AlephTree>>,
        does_body: Option<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,
    ForthMod,
    ForthDivMod,
    ForthMulDiv,
    ForthMulDivMod,
    ForthOnePlus,
    ForthOneMinus,
    ForthTwoMul,
    ForthTwoDiv,
    ForthAbs,
    ForthNegate,
    ForthMin,
    ForthMax,
    ForthXor,
    ForthInvert,
    ForthLShift,
    ForthRShift,
    ForthNotEq,
    ForthLessThan,
    ForthGreater,
    ForthGreaterEq,
    ForthZeroEq,
    ForthZeroNotEq,
    ForthZeroLess,
    ForthZeroGreater,
    ForthFetch,
    ForthStore,
    ForthPlusStore,
    ForthCFetch,
    ForthCStore,
    ForthCells,
    ForthAllot,
    ForthComma,
    ForthCComma,
    ForthHere,
    ForthDot,
    ForthEmit,
    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>>,
    },
    ForthDoLoop {
        body: Vec<Box<AlephTree>>,
    },
    ForthDoPlusLoop {
        body: Vec<Box<AlephTree>>,
        increment: Box<AlephTree>,
    },
    ForthLeave,
    ForthCase {
        when_clauses: Vec<Box<AlephTree>>,
        default: Option<Vec<Box<AlephTree>>>,
    },
    ForthOf {
        value: Box<AlephTree>,
        body: Vec<Box<AlephTree>>,
    },
    ForthI,
    ForthJ,
    ForthTick {
        word: String,
    },
    ForthBracketTick {
        word: String,
    },
    ForthExecute {
        xt: Box<AlephTree>,
    },
    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,
    ForthDToS,
    ForthQuit,
    ForthAbort,
    ForthAbortQuote {
        message: String,
    },
    ForthComment {
        text: String,
    },
    ForthLineComment {
        text: String,
    },
    ForthHex {
        value: String,
    },
    ForthProgram {
        definitions: Vec<Box<AlephTree>>,
    },
    ForthSequence {
        words: Vec<Box<AlephTree>>,
    },
}