Changeset 2981


Ignore:
Timestamp:
Mar 28, 2013, 7:02:08 PM (5 years ago)
Author:
ksherdy
Message:

Grammar updates. Eliminated optional fw on stream types. Removed typedef.

Location:
proto/pabloj/trunk
Files:
6 added
3 deleted
53 edited
6 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/docs/notes

    r2972 r2981  
    1212
    1313================================================================================
     14PabloS Builtins
     15================================================================================
     16
     17TODO
     18
     191. Add field width to pablo.operation builtin calls.
     20        e.g. pablo.operation() -> pablos.operation<fw>(...)
     21
     22================================================================================
    1423PabloS Types
    1524================================================================================
     
    19282. 2^k stream types are initialized to simd<k>::constant(0).
    2029
    21 3. Mask?
     303. Mask(2^k, constantValue) can be used to initialized stream<2^k> primitives.
    2231
    2332================================================================================
     
    2635
    27361. All PabloS conditional expression E are wrapped in BitBlock::any(E) calls.
     37
     38================================================================================
     39PabloB Memory and Block-at-a-time Processing Model
     40================================================================================
     41
     421. Pass by reference.
     43
     44   TODO - Think this out.
     45
     46   Call-out streams are re-initialized (reset to zero) on each block iteration.
     47
     48   
    2849
    2950================================================================================
  • proto/pabloj/trunk/input/grammar/scatter/pabloB.scatter

    r2919 r2981  
    33// 2-December-2012
    44//
    5 // PabloBlock (block-at-a-time language)
     5// PabloB (block-at-a-time language)
    66//
    77// Type System
     
    1717// BitBlock - a special type that evaluates uint128 or uint256
    1818//            at compile time based on the target architecture
    19 // Boolean
     19//
    2020// String Constant
    2121//
    2222// Compound Types
    2323//
    24 // ...
     24// Stream Structure (record type)
    2525//
    2626// Comments
     
    5656  tokens {
    5757 
     58        INIT,
    5859        VAR,
    5960        KERNEL,
     
    6263        STRUCT,
    6364        VOID,
    64         INIT,
    65                
     65       
     66        UINT8,
     67        UINT16,
     68        UINT32,
     69        UINT64,
     70        UINT128,
     71        UINT256,
     72        // BITBLOCK // alias for architecture dependent SIMD instruction width
     73       
    6674        IF,
    6775        ELSE,
     
    6977        RETURN,
    7078
    71         AND   "&",
    72         OR    "|",
    73         NOT   "~",
    74         XOR   "^",
    7579        ASSIGN      "=",
    76         AND_ASSIGN  "&=",
    77         OR_ASSIGN   "|=",
    78         XOR_ASSIGN  "^=",       
    7980        LANGLE          "<",
    8081        RANGLE          ">",
     
    9091        TERMINATOR  ";",
    9192        DOT                     ".",
    92         MINUS           "-",
     93       
    9394  }
    9495}
     
    100101
    101102nodes {
    102   binaryOperator {} [expr, expr1],//, expr4],
    103   unaryOperator {} [expr2],// expr5],
    104103  assign {} [assignRest],
    105104  funcCall {} [funcCallRest],
     105  idisaCall {} [idisaCallRest],
    106106  integerConstant{intValued;} [],
    107107  streamConstant{intValued;} [],
     
    176176        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    177177                       
    178         funcCallOrAssignStmt    -> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
     178        funcCallOrAssignStmt    -> compoundIdentifier ( (idisaCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
    179179       
    180180        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
    181 
    182         funcCallArgList                 -> (expr (COMMA expr)*)? ;     
    183                
    184         assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
     181       
     182        funcCallArgList                 -> (expr (COMMA expr)*)? ;
     183       
     184        idisaCallRest                   -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
     185
     186        idisaCallArgList                -> (expr (COMMA expr)*)? ;     
     187               
     188        assignOperator                  -> ASSIGN;                             
    185189                                       
    186190        assignRest                              -> assignOperator^! expr ;                             
     
    192196        returnStmt                              -> RETURN (expr)? TERMINATOR ;
    193197                       
    194         localVarDecl                    -> VAR type VarName (assignOperator^! expr) ? ;
    195                
    196         VarName                                 #-> identifier ;
     198        localVarDecl                    -> VAR type varName (assignOperator^! expr) ? ;
     199               
     200        varName                                 #-> identifier ;
    197201
    198202        blockStmt                               -> LCURLY stmt* RCURLY ;
     
    201205        // e x p r e s s i o n s
    202206        //     
    203         expr            #->     expr1 ((OR^|XOR^) expr)? ;
    204                                        
    205         expr1           #-> expr2 ((AND^) expr1)? ;
    206                                        
    207         expr2           #-> NOT^^? expr3  _leftAssoc_;
    208        
    209         expr3           #-> LROUND expr RROUND
    210                                         | streamConstant
     207        expr            #-> integerConstant
    211208                                        | stringConstant
    212                                         | compoundIdentifier (funcCallRest _promote_)?
     209                                        | compoundIdentifier (funcCallRest _promote_ | idisaCallRest _promote_)?
    213210                                        ;
    214211                                                                                                                                                                                       
    215         constant                                #->  stringConstant | signedIntegerConstant ; 
    216                
    217         streamConstant                  -> INTEGER_CONST {@value = @@value;} ;
    218        
    219         signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
    220                                             | integerConstant ;
    221                                            
     212        constant                                #->  stringConstant | integerConstant ; 
     213                                                                   
    222214        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
    223215       
     
    226218        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
    227219                                                       
    228         identifier                              -> IDENTIFIER ;
     220        identifier                              -> IDENTIFIER ;   
    229221       
    230222    //   
     
    236228        //
    237229
    238         type                    #->  streamType | structType | void | identifier ; // | tupleType;
     230        type                    #->  streamType | structType | void | identifier | integerType ; // | tupleType;
    239231       
    240232        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
     
    243235       
    244236        streamTypeName  #->     identifier ;                           
     237               
     238        integerType             -> UINT8 | UINT16 | UINT32 | UINT64 | UINT128 | UINT256 ;       
    245239               
    246240        //     
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r2968 r2981  
    2828  tokens {
    2929 
    30         TYPEDEF,
     30//      TYPEDEF,
    3131        VAR,
    3232        FUNCTION,       
     
    7070
    7171nodes {
    72   binaryOperator {} [expr, expr1],//, expr4],
     72  binaryOperator {} [expr expr1],//, expr4],
    7373  unaryOperator {} [expr2],// expr5],
    7474  assign {} [assignRest],
    7575  funcCall {} [funcCallRest],
    76  // streamConstant{intValued;} [],
     76  // streamCall {} [streamCallRest],
    7777  integerConstant{intValued;} [],
    7878}
    7979
    8080grammar {
    81         program         -> (typeDecl | typeDef | funcDef) *;
     81        program         -> (typeDecl | funcDef) *; // | typeDef // not implemented
    8282
    8383        //
     
    8989        typeDecl                ->  type TERMINATOR ;
    9090               
    91         typeDef                 ->  TYPEDEF type identifier TERMINATOR ;
     91        // typeDef                      ->  TYPEDEF type identifier TERMINATOR ; // not implemented
    9292       
    9393        // DeclList             ->  identifier (COMMA identifier)* ; 
     
    118118        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    119119                       
    120         funcCallOrAssignStmt    #-> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ;
     120        funcCallOrAssignStmt    #-> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ; // | (idisaCallRest _promote_)
    121121       
    122122        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
    123123
    124124        funcCallArgList                 -> (expr (COMMA expr)*) ? ;     
     125               
     126        // streamCallRest                       -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
     127
     128        // streamCallArgList            -> (expr (COMMA expr)*)? ;             
    125129               
    126130        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
     
    134138        returnStmt                              -> RETURN (expr)? TERMINATOR;
    135139                       
    136         localVarDecl                    -> VAR type VarName (localVarAssignOperator^! expr) ?;
     140        localVarDecl                    -> VAR type varName (localVarAssignOperator^! expr) ?;
    137141       
    138142        localVarAssignOperator  -> ASSIGN ;
    139143               
    140         VarName                                 #-> identifier; // compoundIdentifier ?
     144        varName                                 #-> identifier; // compoundIdentifier ?
    141145
    142146        blockStmt                               -> LCURLY stmt* RCURLY ;
     
    168172                                                                                                                                                                                                                                                                       
    169173        constant                #-> stringConstant | integerConstant ;
    170                
    171         // streamConstant               -> INTEGER_CONST {@value = @@value;} ;
    172                                            
     174                                                           
    173175        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
    174176       
     
    189191        type                    #->  streamType | structType | void | identifier ; // | tupleType;
    190192       
    191         streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
     193        streamType              ->      STREAM LANGLE fieldWidth RANGLE ;       
    192194                                       
    193195        fieldWidth              ->  integerConstant ;   
    194        
    195         streamTypeName  #->     identifier ;                           
     196                                       
    196197       
    197198        // c o m p o u n d   t y p e s
  • proto/pabloj/trunk/input/test/pabloB/statements/idisa/idisa1.pablob

    r2956 r2981  
    33kernel BasisBits
    44{
    5         init
     5        init 
    66        {
    7                 carry1[1] = {0};
    8                 carryN[1] = {1};
     7         
    98        }
    109
    11         function void do_block ()
     10        function void do_block()
    1211        {
    13                 var stream s = 0;
     12               
     13                simd.add<
    1414        }
    1515
    16         function void do_final_block(stream EOF_mask)
    17         {
    18        
    19         }
    20 
    21 }       
     16};     
  • proto/pabloj/trunk/input/test/pabloS/decl/decl1.pablos

    r2834 r2981  
    11struct BasisBits {
    2         stream b1;
    3         stream b2;
    4         stream b3;
    5         stream b4;
     2        stream<1> b1;
     3        stream<1> b2;
     4        stream<1> b3;
     5        stream<1> b4;
    66};
    77
  • proto/pabloj/trunk/input/test/pabloS/decl/decl3.pablos.exclude

    r2834 r2981  
    1 //tuple Streams (stream, stream);
     1//tuple Streams (stream<1>, stream<1>);
    22//tuple Streams (stream<1>, stream<8>);
  • proto/pabloj/trunk/input/test/pabloS/funcDef/funcDef1.pablos

    r2834 r2981  
    11struct B
    22{
    3         stream a;
    4         stream a;
    5         stream a;
    6         stream a;
     3        stream<1> a;
     4        stream<1> a;
     5        stream<1> a;
     6        stream<1> a;
    77};
    88
  • proto/pabloj/trunk/input/test/pabloS/funcDef/funcDef2.pablos

    r2834 r2981  
    11struct bb {
    2         stream a;
     2        stream<1> a;
    33
    44};
    55
    66/*
    7 function stream Function(stream a, stream b, stream c) {
     7function stream<1> Function(stream<1> a, stream<1> b, stream<1> c) {
    88
    99
  • proto/pabloj/trunk/input/test/pabloS/funcDef/funcDef4.pablos.exclude

    r2834 r2981  
    1 //function tuple T Foo(stream a, stream b) {};
     1//function tuple T Foo(stream<1> a, stream<1> b) {};
  • proto/pabloj/trunk/input/test/pabloS/py2pablo/parabix2_pablo.pablos

    r2972 r2981  
    218218    u8.unibyte = (~ basis_bits.bit_0);
    219219    u8.suffix = pablo.Mask(1,0);
    220     var stream<1> u8_error;
    221     var stream<1> u8_FFFE_FFFF;
    222     var stream<1> u8anyscope;
     220    var stream<1> u8_error = pablo.Mask(1,0);
     221    var stream<1> u8_FFFE_FFFF = pablo.Mask(1,0);
     222    var stream<1> u8anyscope = pablo.Mask(1,0);
    223223    if (basis_bits.bit_0) {
    224224        u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     
    287287    ctCDPI_Callouts.PI_name_ends = pablo.Mask(1,0);
    288288    ctCDPI_Callouts.PI_ends = pablo.Mask(1,0);
    289     var stream<1> CtCDPI_starts;
    290     var stream<1> CtCDPI_ends;
    291     var stream<1> ctCDPI_mask;
     289    var stream<1> CtCDPI_starts = pablo.Mask(1,0);
     290    var stream<1> CtCDPI_ends = pablo.Mask(1,0);
     291    var stream<1> ctCDPI_mask = pablo.Mask(1,0);
    292292    var stream<1> v = (lex.LAngle | lex.Hyphen);
    293293    var stream<1> w = (lex.Hyphen | lex.QMark);
     
    298298    var stream<1> CtCD_opener = (LAngle_scope & lex.Exclam);
    299299    var stream<1> CtCDPI_opener = (PI_opener | CtCD_opener);
    300     var stream<1> CD_closer;
     300    var stream<1> CD_closer = pablo.Mask(1,0);
    301301    var stream<1> DoubleHyphen = ((v1 & w1) & lex.Hyphen);
    302302    if (lex.RBracket) {
     
    354354
    355355function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    356     var stream<1> EqExpected;
    357     var stream<1> AttListEnd;
     356    var stream<1> EqExpected = pablo.Mask(1,0);
     357    var stream<1> AttListEnd = pablo.Mask(1,0);
    358358    var stream<1> DQuoteDelim = (lex.DQuote | lex.LAngle);
    359359    var stream<1> SQuoteDelim = (lex.SQuote | lex.LAngle);
     
    428428    ref_Callouts.HexRef_starts = pablo.Mask(1,0);
    429429    ref_Callouts.HexRef_ends = pablo.Mask(1,0);
    430     var stream<1> ref_error;
     430    var stream<1> ref_error = pablo.Mask(1,0);
    431431    if (marker.Ref_opener) {
    432432        var stream<1> Ref_scope = pablo.Advance(marker.Ref_opener);
     
    475475    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
    476476}
    477 /*
    478 function void Main(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, struct Xml_char xml_char, struct Scope1 scope1, struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Masks masks, struct Xml_names xml_names, struct Check_streams check_streams) {
    479     Classify_bytes_Validate_utf8(basis_bits, lex, u8);
    480     Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams);
    481     Parse_tags(lex, marker, tag_Callouts);
    482     Parse_refs(lex, marker, ref_Callouts);
    483     Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
    484     Do_check_streams(marker, tag_Callouts, check_streams);
    485 }*/
  • proto/pabloj/trunk/input/test/pabloS/statements/assign/assign1.pablos

    r2834 r2981  
    11function void Assignments() {
    2         var stream s;
     2        var stream<1> s;
    33        s = 0;
    44        s &= 0;
  • proto/pabloj/trunk/input/test/pabloS/statements/assign/assign7.pablos

    r2834 r2981  
    11function void Assignments() {
    2         var stream s;
    3         var stream a;
    4         var stream b;
    5         var stream c;
     2        var stream<1> s;
     3        var stream<1> a;
     4        var stream<1> b;
     5        var stream<1> c;
    66        //s |= 0;
    77        //s = a | b | c;
  • proto/pabloj/trunk/input/test/pabloS/statements/localDecl/localDecl1.pablos

    r2834 r2981  
    22
    33        var struct BasisBits {
    4         stream b1;
    5         stream b2;
    6         stream b3;
    7         stream b4;
     4        stream<1> b1;
     5        stream<1> b2;
     6        stream<1> b3;
     7        stream<1> b4;
    88        } A;
    99
  • proto/pabloj/trunk/input/test/pabloS/statements/localDecl/localDecl4.pablos

    r2834 r2981  
    11function void localDecl() {
    2         var stream A;
    3         var stream A=0;
     2        var stream<1> A;
     3        var stream<1> A=0;
    44}
  • proto/pabloj/trunk/input/test/pabloS/statements/localDecl/localDecl5.pablos

    r2834 r2981  
    11function void Assignments() {
    2         var stream s = 4;
    3         var stream s &= 4;
    4         var stream s |= 4;
    5 //      var stream s ~= 4;
    6         var stream s ^= 4;
     2        var stream<1> s = 4;
     3        var stream<1> s &= 4;
     4        var stream<1> s |= 4;
     5//      var stream<1> s ~= 4;
     6        var stream<1> s ^= 4;
    77}
  • proto/pabloj/trunk/input/test/pabloS/statements/while/test.pablos.exclude

    r2834 r2981  
    11function void Function() {
    2 var stream cursor = pablo.ScanToFirst(lex.opener);
     2var stream<1> cursor = pablo.ScanToFirst(lex.opener);
    33}
  • proto/pabloj/trunk/input/test/pabloS/statements/while/while1.pablos

    r2975 r2981  
    11function void While() {
    22                       
    3         var stream cursor = 1;
     3        var stream<1> cursor = 1;
    44       
    55        while (cursor) {
  • proto/pabloj/trunk/input/test/pabloS/statements/while/while2.pablos

    r2834 r2981  
    11function void While() {
    22       
    3         var stream cursor;
     3        var stream<1> cursor;
    44       
    55        while (cursor) {
  • proto/pabloj/trunk/input/test/pabloS/statements/while/while3.pablos

    r2834 r2981  
    11function void Function() {     
    2         var stream cursor1;
     2        var stream<1> cursor1;
    33       
    44        while (cursor1) {
    5                 var stream cursor2;
     5                var stream<1> cursor2;
    66                while(cursor2) {
    77                        cursor = pablo.Advance(cursor);
  • proto/pabloj/trunk/input/test/pabloS/statements/while/while4.pablos

    r2834 r2981  
    11function void Function(struct TagCallouts tagCallouts, struct Lex lex) {       
    22
    3         var stream starts_accum = 0;
    4         var stream ends_accum = 0;     
     3        var stream<1> starts_accum = 0;
     4        var stream<1> ends_accum = 0;   
    55       
    6         var stream cursor = pablo.ScanToFirst(lex.opener);
     6        var stream<1> cursor = pablo.ScanToFirst(lex.opener);
    77       
    88        while (cursor) {
  • proto/pabloj/trunk/input/test/pabloS/typedef/typedef1.pablos.exclude

    r2956 r2981  
    11typedef struct BasisBits {
    2 stream b1;
    3 stream b2;
    4 stream b3;
    5 stream b4;
     2stream<1> b1;
     3stream<1> b2;
     4stream<1> b3;
     5stream<1> b4;
    66} BasisBitsAlias;
  • proto/pabloj/trunk/input/test/pabloS/typedef/typedef3.pablos.exclude

    r2956 r2981  
    1 typedef stream s;
    2 
    31typedef stream<1> s1;
  • proto/pabloj/trunk/input/test/pabloS/typedef/typedef4.pablos.exclude

    r2956 r2981  
    11struct Lex {
    2         stream LAngle;
    3         stream RAngle;
     2        stream<1> LAngle;
     3        stream<1> RAngle;
    44};
    55
  • proto/pabloj/trunk/input/test/visitors/AdvanceCombinerXFormer/advance.pablos

    r2834 r2981  
    11function void Test() {
    2         var stream temp;
    3         var stream X = 0;
     2        var stream<1> temp;
     3        var stream<1> X = 0;
    44       
    55        temp = pablo.Advance(X);                       
  • proto/pabloj/trunk/input/test/visitors/AdvanceNCounterVisitor/advanceNCounter.pablos

    r2834 r2981  
    11function void Test() {
    2         var stream temp;
    3         var stream C = 0;
    4         var stream X = 0;
    5         var stream R = 0;
     2        var stream<1> temp;
     3        var stream<1> C = 0;
     4        var stream<1> X = 0;
     5        var stream<1> R = 0;
    66
    77        //R = Advance(X);
  • proto/pabloj/trunk/input/test/visitors/AugmentedAssignmentXFormer/augmentedAssignment.pablos

    r2834 r2981  
    11function void Test() {
    2         var stream x;
    3         var stream y;
    4         var stream z;
     2        var stream<1> x;
     3        var stream<1> y;
     4        var stream<1> z;
    55
    66        x = x | y;                      // Expected
  • proto/pabloj/trunk/input/test/visitors/Bitwise2IDISAXFormer/bitwise2IDISA.pablos

    r2834 r2981  
    99*/     
    1010
    11         var stream x;
    12         var stream y;
    13         var stream r;
     11        var stream<1> x;
     12        var stream<1> y;
     13        var stream<1> r;
    1414       
    1515        r = simd_and(x,y);              // Expected
  • proto/pabloj/trunk/input/test/visitors/CarryCounterVisitor/carryCounter.pablos

    r2834 r2981  
    11function void Test() {
    2         var stream temp;
    3         var stream C = 0;
    4         var stream X = 0;
    5         var stream R = 0;
     2        var stream<1> temp;
     3        var stream<1> C = 0;
     4        var stream<1> X = 0;
     5        var stream<1> R = 0;
    66       
    77        R = Advance(X);
  • proto/pabloj/trunk/input/test/visitors/CarryInitToOneListVisitor/carryInitToOneList.pablos

    r2834 r2981  
    11function void Test() {
    2         var stream temp;
    3         var stream C = 0;
    4         var stream X = 0;
    5         var stream R = 0;
     2        var stream<1> temp;
     3        var stream<1> C = 0;
     4        var stream<1> X = 0;
     5        var stream<1> R = 0;
    66       
    77        R = Advance(X);
  • proto/pabloj/trunk/input/test/visitors/CarryIntroXFormer/FinalBlock/pablo2CarryQ.pablos

    r2975 r2981  
    11function void Test() {
    2         var stream temp;
    3         var stream C;   // Cursor stream
    4         var stream M;   // Marker stream
    5         var stream R;   // Result stream
     2        var stream<1> temp;
     3        var stream<1> C;        // Cursor stream<1>
     4        var stream<1> M;        // Marker stream<1>
     5        var stream<1> R;        // Result stream<1>
    66       
    77        // TODO - UPDATE EXPECTED RESULTS
  • proto/pabloj/trunk/input/test/visitors/CarryIntroXFormer/NotFinalBlock/atEOF.pablos

    r2834 r2981  
    33        var stream<1> R;
    44               
    5         /*
     5        /*      TODO
    66        simd<1>::constant<0>();
    77        atEOF(X);
  • proto/pabloj/trunk/input/test/visitors/CarryIntroXFormer/NotFinalBlock/pablo2CarryQ.pablos

    r2975 r2981  
    11function void Test() {
    2         var stream temp;
    3         var stream C;   // Cursor stream
    4         var stream M;   // Marker stream
    5         var stream R;   // Result stream
     2        var stream<1> temp;
     3        var stream<1> C;        // Cursor stream<1>
     4        var stream<1> M;        // Marker stream<1>
     5        var stream<1> R;        // Result stream<1>
    66       
    77        // TODO - UPDATE EXPECTED RESULTS
  • proto/pabloj/trunk/runConfigurations/PabloBAST.launch

    r2956 r2981  
    22<launchConfiguration type="org.eclipse.jdt.launching.localJavaApplication">
    33<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
    4 <listEntry value="/pabloj/src/test/pabloB/grammar/TestPabloBAST.java"/>
     4<listEntry value="/pabloj/src/test/pabloB/PabloBAST.java"/>
    55</listAttribute>
    66<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
    77<listEntry value="1"/>
    88</listAttribute>
    9 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="test.pabloB.grammar.TestPabloBAST"/>
    10 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/pabloB"/>
     9<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="test.pabloB.PabloBAST"/>
     10<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/pabloB/statements/idisa"/>
    1111<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1212</launchConfiguration>
  • proto/pabloj/trunk/runConfigurations/PabloSAST.launch

    r2956 r2981  
    33<stringAttribute key="bad_container_name" value="/pabloj/runConfigurations/testPabloSAST"/>
    44<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
    5 <listEntry value="/pabloj/src/test/pabloS/grammar/TestPabloSAST.java"/>
     5<listEntry value="/pabloj/src/test/pabloS/PabloSAST.java"/>
    66</listAttribute>
    77<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
    88<listEntry value="1"/>
    99</listAttribute>
    10 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="test.pabloS.grammar.TestPabloSAST"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/pabloS/statements/while"/>
     10<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="test.pabloS.PabloSAST"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/visitors/Bitwise2IDISAXFormer"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313</launchConfiguration>
  • proto/pabloj/trunk/runConfigurations/PabloSTestHarness.launch

    r2835 r2981  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="test.pabloS.PabloSTestHarness"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${project_loc}/input/test/visitors"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${project_loc}/input/test/visitors/"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pabloj/trunk/src/applicationGenerator/ApplicationGenerator.java

    r2972 r2981  
    5656                PabloSBuiltins2Lang builtins2Lang               = null;
    5757                CarrySetBuiltins2Lang carrySet2Lang     = null;
    58                 Unparser unparser                                       = null;
     58                Unparser unparser                                               = null;
    5959               
    6060                if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
  • proto/pabloj/trunk/src/compilers/pabloB/ast/Accessors.java

    r2952 r2981  
    221221       
    222222        ////////////////////////////////////////////////////////////////////////////
    223         // Unary Operators
    224         ////////////////////////////////////////////////////////////////////////////                   
    225         public static ASTNode operand(UnaryOperatorNode node) {
    226                 return node.child(0);
    227         }
    228 
    229         public static String operatorLexeme(UnaryOperatorNode node) {
    230                 return node.getToken().getLexeme();
    231         }
    232        
    233         ////////////////////////////////////////////////////////////////////////////
    234         // Binary Operators
    235         ////////////////////////////////////////////////////////////////////////////           
    236         public static ASTNode lhs(BinaryOperatorNode node) {
    237                 return node.child(0);
    238         }               
    239 
    240         public static ASTNode rhs(BinaryOperatorNode node) {
    241                 return node.child(1);
    242         }
    243        
    244         public static String operatorLexeme(BinaryOperatorNode node) {
    245                 return node.getToken().getLexeme();
    246         }               
    247 
    248         ////////////////////////////////////////////////////////////////////////////
    249223        // Terminals
    250224        ////////////////////////////////////////////////////////////////////////////
     
    253227        }       
    254228       
    255 
    256229        ////////////////////////////////////////////////////////////////////////////
    257230        // StructTypeNode
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/visitors/CPPUnparser.java

    r2970 r2981  
    369369        ////////////////////////////////////////////////////////////////////////////
    370370       
    371         // BinaryOperator
     371        // BinaryOperator - Deprecated
     372        /*
    372373        public CodeStore visitLeave(BinaryOperatorNode node, List<CodeStore> childResults) {
    373374                CodeStore code = new CodeStore();
     
    397398                return code;
    398399        }
    399 
    400         ////////////////////////////////////////////////////////////////////////////
    401         // UnaryOperator
    402         ////////////////////////////////////////////////////////////////////////////
     400        */
     401
     402        ////////////////////////////////////////////////////////////////////////////
     403        // UnaryOperator - Deprecated
     404        ////////////////////////////////////////////////////////////////////////////
     405        /*
    403406        public CodeStore visitLeave(UnaryOperatorNode node, List<CodeStore> childResults) {
    404407                CodeStore code = new CodeStore();
     
    417420                return code;
    418421        }       
     422        */
    419423       
    420424        private String bracketExpressionCode(String code) {
  • proto/pabloj/trunk/src/compilers/pabloS/lang/types/PrimitiveType.java

    r2978 r2981  
    6868                return this;
    6969        }
    70 
    71         @Override
    72         public boolean isComparable() {
    73                 // TODO Auto-generated method stub
    74                 return false;
    75         }
    7670       
    7771}
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r2962 r2981  
    183183                }
    184184
    185                 /*
     185                /*// - Deprecated
    186186                public void visitEnter(BinaryOperatorNode node) {
    187187                        defaultVisitEnter(node);
     
    189189                */
    190190               
     191                /*// - Deprecated
    191192                public pabloB.ast.ASTNode visitLeave(pabloS.ast.BinaryOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
    192193                        pabloB.ast.ASTNode bNode = new pabloB.ast.BinaryOperatorNode(Generators.makePabloBToken(node.getToken()));                     
     
    194195                        return bNode;
    195196                }
     197                */
    196198
    197199                /*
     
    495497                */
    496498               
     499                /* //- Deprecated
    497500                public pabloB.ast.ASTNode visitLeave(pabloS.ast.TypeDefNode node, List<pabloB.ast.ASTNode> childResults) {
    498501                        throw new RuntimeException(node.getClass().toString() + ": node class not supported.");
    499502                }
     503                */
    500504
    501505                /*
     
    505509                */
    506510               
     511                /* //- Deprecated
    507512                public pabloB.ast.ASTNode visitLeave(pabloS.ast.UnaryOperatorNode node, List<pabloB.ast.ASTNode> childResults) {
    508513                        pabloB.ast.ASTNode bNode = new pabloB.ast.UnaryOperatorNode(Generators.makePabloBToken(node.getToken()));
     
    510515                        return bNode;
    511516                }
    512 
     517                */
     518               
    513519                /*
    514520                public void visitEnter(VoidNode node) {
  • proto/pabloj/trunk/src/pabloB/ast/ASTNode.java

    r2976 r2981  
    141141    }
    142142        public void insertAfterChild(ASTNode node, ASTNode successor) {
    143                 int index = children.indexOf(node);
    144                 insertChildAfter(index, successor);
    145                 successor.setParent(this);
     143        int index = children.indexOf(node);
     144        insertAfterChild(index, successor);
     145        successor.setParent(this);
    146146    }
    147     private void insertChildAfter(int index, ASTNode successor) {
    148             if(index == children.size()-1) {
    149                     children.add(successor);
    150             } else {
    151                     children.add(index+1, successor);
    152             }       
     147    private void insertAfterChild(int index, ASTNode successor) {
     148        if(index == children.size()-1) {
     149            children.add(successor);
     150        }
     151        else {
     152            children.add(index+1, successor);
     153        }       
    153154    }   
    154155
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r2917 r2981  
    1616        public ASTNode visit(AssignOperatorNode node);
    1717
    18         public ASTNode visit(BinaryOperatorNode node);
    19 
    2018        public ASTNode visit(BlockStmtNode node);
    2119
     
    3836        public ASTNode visit(IdentifierNode node);
    3937
     38        public ASTNode visit(IdisaCallArgListNode node);
     39
     40        public ASTNode visit(IdisaCallNode node);
     41
    4042        public ASTNode visit(IfStmtNode node);
    4143
     
    4648        public ASTNode visit(IntegerConstantNode node);
    4749
     50        public ASTNode visit(IntegerTypeNode node);
     51
    4852        public ASTNode visit(KernelDefNode node);
    4953
     
    8185
    8286        public ASTNode visit(TypeDeclNode node);
    83 
    84         public ASTNode visit(UnaryOperatorNode node);
    8587
    8688        public ASTNode visit(VoidNode node);
     
    107109                }
    108110
    109                 public ASTNode visit(BinaryOperatorNode node) {
    110                         return defaultVisit(node);
    111                 }
    112 
    113111                public ASTNode visit(BlockStmtNode node) {
    114112                        return defaultVisit(node);
     
    151149                }
    152150
     151                public ASTNode visit(IdisaCallArgListNode node) {
     152                        return defaultVisit(node);
     153                }
     154
     155                public ASTNode visit(IdisaCallNode node) {
     156                        return defaultVisit(node);
     157                }
     158
    153159                public ASTNode visit(IfStmtNode node) {
    154160                        return defaultVisit(node);
     
    167173                }
    168174
     175                public ASTNode visit(IntegerTypeNode node) {
     176                        return defaultVisit(node);
     177                }
     178
    169179                public ASTNode visit(KernelDefNode node) {
    170180                        return defaultVisit(node);
     
    236246
    237247                public ASTNode visit(TypeDeclNode node) {
    238                         return defaultVisit(node);
    239                 }
    240 
    241                 public ASTNode visit(UnaryOperatorNode node) {
    242248                        return defaultVisit(node);
    243249                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r2917 r2981  
    2020        public T visitLeave(AssignOperatorNode node, List<T> childResults);
    2121
    22         public void visitEnter(BinaryOperatorNode node);
    23         public T visitLeave(BinaryOperatorNode node, List<T> childResults);
    24 
    2522        public void visitEnter(BlockStmtNode node);
    2623        public T visitLeave(BlockStmtNode node, List<T> childResults);
     
    5350        public T visitLeave(IdentifierNode node, List<T> childResults);
    5451
     52        public void visitEnter(IdisaCallArgListNode node);
     53        public T visitLeave(IdisaCallArgListNode node, List<T> childResults);
     54
     55        public void visitEnter(IdisaCallNode node);
     56        public T visitLeave(IdisaCallNode node, List<T> childResults);
     57
    5558        public void visitEnter(IfStmtNode node);
    5659        public T visitLeave(IfStmtNode node, List<T> childResults);
     
    6568        public T visitLeave(IntegerConstantNode node, List<T> childResults);
    6669
     70        public void visitEnter(IntegerTypeNode node);
     71        public T visitLeave(IntegerTypeNode node, List<T> childResults);
     72
    6773        public void visitEnter(KernelDefNode node);
    6874        public T visitLeave(KernelDefNode node, List<T> childResults);
     
    118124        public void visitEnter(TypeDeclNode node);
    119125        public T visitLeave(TypeDeclNode node, List<T> childResults);
    120 
    121         public void visitEnter(UnaryOperatorNode node);
    122         public T visitLeave(UnaryOperatorNode node, List<T> childResults);
    123126
    124127        public void visitEnter(VoidNode node);
     
    166169                }
    167170
    168                 public void visitEnter(BinaryOperatorNode node) {
    169                         defaultVisitEnter(node);
    170                 }
    171                 public T visitLeave(BinaryOperatorNode node, List<T> childResults) {
    172                         return defaultVisitLeave(node);
    173                 }
    174 
    175171                public void visitEnter(BlockStmtNode node) {
    176172                        defaultVisitEnter(node);
     
    243239                }
    244240
     241                public void visitEnter(IdisaCallArgListNode node) {
     242                        defaultVisitEnter(node);
     243                }
     244                public T visitLeave(IdisaCallArgListNode node, List<T> childResults) {
     245                        return defaultVisitLeave(node);
     246                }
     247
     248                public void visitEnter(IdisaCallNode node) {
     249                        defaultVisitEnter(node);
     250                }
     251                public T visitLeave(IdisaCallNode node, List<T> childResults) {
     252                        return defaultVisitLeave(node);
     253                }
     254
    245255                public void visitEnter(IfStmtNode node) {
    246256                        defaultVisitEnter(node);
     
    271281                }
    272282
     283                public void visitEnter(IntegerTypeNode node) {
     284                        defaultVisitEnter(node);
     285                }
     286                public T visitLeave(IntegerTypeNode node, List<T> childResults) {
     287                        return defaultVisitLeave(node);
     288                }
     289
    273290                public void visitEnter(KernelDefNode node) {
    274291                        defaultVisitEnter(node);
     
    394411                }
    395412                public T visitLeave(TypeDeclNode node, List<T> childResults) {
    396                         return defaultVisitLeave(node);
    397                 }
    398 
    399                 public void visitEnter(UnaryOperatorNode node) {
    400                         defaultVisitEnter(node);
    401                 }
    402                 public T visitLeave(UnaryOperatorNode node, List<T> childResults) {
    403413                        return defaultVisitLeave(node);
    404414                }
  • proto/pabloj/trunk/src/pabloB/ast/IntValuedNodeType.java

    r2834 r2981  
    1010
    1111        public int getValue();
    12         public void setValue(int scatterValueX);
     12        public void setValue(int _value_);
    1313       
    1414
  • proto/pabloj/trunk/src/pabloB/ast/IntegerConstantNode.java

    r2834 r2981  
    3939                return value;
    4040        }
    41         public void setValue(int scatterValueX) {
    42                 value = scatterValueX;
     41        public void setValue(int _value_) {
     42                value = _value_;
    4343        }
    4444       
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r2917 r2981  
    1717        public void visit(AssignOperatorNode node);
    1818
    19         public void visit(BinaryOperatorNode node);
    20 
    2119        public void visit(BlockStmtNode node);
    2220
     
    3937        public void visit(IdentifierNode node);
    4038
     39        public void visit(IdisaCallArgListNode node);
     40
     41        public void visit(IdisaCallNode node);
     42
    4143        public void visit(IfStmtNode node);
    4244
     
    4749        public void visit(IntegerConstantNode node);
    4850
     51        public void visit(IntegerTypeNode node);
     52
    4953        public void visit(KernelDefNode node);
    5054
     
    8286
    8387        public void visit(TypeDeclNode node);
    84 
    85         public void visit(UnaryOperatorNode node);
    8688
    8789        public void visit(VoidNode node);
     
    108110                }
    109111
    110                 public void visit(BinaryOperatorNode node) {
    111                         defaultVisit(node);
    112                 }
    113 
    114112                public void visit(BlockStmtNode node) {
    115113                        defaultVisit(node);
     
    152150                }
    153151
     152                public void visit(IdisaCallArgListNode node) {
     153                        defaultVisit(node);
     154                }
     155
     156                public void visit(IdisaCallNode node) {
     157                        defaultVisit(node);
     158                }
     159
    154160                public void visit(IfStmtNode node) {
    155161                        defaultVisit(node);
     
    168174                }
    169175
     176                public void visit(IntegerTypeNode node) {
     177                        defaultVisit(node);
     178                }
     179
    170180                public void visit(KernelDefNode node) {
    171181                        defaultVisit(node);
     
    237247
    238248                public void visit(TypeDeclNode node) {
    239                         defaultVisit(node);
    240                 }
    241 
    242                 public void visit(UnaryOperatorNode node) {
    243249                        defaultVisit(node);
    244250                }
  • proto/pabloj/trunk/src/pabloB/ast/StreamConstantNode.java

    r2834 r2981  
    3939                return value;
    4040        }
    41         public void setValue(int scatterValueX) {
    42                 value = scatterValueX;
     41        public void setValue(int _value_) {
     42                value = _value_;
    4343        }
    4444       
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r2917 r2981  
    1818        public void visitLeave(AssignOperatorNode node);
    1919
    20         public void visitEnter(BinaryOperatorNode node);
    21         public void visitLeave(BinaryOperatorNode node);
    22 
    2320        public void visitEnter(BlockStmtNode node);
    2421        public void visitLeave(BlockStmtNode node);
     
    5148        public void visitLeave(IdentifierNode node);
    5249
     50        public void visitEnter(IdisaCallArgListNode node);
     51        public void visitLeave(IdisaCallArgListNode node);
     52
     53        public void visitEnter(IdisaCallNode node);
     54        public void visitLeave(IdisaCallNode node);
     55
    5356        public void visitEnter(IfStmtNode node);
    5457        public void visitLeave(IfStmtNode node);
     
    6366        public void visitLeave(IntegerConstantNode node);
    6467
     68        public void visitEnter(IntegerTypeNode node);
     69        public void visitLeave(IntegerTypeNode node);
     70
    6571        public void visitEnter(KernelDefNode node);
    6672        public void visitLeave(KernelDefNode node);
     
    116122        public void visitEnter(TypeDeclNode node);
    117123        public void visitLeave(TypeDeclNode node);
    118 
    119         public void visitEnter(UnaryOperatorNode node);
    120         public void visitLeave(UnaryOperatorNode node);
    121124
    122125        public void visitEnter(VoidNode node);
     
    163166                }
    164167
    165                 public void visitEnter(BinaryOperatorNode node) {
    166                         defaultVisitEnter(node);
    167                 }
    168                 public void visitLeave(BinaryOperatorNode node) {
    169                         defaultVisitLeave(node);
    170                 }
    171 
    172168                public void visitEnter(BlockStmtNode node) {
    173169                        defaultVisitEnter(node);
     
    240236                }
    241237
     238                public void visitEnter(IdisaCallArgListNode node) {
     239                        defaultVisitEnter(node);
     240                }
     241                public void visitLeave(IdisaCallArgListNode node) {
     242                        defaultVisitLeave(node);
     243                }
     244
     245                public void visitEnter(IdisaCallNode node) {
     246                        defaultVisitEnter(node);
     247                }
     248                public void visitLeave(IdisaCallNode node) {
     249                        defaultVisitLeave(node);
     250                }
     251
    242252                public void visitEnter(IfStmtNode node) {
    243253                        defaultVisitEnter(node);
     
    268278                }
    269279
     280                public void visitEnter(IntegerTypeNode node) {
     281                        defaultVisitEnter(node);
     282                }
     283                public void visitLeave(IntegerTypeNode node) {
     284                        defaultVisitLeave(node);
     285                }
     286
    270287                public void visitEnter(KernelDefNode node) {
    271288                        defaultVisitEnter(node);
     
    391408                }
    392409                public void visitLeave(TypeDeclNode node) {
    393                         defaultVisitLeave(node);
    394                 }
    395 
    396                 public void visitEnter(UnaryOperatorNode node) {
    397                         defaultVisitEnter(node);
    398                 }
    399                 public void visitLeave(UnaryOperatorNode node) {
    400410                        defaultVisitLeave(node);
    401411                }
  • proto/pabloj/trunk/src/pabloB/lexicalAnalyzer/Lextant.java

    r2834 r2981  
    2121        DOT(".", "main"),
    2222        LROUND("(", "main"),
    23         OR("|", "main"),
    24         AND_ASSIGN("&=", "main"),
    25         NOT("~", "main"),
     23        UINT32("uint32", "main"),
     24        UINT64("uint64", "main"),
    2625        RSQUARE("]", "main"),
    2726        INIT("init", "main"),
    2827        LANGLE("<", "main"),
     28        UINT128("uint128", "main"),
    2929        VOID("void", "main"),
    3030        ASSIGN("=", "main"),
    31         XOR("^", "main"),
    32         XOR_ASSIGN("^=", "main"),
    3331        STRUCT("struct", "main"),
    34         OR_ASSIGN("|=", "main"),
    3532        IF("if", "main"),
    3633        WHILE("while", "main"),
    3734        RETURN("return", "main"),
     35        UINT256("uint256", "main"),
    3836        ELSE("else", "main"),
    3937        FUNCTION("function", "main"),
    4038        LCURLY("{", "main"),
     39        UINT16("uint16", "main"),
    4140        LSQUARE("[", "main"),
    42         AND("&", "main"),
    4341        RROUND(")", "main"),
    44         MINUS("-", "main"),
    4542        RCURLY("}", "main"),
    4643        RANGLE(">", "main"),
     44        UINT8("uint8", "main"),
    4745        KERNEL("kernel", "main"),
    4846        VAR("var", "main"),
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r2964 r2981  
    4848                result.setProductionTag(1);
    4949                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    50                 while( nowReading.isLextant(Lextant.KERNEL, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    51                         if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     50                while( nowReading.isLextant(Lextant.KERNEL, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     51                        if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    5252                                {
    5353                                        ASTNode child = parseTypeDecl();
     
    7171         
    7272        public ASTNode parseTypeDecl() {
    73                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    74                         return syntaxErrorNode("typeDecl² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     73                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     74                        return syntaxErrorNode("typeDecl² [IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    7575                }
    7676       
     
    348348                }
    349349                expect(Lextant.LROUND);
    350                 if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     350                if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    351351                        {
    352352                                ASTNode child = parseParameterList();
     
    371371         
    372372        public ASTNode parseReturnType() {
    373                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    374                         return syntaxErrorNode("returnType² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     373                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     374                        return syntaxErrorNode("returnType² [IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    375375                }
    376376       
     
    391391         
    392392        public ASTNode parseParameterList() {
    393                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    394                         return syntaxErrorNode("parameterList² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     393                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     394                        return syntaxErrorNode("parameterList² [IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    395395                }
    396396       
     
    439439         
    440440        public ASTNode parseParameter() {
    441                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    442                         return syntaxErrorNode("parameter² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     441                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     442                        return syntaxErrorNode("parameter² [IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    443443                }
    444444       
     
    590590                        allChildren.add(child);
    591591                }
    592                 if( nowReading.isLextant(Lextant.LROUND) ) {
    593                         {
    594                                 ASTNode child = parseFuncCallRest();
     592                if( nowReading.isLextant(Lextant.LANGLE) ) {
     593                        {
     594                                ASTNode child = parseIdisaCallRest();
    595595                                result.appendChild(child);
    596596                                allChildren.add(child);
     
    599599                        allowCompression = false;
    600600                }
    601                 else if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
     601                else if( nowReading.isLextant(Lextant.LROUND) ) {
     602                        {
     603                                ASTNode child = parseFuncCallRest();
     604                                result.appendChild(child);
     605                                allChildren.add(child);
     606                        }
     607                        result = promoteLastChild(result);
     608                        allowCompression = false;
     609                }
     610                else if( nowReading.isLextant(Lextant.ASSIGN) ) {
    602611                        {
    603612                                ASTNode child = parseAssignRest();
     
    643652                result.setProductionTag(23);
    644653                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    645                 if( nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     654                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    646655                        {
    647656                                ASTNode child = parseExpr();
     
    664673        }
    665674         
     675        public ASTNode parseIdisaCallRest() {
     676                if( !(nowReading.isLextant(Lextant.LANGLE)) ) {
     677                        return syntaxErrorNode("idisaCallRest² [LANGLE¹]");
     678                }
     679       
     680                boolean allowCompression = true;
     681                ASTNode result = new IdisaCallNode(nowReading);
     682                result.setProductionTag(24);
     683                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     684                result.setToken(nowReading);
     685                expect(Lextant.LANGLE);
     686                {
     687                        ASTNode child = parseFieldWidth();
     688                        result.appendChild(child);
     689                        allChildren.add(child);
     690                }
     691                expect(Lextant.RANGLE);
     692                expect(Lextant.LROUND);
     693                {
     694                        ASTNode child = parseIdisaCallArgList();
     695                        result.appendChild(child);
     696                        allChildren.add(child);
     697                }
     698                expect(Lextant.RROUND);
     699                if(allowCompression) {
     700                        return result;
     701                }
     702                return result;
     703        }
     704         
     705        public ASTNode parseIdisaCallArgList() {
     706                boolean allowCompression = true;
     707                ASTNode result = new IdisaCallArgListNode(nowReading);
     708                result.setProductionTag(25);
     709                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     710                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     711                        {
     712                                ASTNode child = parseExpr();
     713                                result.appendChild(child);
     714                                allChildren.add(child);
     715                        }
     716                        while( nowReading.isLextant(Lextant.COMMA) ) {
     717                                expect(Lextant.COMMA);
     718                                {
     719                                        ASTNode child = parseExpr();
     720                                        result.appendChild(child);
     721                                        allChildren.add(child);
     722                                }
     723                        }
     724                }
     725                if(allowCompression) {
     726                        return result;
     727                }
     728                return result;
     729        }
     730         
    666731        public ASTNode parseAssignOperator() {
    667                 if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
    668                         return syntaxErrorNode("assignOperator² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     732                if( !(nowReading.isLextant(Lextant.ASSIGN)) ) {
     733                        return syntaxErrorNode("assignOperator² [ASSIGN¹]");
    669734                }
    670735       
    671736                boolean allowCompression = true;
    672737                ASTNode result = new AssignOperatorNode(nowReading);
    673                 result.setProductionTag(24);
    674                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    675                 if( nowReading.isLextant(Lextant.ASSIGN) ) {
    676                         expect(Lextant.ASSIGN);
    677                 }
    678                 else if( nowReading.isLextant(Lextant.AND_ASSIGN) ) {
    679                         expect(Lextant.AND_ASSIGN);
    680                 }
    681                 else if( nowReading.isLextant(Lextant.OR_ASSIGN) ) {
    682                         expect(Lextant.OR_ASSIGN);
    683                 }
    684                 else if( nowReading.isLextant(Lextant.XOR_ASSIGN) ) {
    685                         expect(Lextant.XOR_ASSIGN);
    686                 }
     738                result.setProductionTag(26);
     739                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     740                expect(Lextant.ASSIGN);
    687741                if(allowCompression) {
    688742                        return result;
     
    692746         
    693747        public ASTNode parseAssignRest() {
    694                 if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
    695                         return syntaxErrorNode("assignRest² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     748                if( !(nowReading.isLextant(Lextant.ASSIGN)) ) {
     749                        return syntaxErrorNode("assignRest² [ASSIGN¹]");
    696750                }
    697751       
    698752                boolean allowCompression = true;
    699753                ASTNode result = new AssignNode(nowReading);
    700                 result.setProductionTag(25);
     754                result.setProductionTag(27);
    701755                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    702756                {
     
    724778                boolean allowCompression = true;
    725779                ASTNode result = new IfStmtNode(nowReading);
    726                 result.setProductionTag(26);
     780                result.setProductionTag(28);
    727781                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    728782                expect(Lextant.IF);
     
    760814                boolean allowCompression = true;
    761815                ASTNode result = new WhileStmtNode(nowReading);
    762                 result.setProductionTag(27);
     816                result.setProductionTag(29);
    763817                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    764818                expect(Lextant.WHILE);
     
    788842                boolean allowCompression = true;
    789843                ASTNode result = new ReturnStmtNode(nowReading);
    790                 result.setProductionTag(28);
     844                result.setProductionTag(30);
    791845                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    792846                expect(Lextant.RETURN);
    793                 if( nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     847                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    794848                        {
    795849                                ASTNode child = parseExpr();
     
    812866                boolean allowCompression = true;
    813867                ASTNode result = new LocalVarDeclNode(nowReading);
    814                 result.setProductionTag(29);
     868                result.setProductionTag(31);
    815869                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    816870                expect(Lextant.VAR);
     
    825879                        allChildren.add(child);
    826880                }
    827                 if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
     881                if( nowReading.isLextant(Lextant.ASSIGN) ) {
    828882                        {
    829883                                ASTNode child = parseAssignOperator();
     
    846900        public ASTNode parseVarName() {
    847901                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    848                         return syntaxErrorNode("VarName² [IDENTIFIER¹]");
     902                        return syntaxErrorNode("varName² [IDENTIFIER¹]");
    849903                }
    850904       
    851905                boolean allowCompression = true;
    852906                ASTNode result = new ASTNode(nowReading);
    853                 result.setProductionTag(30);
     907                result.setProductionTag(32);
    854908                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    855909                {
     
    871925                boolean allowCompression = true;
    872926                ASTNode result = new BlockStmtNode(nowReading);
    873                 result.setProductionTag(31);
     927                result.setProductionTag(33);
    874928                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    875929                expect(Lextant.LCURLY);
     
    889943         
    890944        public ASTNode parseExpr() {
    891                 if( !(nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    892                         return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    893                 }
    894        
    895                 boolean allowCompression = true;
    896                 ASTNode result = new BinaryOperatorNode(nowReading);
    897                 result.setProductionTag(32);
    898                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    899                 {
    900                         ASTNode child = parseExpr1();
    901                         result.appendChild(child);
    902                         allChildren.add(child);
    903                 }
    904                 if( nowReading.isLextant(Lextant.OR, Lextant.XOR) ) {
    905                         if( nowReading.isLextant(Lextant.OR) ) {
    906                                 result.setToken(nowReading);
    907                                 expect(Lextant.OR);
    908                         }
    909                         else if( nowReading.isLextant(Lextant.XOR) ) {
    910                                 result.setToken(nowReading);
    911                                 expect(Lextant.XOR);
    912                         }
    913                         {
    914                                 ASTNode child = parseExpr();
    915                                 result.appendChild(child);
    916                                 allChildren.add(child);
     945                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     946                        return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
     947                }
     948       
     949                boolean allowCompression = true;
     950                ASTNode result = new ASTNode(nowReading);
     951                result.setProductionTag(34);
     952                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     953                if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     954                        {
     955                                ASTNode child = parseIntegerConstant();
     956                                result.appendChild(child);
     957                                allChildren.add(child);
     958                        }
     959                }
     960                else if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     961                        {
     962                                ASTNode child = parseStringConstant();
     963                                result.appendChild(child);
     964                                allChildren.add(child);
     965                        }
     966                }
     967                else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     968                        {
     969                                ASTNode child = parseCompoundIdentifier();
     970                                result.appendChild(child);
     971                                allChildren.add(child);
     972                        }
     973                        if( nowReading.isLextant(Lextant.LANGLE, Lextant.LROUND) ) {
     974                                if( nowReading.isLextant(Lextant.LROUND) ) {
     975                                        {
     976                                                ASTNode child = parseFuncCallRest();
     977                                                result.appendChild(child);
     978                                                allChildren.add(child);
     979                                        }
     980                                        result = promoteLastChild(result);
     981                                        allowCompression = false;
     982                                }
     983                                else if( nowReading.isLextant(Lextant.LANGLE) ) {
     984                                        {
     985                                                ASTNode child = parseIdisaCallRest();
     986                                                result.appendChild(child);
     987                                                allChildren.add(child);
     988                                        }
     989                                        result = promoteLastChild(result);
     990                                        allowCompression = false;
     991                                }
    917992                        }
    918993                }
     
    923998        }
    924999         
    925         public ASTNode parseExpr1() {
    926                 if( !(nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    927                         return syntaxErrorNode("expr1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    928                 }
    929        
    930                 boolean allowCompression = true;
    931                 ASTNode result = new BinaryOperatorNode(nowReading);
    932                 result.setProductionTag(33);
    933                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    934                 {
    935                         ASTNode child = parseExpr2();
    936                         result.appendChild(child);
    937                         allChildren.add(child);
    938                 }
    939                 if( nowReading.isLextant(Lextant.AND) ) {
    940                         result.setToken(nowReading);
    941                         expect(Lextant.AND);
    942                         {
    943                                 ASTNode child = parseExpr1();
    944                                 result.appendChild(child);
    945                                 allChildren.add(child);
    946                         }
    947                 }
    948                 if(allowCompression) {
    949                         return compressIfPossible(result);
    950                 }
    951                 return result;
    952         }
    953          
    954         public ASTNode parseExpr2() {
    955                 if( !(nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    956                         return syntaxErrorNode("expr2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    957                 }
    958        
    959                 boolean allowCompression = true;
    960                 ASTNode result = new UnaryOperatorNode(nowReading);
    961                 result.setProductionTag(34);
    962                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    963                 if( nowReading.isLextant(Lextant.NOT) ) {
    964                         result.setToken(nowReading);
    965                         allowCompression = false;
    966                         expect(Lextant.NOT);
    967                 }
    968                 {
    969                         ASTNode child = parseExpr3();
    970                         result.appendChild(child);
    971                         allChildren.add(child);
    972                 }
    973                 result = rotateLeftIfPossible(result);
    974                 if(allowCompression) {
    975                         return compressIfPossible(result);
    976                 }
    977                 return result;
    978         }
    979          
    980         public ASTNode parseExpr3() {
    981                 if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    982                         return syntaxErrorNode("expr3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
     1000        public ASTNode parseConstant() {
     1001                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     1002                        return syntaxErrorNode("constant² [INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
    9831003                }
    9841004       
     
    9871007                result.setProductionTag(35);
    9881008                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    989                 if( nowReading.isLextant(Lextant.LROUND) ) {
    990                         expect(Lextant.LROUND);
    991                         {
    992                                 ASTNode child = parseExpr();
    993                                 result.appendChild(child);
    994                                 allChildren.add(child);
    995                         }
    996                         expect(Lextant.RROUND);
     1009                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     1010                        {
     1011                                ASTNode child = parseStringConstant();
     1012                                result.appendChild(child);
     1013                                allChildren.add(child);
     1014                        }
    9971015                }
    9981016                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    9991017                        {
    1000                                 ASTNode child = parseStreamConstant();
    1001                                 result.appendChild(child);
    1002                                 allChildren.add(child);
    1003                         }
    1004                 }
    1005                 else if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    1006                         {
    1007                                 ASTNode child = parseStringConstant();
    1008                                 result.appendChild(child);
    1009                                 allChildren.add(child);
    1010                         }
    1011                 }
    1012                 else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    1013                         {
    1014                                 ASTNode child = parseCompoundIdentifier();
    1015                                 result.appendChild(child);
    1016                                 allChildren.add(child);
    1017                         }
    1018                         if( nowReading.isLextant(Lextant.LROUND) ) {
    1019                                 {
    1020                                         ASTNode child = parseFuncCallRest();
    1021                                         result.appendChild(child);
    1022                                         allChildren.add(child);
    1023                                 }
    1024                                 result = promoteLastChild(result);
    1025                                 allowCompression = false;
     1018                                ASTNode child = parseIntegerConstant();
     1019                                result.appendChild(child);
     1020                                allChildren.add(child);
    10261021                        }
    10271022                }
     
    10321027        }
    10331028         
    1034         public ASTNode parseConstant() {
    1035                 if( !(nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    1036                         return syntaxErrorNode("constant² [INTEGER_CONST¹, MINUS¹, SQ_STRING¹, STRING¹]");
    1037                 }
    1038        
    1039                 boolean allowCompression = true;
    1040                 ASTNode result = new ASTNode(nowReading);
     1029        public ASTNode parseIntegerConstant() {
     1030                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     1031                        return syntaxErrorNode("integerConstant² [INTEGER_CONST¹]");
     1032                }
     1033       
     1034                boolean allowCompression = true;
     1035                ASTNode result = new IntegerConstantNode(nowReading);
    10411036                result.setProductionTag(36);
    1042                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1043                 if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    1044                         {
    1045                                 ASTNode child = parseStringConstant();
    1046                                 result.appendChild(child);
    1047                                 allChildren.add(child);
    1048                         }
    1049                 }
    1050                 else if( nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    1051                         {
    1052                                 ASTNode child = parseSignedIntegerConstant();
    1053                                 result.appendChild(child);
    1054                                 allChildren.add(child);
    1055                         }
    1056                 }
    1057                 if(allowCompression) {
    1058                         return compressIfPossible(result);
    1059                 }
    1060                 return result;
    1061         }
    1062          
    1063         public ASTNode parseStreamConstant() {
    1064                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    1065                         return syntaxErrorNode("streamConstant² [INTEGER_CONST¹]");
    1066                 }
    1067        
    1068                 boolean allowCompression = true;
    1069                 ASTNode result = new StreamConstantNode(nowReading);
    1070                 result.setProductionTag(37);
    10711037                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10721038                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    10871053        }
    10881054         
    1089         public ASTNode parseSignedIntegerConstant() {
    1090                 if( !(nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    1091                         return syntaxErrorNode("signedIntegerConstant² [INTEGER_CONST¹, MINUS¹]");
    1092                 }
    1093        
    1094                 boolean allowCompression = true;
    1095                 ASTNode result = new ASTNode(nowReading);
    1096                 result.setProductionTag(38);
    1097                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1098                 if( nowReading.isLextant(Lextant.MINUS) ) {
    1099                         expect(Lextant.MINUS);
    1100                         {
    1101                                 ASTNode child = parseIntegerConstant();
    1102                                 result.appendChild(child);
    1103                                 allChildren.add(child);
    1104                         }
    1105                         {
    1106                                 ASTNode temp_7 = allChildren.revGet(0);
    1107                                 IntValuedNodeType temp_9 = (IntValuedNodeType)temp_7;
    1108                                 int temp_10 = 0;
    1109                                 ASTNode temp_11 = allChildren.revGet(0);
    1110                                 IntValuedNodeType temp_13 = (IntValuedNodeType)temp_11;
    1111                                 int temp_12 = temp_13.getValue();
    1112                                 int temp_14 = temp_10 - temp_12;
    1113                                 temp_9.setValue( temp_14 );
    1114                         }
    1115                 }
    1116                 else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    1117                         {
    1118                                 ASTNode child = parseIntegerConstant();
    1119                                 result.appendChild(child);
    1120                                 allChildren.add(child);
    1121                         }
    1122                 }
    1123                 if(allowCompression) {
    1124                         return compressIfPossible(result);
    1125                 }
    1126                 return result;
    1127         }
    1128          
    1129         public ASTNode parseIntegerConstant() {
    1130                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    1131                         return syntaxErrorNode("integerConstant² [INTEGER_CONST¹]");
    1132                 }
    1133        
    1134                 boolean allowCompression = true;
    1135                 ASTNode result = new IntegerConstantNode(nowReading);
    1136                 result.setProductionTag(39);
    1137                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1138                 if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    1139                         return syntaxErrorNode("INTEGER_CONST");
    1140                 }
    1141                 readToken();
    1142                 {
    1143                         ASTNode temp_15 = result;
    1144                         IntValuedNodeType temp_17 = (IntValuedNodeType)temp_15;
    1145                         IntConstantToken temp_20 = (IntConstantToken)previouslyRead;
    1146                         int temp_19 = temp_20.getValue();
    1147                         temp_17.setValue( temp_19 );
    1148                 }
    1149                 if(allowCompression) {
    1150                         return result;
    1151                 }
    1152                 return result;
    1153         }
    1154          
    11551055        public ASTNode parseStringConstant() {
    11561056                if( !((nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     
    11601060                boolean allowCompression = true;
    11611061                ASTNode result = new StringConstantNode(nowReading);
    1162                 result.setProductionTag(40);
     1062                result.setProductionTag(37);
    11631063                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11641064                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    11871087                boolean allowCompression = true;
    11881088                ASTNode result = new CompoundIdentifierNode(nowReading);
    1189                 result.setProductionTag(41);
     1089                result.setProductionTag(38);
    11901090                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11911091                {
     
    12161116                boolean allowCompression = true;
    12171117                ASTNode result = new IdentifierNode(nowReading);
    1218                 result.setProductionTag(42);
     1118                result.setProductionTag(39);
    12191119                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12201120                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    12291129         
    12301130        public ASTNode parseType() {
    1231                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    1232                         return syntaxErrorNode("type² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     1131                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     1132                        return syntaxErrorNode("type² [IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    12331133                }
    12341134       
    12351135                boolean allowCompression = true;
    12361136                ASTNode result = new ASTNode(nowReading);
    1237                 result.setProductionTag(43);
     1137                result.setProductionTag(40);
    12381138                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12391139                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    12611161                        {
    12621162                                ASTNode child = parseIdentifier();
     1163                                result.appendChild(child);
     1164                                allChildren.add(child);
     1165                        }
     1166                }
     1167                else if( nowReading.isLextant(Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8) ) {
     1168                        {
     1169                                ASTNode child = parseIntegerType();
    12631170                                result.appendChild(child);
    12641171                                allChildren.add(child);
     
    12781185                boolean allowCompression = true;
    12791186                ASTNode result = new StreamTypeNode(nowReading);
    1280                 result.setProductionTag(44);
     1187                result.setProductionTag(41);
    12811188                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12821189                expect(Lextant.STREAM);
     
    13031210                boolean allowCompression = true;
    13041211                ASTNode result = new FieldWidthNode(nowReading);
    1305                 result.setProductionTag(45);
     1212                result.setProductionTag(42);
    13061213                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13071214                {
     
    13231230                boolean allowCompression = true;
    13241231                ASTNode result = new ASTNode(nowReading);
    1325                 result.setProductionTag(46);
     1232                result.setProductionTag(43);
    13261233                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13271234                {
     
    13321239                if(allowCompression) {
    13331240                        return compressIfPossible(result);
     1241                }
     1242                return result;
     1243        }
     1244         
     1245        public ASTNode parseIntegerType() {
     1246                if( !(nowReading.isLextant(Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8)) ) {
     1247                        return syntaxErrorNode("integerType² [UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹]");
     1248                }
     1249       
     1250                boolean allowCompression = true;
     1251                ASTNode result = new IntegerTypeNode(nowReading);
     1252                result.setProductionTag(44);
     1253                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1254                if( nowReading.isLextant(Lextant.UINT8) ) {
     1255                        expect(Lextant.UINT8);
     1256                }
     1257                else if( nowReading.isLextant(Lextant.UINT16) ) {
     1258                        expect(Lextant.UINT16);
     1259                }
     1260                else if( nowReading.isLextant(Lextant.UINT32) ) {
     1261                        expect(Lextant.UINT32);
     1262                }
     1263                else if( nowReading.isLextant(Lextant.UINT64) ) {
     1264                        expect(Lextant.UINT64);
     1265                }
     1266                else if( nowReading.isLextant(Lextant.UINT128) ) {
     1267                        expect(Lextant.UINT128);
     1268                }
     1269                else if( nowReading.isLextant(Lextant.UINT256) ) {
     1270                        expect(Lextant.UINT256);
     1271                }
     1272                if(allowCompression) {
     1273                        return result;
    13341274                }
    13351275                return result;
     
    13431283                boolean allowCompression = true;
    13441284                ASTNode result = new StructTypeNode(nowReading);
    1345                 result.setProductionTag(47);
     1285                result.setProductionTag(45);
    13461286                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13471287                expect(Lextant.STRUCT);
     
    13711311                boolean allowCompression = true;
    13721312                ASTNode result = new ASTNode(nowReading);
    1373                 result.setProductionTag(48);
     1313                result.setProductionTag(46);
    13741314                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13751315                {
     
    13911331                boolean allowCompression = true;
    13921332                ASTNode result = new StructTypeBodyNode(nowReading);
    1393                 result.setProductionTag(49);
     1333                result.setProductionTag(47);
    13941334                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13951335                expect(Lextant.LCURLY);
     
    14001340                }
    14011341                expect(Lextant.TERMINATOR);
    1402                 while( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     1342                while( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    14031343                        {
    14041344                                ASTNode child = parseStructMember();
     
    14161356         
    14171357        public ASTNode parseStructMember() {
    1418                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    1419                         return syntaxErrorNode("structMember² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     1358                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     1359                        return syntaxErrorNode("structMember² [IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    14201360                }
    14211361       
    14221362                boolean allowCompression = true;
    14231363                ASTNode result = new StructMemberNode(nowReading);
    1424                 result.setProductionTag(50);
     1364                result.setProductionTag(48);
    14251365                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14261366                {
     
    14471387                boolean allowCompression = true;
    14481388                ASTNode result = new ASTNode(nowReading);
    1449                 result.setProductionTag(51);
     1389                result.setProductionTag(49);
    14501390                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14511391                {
     
    14671407                boolean allowCompression = true;
    14681408                ASTNode result = new VoidNode(nowReading);
    1469                 result.setProductionTag(52);
     1409                result.setProductionTag(50);
    14701410                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14711411                expect(Lextant.VOID);
  • proto/pabloj/trunk/src/pabloS/ast/ASTNode.java

    r2976 r2981  
    141141    }
    142142        public void insertAfterChild(ASTNode node, ASTNode successor) {
    143                 int index = children.indexOf(node);
    144                 insertChildAfter(index, successor);
    145                 successor.setParent(this);
     143        int index = children.indexOf(node);
     144        insertAfterChild(index, successor);
     145        successor.setParent(this);
    146146    }
    147     private void insertChildAfter(int index, ASTNode successor) {
    148             if(index == children.size()-1) {
    149                     children.add(successor);
    150             } else {
    151                     children.add(index+1, successor);
    152             }       
     147    private void insertAfterChild(int index, ASTNode successor) {
     148        if(index == children.size()-1) {
     149            children.add(successor);
     150        }
     151        else {
     152            children.add(index+1, successor);
     153        }       
    153154    }   
    154155
  • proto/pabloj/trunk/src/pabloS/ast/ASTTransformer.java

    r2972 r2981  
    6666        public ASTNode visit(TypeDeclNode node);
    6767
    68         public ASTNode visit(TypeDefNode node);
    69 
    7068        public ASTNode visit(UnaryOperatorNode node);
    7169
     
    193191                }
    194192
    195                 public ASTNode visit(TypeDefNode node) {
    196                         return defaultVisit(node);
    197                 }
    198 
    199193                public ASTNode visit(UnaryOperatorNode node) {
    200194                        return defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/ASTVisitor.java

    r2972 r2981  
    9595        public T visitLeave(TypeDeclNode node, List<T> childResults);
    9696
    97         public void visitEnter(TypeDefNode node);
    98         public T visitLeave(TypeDefNode node, List<T> childResults);
    99 
    10097        public void visitEnter(UnaryOperatorNode node);
    10198        public T visitLeave(UnaryOperatorNode node, List<T> childResults);
     
    320317                }
    321318
    322                 public void visitEnter(TypeDefNode node) {
    323                         defaultVisitEnter(node);
    324                 }
    325                 public T visitLeave(TypeDefNode node, List<T> childResults) {
    326                         return defaultVisitLeave(node);
    327                 }
    328 
    329319                public void visitEnter(UnaryOperatorNode node) {
    330320                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloS/ast/IntValuedNodeType.java

    r2834 r2981  
    1010
    1111        public int getValue();
    12         public void setValue(int scatterValueX);
     12        public void setValue(int _value_);
    1313       
    1414
  • proto/pabloj/trunk/src/pabloS/ast/IntegerConstantNode.java

    r2834 r2981  
    3939                return value;
    4040        }
    41         public void setValue(int scatterValueX) {
    42                 value = scatterValueX;
     41        public void setValue(int _value_) {
     42                value = _value_;
    4343        }
    4444       
  • proto/pabloj/trunk/src/pabloS/ast/SimpleVisitor.java

    r2972 r2981  
    6767        public void visit(TypeDeclNode node);
    6868
    69         public void visit(TypeDefNode node);
    70 
    7169        public void visit(UnaryOperatorNode node);
    7270
     
    194192                }
    195193
    196                 public void visit(TypeDefNode node) {
    197                         defaultVisit(node);
    198                 }
    199 
    200194                public void visit(UnaryOperatorNode node) {
    201195                        defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/VoidVisitor.java

    r2972 r2981  
    9393        public void visitLeave(TypeDeclNode node);
    9494
    95         public void visitEnter(TypeDefNode node);
    96         public void visitLeave(TypeDefNode node);
    97 
    9895        public void visitEnter(UnaryOperatorNode node);
    9996        public void visitLeave(UnaryOperatorNode node);
     
    317314                }
    318315
    319                 public void visitEnter(TypeDefNode node) {
    320                         defaultVisitEnter(node);
    321                 }
    322                 public void visitLeave(TypeDefNode node) {
    323                         defaultVisitLeave(node);
    324                 }
    325 
    326316                public void visitEnter(UnaryOperatorNode node) {
    327317                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloS/lexicalAnalyzer/Lextant.java

    r2947 r2981  
    3737        FUNCTION("function", "main"),
    3838        LCURLY("{", "main"),
    39         TYPEDEF("typedef", "main"),
    4039        AND("&", "main"),
    4140        RROUND(")", "main"),
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r2972 r2981  
    4848                result.setProductionTag(1);
    4949                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    50                 while( nowReading.isLextant(Lextant.FUNCTION, Lextant.STREAM, Lextant.STRUCT, Lextant.TYPEDEF, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     50                while( nowReading.isLextant(Lextant.FUNCTION, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    5151                        if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    5252                                {
     
    5656                                }
    5757                        }
    58                         else if( nowReading.isLextant(Lextant.TYPEDEF) ) {
    59                                 {
    60                                         ASTNode child = parseTypeDef();
    61                                         result.appendChild(child);
    62                                         allChildren.add(child);
    63                                 }
    64                         }
    6558                        else if( nowReading.isLextant(Lextant.FUNCTION) ) {
    6659                                {
     
    9891        }
    9992         
    100         public ASTNode parseTypeDef() {
    101                 if( !(nowReading.isLextant(Lextant.TYPEDEF)) ) {
    102                         return syntaxErrorNode("typeDef² [TYPEDEF¹]");
    103                 }
    104        
    105                 boolean allowCompression = true;
    106                 ASTNode result = new TypeDefNode(nowReading);
    107                 result.setProductionTag(3);
    108                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    109                 expect(Lextant.TYPEDEF);
    110                 {
    111                         ASTNode child = parseType();
    112                         result.appendChild(child);
    113                         allChildren.add(child);
    114                 }
    115                 {
    116                         ASTNode child = parseIdentifier();
    117                         result.appendChild(child);
    118                         allChildren.add(child);
    119                 }
    120                 expect(Lextant.TERMINATOR);
    121                 if(allowCompression) {
    122                         return result;
    123                 }
    124                 return result;
    125         }
    126          
    12793        public ASTNode parseFuncDef() {
    12894                if( !(nowReading.isLextant(Lextant.FUNCTION)) ) {
     
    13298                boolean allowCompression = true;
    13399                ASTNode result = new FuncDefNode(nowReading);
    134                 result.setProductionTag(4);
     100                result.setProductionTag(3);
    135101                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    136102                expect(Lextant.FUNCTION);
     
    175141                boolean allowCompression = true;
    176142                ASTNode result = new ASTNode(nowReading);
    177                 result.setProductionTag(5);
     143                result.setProductionTag(4);
    178144                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    179145                {
     
    195161                boolean allowCompression = true;
    196162                ASTNode result = new ParameterListNode(nowReading);
    197                 result.setProductionTag(6);
     163                result.setProductionTag(5);
    198164                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    199165                {
     
    223189                boolean allowCompression = true;
    224190                ASTNode result = new ASTNode(nowReading);
    225                 result.setProductionTag(7);
     191                result.setProductionTag(6);
    226192                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    227193                {
     
    243209                boolean allowCompression = true;
    244210                ASTNode result = new ParameterNode(nowReading);
    245                 result.setProductionTag(8);
     211                result.setProductionTag(7);
    246212                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    247213                {
     
    268234                boolean allowCompression = true;
    269235                ASTNode result = new ASTNode(nowReading);
    270                 result.setProductionTag(9);
     236                result.setProductionTag(8);
    271237                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    272238                {
     
    288254                boolean allowCompression = true;
    289255                ASTNode result = new ASTNode(nowReading);
    290                 result.setProductionTag(10);
     256                result.setProductionTag(9);
    291257                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    292258                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    341307                boolean allowCompression = true;
    342308                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    343                 result.setProductionTag(11);
     309                result.setProductionTag(10);
    344310                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    345311                {
     
    380346                boolean allowCompression = true;
    381347                ASTNode result = new FuncCallNode(nowReading);
    382                 result.setProductionTag(12);
     348                result.setProductionTag(11);
    383349                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    384350                result.setToken(nowReading);
     
    399365                boolean allowCompression = true;
    400366                ASTNode result = new FuncCallArgListNode(nowReading);
    401                 result.setProductionTag(13);
     367                result.setProductionTag(12);
    402368                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    403369                if( nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    429395                boolean allowCompression = true;
    430396                ASTNode result = new AssignOperatorNode(nowReading);
    431                 result.setProductionTag(14);
     397                result.setProductionTag(13);
    432398                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    433399                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    456422                boolean allowCompression = true;
    457423                ASTNode result = new AssignNode(nowReading);
    458                 result.setProductionTag(15);
     424                result.setProductionTag(14);
    459425                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    460426                {
     
    482448                boolean allowCompression = true;
    483449                ASTNode result = new IfStmtNode(nowReading);
    484                 result.setProductionTag(16);
     450                result.setProductionTag(15);
    485451                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    486452                expect(Lextant.IF);
     
    518484                boolean allowCompression = true;
    519485                ASTNode result = new WhileStmtNode(nowReading);
    520                 result.setProductionTag(17);
     486                result.setProductionTag(16);
    521487                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    522488                expect(Lextant.WHILE);
     
    546512                boolean allowCompression = true;
    547513                ASTNode result = new ReturnStmtNode(nowReading);
    548                 result.setProductionTag(18);
     514                result.setProductionTag(17);
    549515                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    550516                expect(Lextant.RETURN);
     
    570536                boolean allowCompression = true;
    571537                ASTNode result = new LocalVarDeclNode(nowReading);
    572                 result.setProductionTag(19);
     538                result.setProductionTag(18);
    573539                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    574540                expect(Lextant.VAR);
     
    609575                boolean allowCompression = true;
    610576                ASTNode result = new LocalVarAssignOperatorNode(nowReading);
    611                 result.setProductionTag(20);
     577                result.setProductionTag(19);
    612578                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    613579                expect(Lextant.ASSIGN);
     
    620586        public ASTNode parseVarName() {
    621587                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    622                         return syntaxErrorNode("VarName² [IDENTIFIER¹]");
     588                        return syntaxErrorNode("varName² [IDENTIFIER¹]");
    623589                }
    624590       
    625591                boolean allowCompression = true;
    626592                ASTNode result = new ASTNode(nowReading);
    627                 result.setProductionTag(21);
     593                result.setProductionTag(20);
    628594                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    629595                {
     
    645611                boolean allowCompression = true;
    646612                ASTNode result = new BlockStmtNode(nowReading);
    647                 result.setProductionTag(22);
     613                result.setProductionTag(21);
    648614                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    649615                expect(Lextant.LCURLY);
     
    669635                boolean allowCompression = true;
    670636                ASTNode result = new BinaryOperatorNode(nowReading);
    671                 result.setProductionTag(23);
     637                result.setProductionTag(22);
    672638                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    673639                {
     
    704670                boolean allowCompression = true;
    705671                ASTNode result = new BinaryOperatorNode(nowReading);
    706                 result.setProductionTag(24);
     672                result.setProductionTag(23);
    707673                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    708674                {
     
    733699                boolean allowCompression = true;
    734700                ASTNode result = new UnaryOperatorNode(nowReading);
    735                 result.setProductionTag(25);
     701                result.setProductionTag(24);
    736702                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    737703                if( nowReading.isLextant(Lextant.NOT) ) {
     
    759725                boolean allowCompression = true;
    760726                ASTNode result = new ASTNode(nowReading);
    761                 result.setProductionTag(26);
     727                result.setProductionTag(25);
    762728                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    763729                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    813779                boolean allowCompression = true;
    814780                ASTNode result = new ASTNode(nowReading);
    815                 result.setProductionTag(27);
     781                result.setProductionTag(26);
    816782                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    817783                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    842808                boolean allowCompression = true;
    843809                ASTNode result = new IntegerConstantNode(nowReading);
    844                 result.setProductionTag(28);
     810                result.setProductionTag(27);
    845811                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    846812                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    868834                boolean allowCompression = true;
    869835                ASTNode result = new StringConstantNode(nowReading);
    870                 result.setProductionTag(29);
     836                result.setProductionTag(28);
    871837                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    872838                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    895861                boolean allowCompression = true;
    896862                ASTNode result = new CompoundIdentifierNode(nowReading);
    897                 result.setProductionTag(30);
     863                result.setProductionTag(29);
    898864                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    899865                {
     
    924890                boolean allowCompression = true;
    925891                ASTNode result = new IdentifierNode(nowReading);
    926                 result.setProductionTag(31);
     892                result.setProductionTag(30);
    927893                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    928894                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    943909                boolean allowCompression = true;
    944910                ASTNode result = new ASTNode(nowReading);
    945                 result.setProductionTag(32);
     911                result.setProductionTag(31);
    946912                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    947913                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    986952                boolean allowCompression = true;
    987953                ASTNode result = new StreamTypeNode(nowReading);
    988                 result.setProductionTag(33);
     954                result.setProductionTag(32);
    989955                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    990956                expect(Lextant.STREAM);
    991                 if( nowReading.isLextant(Lextant.LANGLE) ) {
    992                         expect(Lextant.LANGLE);
    993                         {
    994                                 ASTNode child = parseFieldWidth();
    995                                 result.appendChild(child);
    996                                 allChildren.add(child);
    997                         }
    998                         expect(Lextant.RANGLE);
    999                 }
     957                expect(Lextant.LANGLE);
     958                {
     959                        ASTNode child = parseFieldWidth();
     960                        result.appendChild(child);
     961                        allChildren.add(child);
     962                }
     963                expect(Lextant.RANGLE);
    1000964                if(allowCompression) {
    1001965                        return result;
     
    1011975                boolean allowCompression = true;
    1012976                ASTNode result = new FieldWidthNode(nowReading);
    1013                 result.setProductionTag(34);
     977                result.setProductionTag(33);
    1014978                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1015979                {
     
    1020984                if(allowCompression) {
    1021985                        return result;
    1022                 }
    1023                 return result;
    1024         }
    1025          
    1026         public ASTNode parseStreamTypeName() {
    1027                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    1028                         return syntaxErrorNode("streamTypeName² [IDENTIFIER¹]");
    1029                 }
    1030        
    1031                 boolean allowCompression = true;
    1032                 ASTNode result = new ASTNode(nowReading);
    1033                 result.setProductionTag(35);
    1034                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1035                 {
    1036                         ASTNode child = parseIdentifier();
    1037                         result.appendChild(child);
    1038                         allChildren.add(child);
    1039                 }
    1040                 if(allowCompression) {
    1041                         return compressIfPossible(result);
    1042986                }
    1043987                return result;
     
    1051995                boolean allowCompression = true;
    1052996                ASTNode result = new StructTypeNode(nowReading);
    1053                 result.setProductionTag(36);
     997                result.setProductionTag(34);
    1054998                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1055999                expect(Lextant.STRUCT);
     
    10791023                boolean allowCompression = true;
    10801024                ASTNode result = new ASTNode(nowReading);
    1081                 result.setProductionTag(37);
     1025                result.setProductionTag(35);
    10821026                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10831027                {
     
    10991043                boolean allowCompression = true;
    11001044                ASTNode result = new StructTypeBodyNode(nowReading);
    1101                 result.setProductionTag(38);
     1045                result.setProductionTag(36);
    11021046                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11031047                expect(Lextant.LCURLY);
     
    11301074                boolean allowCompression = true;
    11311075                ASTNode result = new StructMemberNode(nowReading);
    1132                 result.setProductionTag(39);
     1076                result.setProductionTag(37);
    11331077                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11341078                {
     
    11551099                boolean allowCompression = true;
    11561100                ASTNode result = new ASTNode(nowReading);
    1157                 result.setProductionTag(40);
     1101                result.setProductionTag(38);
    11581102                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11591103                {
     
    11751119                boolean allowCompression = true;
    11761120                ASTNode result = new VoidNode(nowReading);
    1177                 result.setProductionTag(41);
     1121                result.setProductionTag(39);
    11781122                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11791123                expect(Lextant.VOID);
Note: See TracChangeset for help on using the changeset viewer.