Changes between Version 37 and Version 38 of AST


Ignore:
Timestamp:
04/25/11 14:21:37 (15 years ago)
Author:
Stephen Siegel
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • AST

    v37 v38  
    8080    * methods
    8181       * referent: ASTNodeIF
    82        * identifier: string
    83     * LabelReferenceNodeIF
    84        * methods
    85            * referent: LabelNodeIF
    86     * EnumElementReferenceNodeIF
    87        * methods
    88            * EnumElementNodeIF
    89     * StatementReferenceNodeIF
    90        * methods
    91            * StatementNodeIF
     82       * identifier: string ?
    9283 * IdentifierNodeIF: wraps a string. represents an identifier occurrence in code.   Has 0 children, i.e., is a leaf node.
    9384    * methods
    … …  
    111102        * no children
    112103    * ArrayTypeNodeIF: an array type
    113        * methods
    114           * elementType: TypeNodeIF (child 0)
     104       * children
     105          * elementType: TypeNodeIF
    115106          * extent: ?  This is complicated.   The extent might be an expression involving input variables.
    116107    * PointerTypeNodeIF
    117        * methods
    118            * baseType: TypeNodeIF (child 0)
     108       * children
     109           * baseType: TypeNodeIF
    119110    * CompositeTypeNodeIF: "struct" or "union" in C
    120        * methods
    121           * struct or union?: boolean
     111       * children
    122112          * name: IdentifierNodeIF
    123           * numFields: int
    124           * field(int i): PairNode<IdentifierNodeIF,TypeNodeIF>
    125           * fields: Iterator<PairNode<IdentifierNodeIF,TypeNodeIF>>
     113          * fields: SequenceNode<PairNode<IdentifierNodeIF,TypeNodeIF>>
     114       * methods
     115          * isUnion: boolean         
    126116    * FunctionTypeNodeIF
    127        * methods
    128           * numInputs: int
    129           * inputType(int i): TypeNodeIF
    130           * inputTypes: Iterator<TypeNodeIF>
     117       * children
     118          * inputTypes: SequenceNode<TypeNodeIF>
     119          * outputType: TypeNodeIF
    131120    * EnumerationTypeNodeIF
    132        * methods
    133           * name: IdentifierNodeIF
    134           * numElements: int
    135           * element(int i): PairNode<IdentifierNodeIF, LiteralNodeIF>
    136           * elements: Iterator<PairNode<IdentifierNodeIF, LiteralNodeIF>>
     121       * children
     122          * SequenceNode<PairNode<IdentifierNodeIF, LiteralNodeIF>>
    137123 * VariableDeclarationNodeIF
    138124   * Every variable is defined at one unique location in the code.   The variable can be declared in several places.   Each declaration has an associated definition.  There can be many decls associated to one def.    This is a linking thing: a single variable that is to be used in several files will be defined in one file but be declared in all
    139     * methods
    140        * isDefinition: boolean : is this the defining declaration?
    141        * definition: VariableDeclarationNodeIF  : the defining declaration (may be null at first)
    142        * scope: ScopeIF
     125    * children
    143126       * name: IdentifierNodeIF
    144127       * type: TypeNodeIF
     128       * initializer: ExpressionNodeIF : the initialization expression for this variable.  May be null.   Only a defining node an have such an expression.
     129       * definition: VariableDeclarationNodeIF  : the defining declaration (may be null at first)
     130    * methods
     131       * isDefinition: boolean : is this the defining declaration?
     132       * scope: ScopeIF
    145133       * typeQualifier: CONST, VOLATILE
    146134       * storageClass: EXTERNAL, AUTO, STATIC, REGISTER
    147        * initializer: ExpressionNodeIF : the initialization expression for this variable.  May be null.   Only a defining node an have such an expression.
    148135 * FunctionDeclarationNodeIF
    149136    * analogous to situation with variables, with the function body playing the role of variable initializer.  I.e., a function may have several declarations ("prototypes" in C), but only one definition (i.e., one with a body).
    … …  
    163150       * type: TypeNodeIF  (type being assigned a name)
    164151 * LabelNodeIF: a label preceding a statement
    165     * methods
    166         * statement: StatementReferenceNodeIF : the statement this label precedes (this may be null at first)
    167         * identifier: IdentifierNodeIF: the name of this label
     152    * children
     153        * identifier: IdentifierNodeIF: the name of this label (child)
     154    * methods
     155        * statement: StatementNodeIF : the statement this label precedes (this may be null at first)
    168156 * StatementNodeIF
    169157    * methods