Changeset 2984


Ignore:
Timestamp:
Mar 29, 2013, 1:43:50 AM (4 years ago)
Author:
ksherdy
Message:

Added parabix2_pablo.py as parabix2_pablo.pablob. Set idisa builtin syntax in PabloB grammar as library_name.operation_name<field_width>(arg_list), e.g. simd.and<1>(a,b), bitblock.any<1>(a) to maintain consistency with existing builtins syntax.

Location:
proto/pabloj/trunk
Files:
14 added
4 deleted
24 edited
1 copied
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/input/grammar/scatter/pabloB.scatter

    r2981 r2984  
    6464        VOID,
    6565       
    66         UINT8,
    67         UINT16,
    68         UINT32,
    69         UINT64,
    70         UINT128,
    71         UINT256,
    72         // BITBLOCK // alias for architecture dependent SIMD instruction width
     66        UINT8           "uint8",
     67        UINT16          "uint16",
     68        UINT32          "uint32",
     69        UINT64          "uint64",
     70        UINT128         "uint128",
     71        UINT256         "uint256",
     72        BITBLOCK        "BitBlock", // alias for architecture dependent SIMD instruction width
     73       
     74        //BLOCKMODE,
    7375       
    7476        IF,
     
    130132        // s t r e a m   s t r u c t   d e c l a r a t i o n s                                                 
    131133        //
    132         kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? RCURLY TERMINATOR? ;
     134        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? (compoundIdentifier (funcCallRest _promote_))? RCURLY TERMINATOR? ; // TODO eliminate carry.Declare ?
    133135       
    134136        kernelName                      #-> identifier ;
     
    146148        stateSize                       ->  integerConstant ;
    147149       
    148         stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of intX type
     150        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of uintN type
    149151       
    150152        stateValue                      ->  integerConstant ;
     
    169171       
    170172        optFuncDef                      #-> funcDef ;
     173 
     174        // c o d e   b l o c k
     175        //
     176        // BLOCKMODE  (LANGLE fieldWidth RANGLE) blockStmt (TERMINATOR)? ;
    171177 
    172178               
     
    205211        // e x p r e s s i o n s
    206212        //     
    207         expr            #-> integerConstant
     213        expr            #-> LROUND expr RROUND
     214                                        |integerConstant
    208215                                        | stringConstant
    209216                                        | compoundIdentifier (funcCallRest _promote_ | idisaCallRest _promote_)?
     
    228235        //
    229236
    230         type                    #->  streamType | structType | void | identifier | integerType ; // | tupleType;
    231        
    232         streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
     237        type                    #->     identifier      |
     238                                                        voidType        |
     239                                                        streamType      |
     240                                                        structType      |
     241                                                        uint8Type       |
     242                                                        uint16Type      |
     243                                                        uint32Type      |
     244                                                        uint64Type      |
     245                                                        uint128Type |
     246                                                        uint256Type |
     247                                                        bitBlockType; // | tupleType;
     248       
     249        streamType              ->      STREAM (LANGLE fieldWidth RANGLE) ;     
    233250                                       
    234251        fieldWidth              ->  integerConstant ;   
     
    236253        streamTypeName  #->     identifier ;                           
    237254               
    238         integerType             -> UINT8 | UINT16 | UINT32 | UINT64 | UINT128 | UINT256 ;       
     255        uint8Type               -> UINT8 ;
     256        uint16Type              -> UINT16 ;
     257        uint32Type              -> UINT32 ;
     258        uint64Type              -> UINT64 ;
     259        uint128Type             -> UINT128 ;
     260        uint256Type             -> UINT256 ;
     261       
     262        bitBlockType    -> BITBLOCK;
    239263               
    240264        //     
     
    253277        structMemberName                #-> identifier ;
    254278       
    255         void                                    -> VOID ;
    256        
    257 }
     279        voidType                                -> VOID ;
     280       
     281}
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r2981 r2984  
    189189        // s t r e a m
    190190
    191         type                    #->  streamType | structType | void | identifier ; // | tupleType;
     191        type                    #->     identifier              |
     192                                                        streamType              |
     193                                                        structType              |
     194                                                        voidType                ; // | tupleType;
    192195       
    193196        streamType              ->      STREAM LANGLE fieldWidth RANGLE ;       
     
    210213        structMemberName                #-> identifier ;
    211214       
    212         void                                    -> VOID ;
     215        voidType                                -> VOID ;
    213216       
    214217        // t u p l e
  • proto/pabloj/trunk/input/test/pabloB/statements/idisa/idisa1.pablob

    r2981 r2984  
    11// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
     2       
     3struct Basis_bits
     4{
     5        BitBlock bit_0;
     6        BitBlock bit_1;
     7        BitBlock bit_2;
     8        BitBlock bit_3;
     9        BitBlock bit_4;
     10        BitBlock bit_5;
     11        BitBlock bit_6;
     12        BitBlock bit_7;
     13};
     14 
     15struct U8
     16{
     17        BitBlock unibyte;
     18        BitBlock prefix;
     19        BitBlock prefix2;
     20        BitBlock prefix3;
     21        BitBlock prefix4;
     22        BitBlock suffix;
     23        BitBlock badprefix;
     24        BitBlock xE0;
     25        BitBlock xED;
     26        BitBlock xF0;
     27        BitBlock xF4;
     28        BitBlock xA0_xBF;
     29        BitBlock x80_x9F;
     30        BitBlock x90_xBF;
     31        BitBlock x80_x8F;
     32        BitBlock xEF;
     33        BitBlock xBF;
     34        BitBlock xBE;
     35        BitBlock scope22;
     36        BitBlock scope32;
     37        BitBlock scope33;
     38        BitBlock scope42;
     39        BitBlock scope43;
     40        BitBlock scope44;
     41        BitBlock xE0_scope;
     42        BitBlock xED_scope;
     43        BitBlock xF0_scope;
     44        BitBlock xF4_scope;
     45        BitBlock xEF_scope;
     46};
     47 
     48struct Lex
     49{
     50        BitBlock CR;
     51        BitBlock LF;
     52        BitBlock HT;
     53        BitBlock SP;
     54        BitBlock CRLF;
     55        BitBlock RefStart;
     56        BitBlock Semicolon;
     57        BitBlock Colon;
     58        BitBlock LAngle;
     59        BitBlock RAngle;
     60        BitBlock LBracket;
     61        BitBlock RBracket;
     62        BitBlock Exclam;
     63        BitBlock QMark;
     64        BitBlock Hyphen;
     65        BitBlock Equals;
     66        BitBlock SQuote;
     67        BitBlock DQuote;
     68        BitBlock Slash;
     69        BitBlock Hash;
     70        BitBlock x;
     71        BitBlock ASCII_name_start;
     72        BitBlock ASCII_name_char;
     73        BitBlock NameScan;
     74        BitBlock Digit;
     75        BitBlock Hex;
     76        BitBlock WS;
     77};
     78 
     79struct Marker
     80{
     81        BitBlock LAngle_scope;
     82        BitBlock Ref_opener;
     83        BitBlock CD_closer;
     84};
     85 
     86struct CtCDPI_Callouts
     87{
     88        BitBlock Ct_starts;
     89        BitBlock Ct_ends;
     90        BitBlock CD_starts;
     91        BitBlock CD_ends;
     92        BitBlock PI_starts;
     93        BitBlock PI_name_starts;
     94        BitBlock PI_name_ends;
     95        BitBlock PI_ends;
     96};
     97 
     98struct Ref_Callouts
     99{
     100        BitBlock GenRef_starts;
     101        BitBlock GenRef_ends;
     102        BitBlock DecRef_starts;
     103        BitBlock DecRef_ends;
     104        BitBlock HexRef_starts;
     105        BitBlock HexRef_ends;
     106};
     107 
     108struct Tag_Callouts
     109{
     110        BitBlock ElemName_starts;
     111        BitBlock ElemName_ends;
     112        BitBlock AttName_starts;
     113        BitBlock AttName_ends;
     114        BitBlock AttVal_starts;
     115        BitBlock AttVal_ends;
     116        BitBlock AttVal_spans;
     117        BitBlock EmptyTag_marks;
     118        BitBlock EndTag_marks;
     119};
     120 
     121struct Check_streams
     122{
     123        BitBlock misc_mask;
     124        BitBlock non_ascii_name_starts;
     125        BitBlock non_ascii_names;
     126        BitBlock tag_marks;
     127        BitBlock name_follows;
     128        BitBlock att_refs;
     129};     
    2130       
    3131kernel BasisBits
     
    11139        {
    12140               
    13                 simd.add<
     141               
    14142        }
    15143
  • proto/pabloj/trunk/input/test/pabloS/all/all.bash

    r2834 r2984  
    11#!/bin/bash
    2 find .. -name "*.pablo" | xargs cat > temp
    3 mv temp all.pablo
     2find .. -name "*.pablos" -not -name all.pablos | xargs cat > temp
     3mv temp all.pablos
  • proto/pabloj/trunk/input/test/pabloS/all/all.pablos

    r2834 r2984  
    66};
    77struct BasisBits {
    8         stream b1;
    9         stream b2;
    10         stream b3;
    11         stream b4;
     8        stream<1> b1;
     9        stream<1> b2;
     10        stream<1> b3;
     11        stream<1> b4;
    1212};
    1313
    1414function void Foo() {
    1515
    16 }
    17 function void AssignmentExpressions() {
    18         temp4 = temp;
    19         temp4 &= temp1 | temp2;
    20         temp4 |= temp1 ^ temp2;
    21         temp4 ^= temp1 & temp2;
    22 //      temp4 ~= temp1 ^ temp2 | temp3;
     16}function void RecordExpressions() {
     17
     18        // records
     19        temp4 = temp1.temp2;
     20        temp4 = temp1.temp2.temp3;
     21       
     22        temp1.temp2 = temp4;
     23        temp1.temp2.temp3 = temp4;
     24               
    2325};function void BasicExpressions() {
    2426
     
    3840
    3941function void Assignments() {
    40         var stream s;
     42        var stream<1> s;
     43        var stream<1> a;
     44        var stream<1> b;
     45        var stream<1> c;
     46        //s |= 0;
     47        //s = a | b | c;
     48        s |= a;
     49        s |= a | b;
     50        s |= a | b | c;
     51        s |= a | b | c | d;
     52        // s = s | a | b | c;
     53};function struct A FunctionExpressions() {
     54         var stream<1> a = b.Advance();
     55};
     56
     57function void AssignmentExpressions() {
     58        temp4 = temp;
     59        temp4 &= temp1 | temp2;
     60        temp4 |= temp1 ^ temp2;
     61        temp4 ^= temp1 & temp2;
     62//      temp4 ~= temp1 ^ temp2 | temp3;
     63};function void Assignments() {
     64        var stream<1> s;
    4165        s = 0;
    4266        s &= 0;
     
    4468//      s ~= 0;
    4569        s ^= 0;
    46 };function struct A FunctionExpressions() {
    47          var stream<1> a = b.Advance();
    48 };
    49 function void RecordExpressions() {
    50 
    51         // records
    52         temp4 = temp1.temp2;
    53         temp4 = temp1.temp2.temp3;
    54        
    55         temp1.temp2 = temp4;
    56         temp1.temp2.temp3 = temp4;
    57                
    58 };function void localDecl() {
    59         var stream A;
    60         var stream A=0;
    61 }function void localDecl() {
     70};function void Function(struct TagCallouts tagCallouts, struct Lex lex) {     
     71
     72        var stream<1> starts_accum = 0;
     73        var stream<1> ends_accum = 0;   
     74       
     75        var stream<1> cursor = pablo.ScanToFirst(lex.opener);
     76       
     77        while (cursor) {
     78                starts_accum |= cursor;
     79                cursor = pablo.ScanTo(cursor, lex.marker &~ cursor);
     80                ends_accum |= cursor;
     81                cursor = pablo.ScanTo(cursor, (lex.marker | lex.terminator) &~ cursor);
     82                cursor = cursor & lex.marker;
     83        }
     84};
     85function void While() {
     86                       
     87        var stream<1> cursor = 1;
     88       
     89        while (cursor) {
     90          cursor = pablo.Advance(cursor);
     91        };
     92}
     93function void While() {
     94       
     95        var stream<1> cursor;
     96       
     97        while (cursor) {
     98                cursor = pablo.Advance(cursor);
     99                cursor = cursor &~ terminator;
     100        };
     101}
     102function void Function() {     
     103        var stream<1> cursor1;
     104       
     105        while (cursor1) {
     106                var stream<1> cursor2;
     107                while(cursor2) {
     108                        cursor = pablo.Advance(cursor);
     109                        // cursor = cursor &~ terminator;
     110                }
     111        }
     112}
     113function void localDecl() {
    62114
    63115var struct BasisBits {
     
    68120} A;
    69121
    70 };function void Assignments() {
    71         var stream s = 4;
    72         var stream s &= 4;
    73         var stream s |= 4;
    74 //      var stream s ~= 4;
    75         var stream s ^= 4;
     122};function void localDecl() {
     123        var stream<1> A;
     124        var stream<1> A=0;
    76125}function void localDecl() {
    77126
    78127        var struct BasisBits {
    79         stream b1;
    80         stream b2;
    81         stream b3;
    82         stream b4;
     128        stream<1> b1;
     129        stream<1> b2;
     130        stream<1> b3;
     131        stream<1> b4;
    83132        } A;
    84133
    85 } function void Function() {   
    86        
    87         if(cursor & a) {
    88                 if(cursor & b) {
    89                
    90                 }
     134} function void Assignments() {
     135        var stream<1> s = 4;
     136}function void Function() {             
     137        if(cursor) {
     138
    91139        }
    92        
    93140}
    94141function void Function() {     
     
    106153       
    107154}
    108 function void Function() {             
    109         if(cursor) {
    110 
     155function void Function() {     
     156       
     157        if(cursor & a) {
     158                if(cursor & b) {
     159               
     160                }
    111161        }
     162       
    112163}
    113164function void Function() {     
     
    120171       
    121172}
    122 function struct Lex ClassifyBytes(struct BasisBit basis) {};
    123 function stream Function(stream a, stream b, stream c) {};
    124 struct B
    125 {
    126         stream a;
    127         stream a;
    128         stream a;
    129         stream a;
    130 };
    131 
    132 function struct B Foo() { }
    133 struct Lex {
    134         stream LAngle;
    135         stream RAngle;
    136 };
    137 
    138 typedef struct Lex Lex;
    139 
    140 typedef Lex Lex;typedef stream s;
    141 
    142 typedef stream<1> s1;typedef struct BasisBits {
    143 stream b1;
    144 stream b2;
    145 stream b3;
    146 stream b4;
    147 } BasisBitsAlias;
     173// PabloS version of parabix2_pablo.py generated with py2pabloS.py
    148174
    149175struct Basis_bits{
     
    158184};
    159185
    160 struct u8{
     186struct U8{
    161187    stream<1> unibyte;
    162188    stream<1> prefix;
     
    363389    pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    364390    u8.unibyte = (~ basis_bits.bit_0);
    365     u8.suffix = 0;
    366     var stream<1> u8_error = 0;
    367     var stream<1> u8_FFFE_FFFF = 0;
    368     var stream<1> u8anyscope = 0;
     391    u8.suffix = pablo.Mask(1,0);
     392    var stream<1> u8_error = pablo.Mask(1,0);
     393    var stream<1> u8_FFFE_FFFF = pablo.Mask(1,0);
     394    var stream<1> u8anyscope = pablo.Mask(1,0);
    369395    if (basis_bits.bit_0) {
    370396        u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     
    425451
    426452function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    427     ctCDPI_Callouts.Ct_starts = 0;
    428     ctCDPI_Callouts.Ct_ends = 0;
    429     ctCDPI_Callouts.CD_starts = 0;
    430     ctCDPI_Callouts.CD_ends = 0;
    431     ctCDPI_Callouts.PI_starts = 0;
    432     ctCDPI_Callouts.PI_name_starts = 0;
    433     ctCDPI_Callouts.PI_name_ends = 0;
    434     ctCDPI_Callouts.PI_ends = 0;
    435     var stream<1> CtCDPI_starts = 0;
    436     var stream<1> CtCDPI_ends = 0;
    437     var stream<1> ctCDPI_mask = 0;
     453    ctCDPI_Callouts.Ct_starts = pablo.Mask(1,0);
     454    ctCDPI_Callouts.Ct_ends = pablo.Mask(1,0);
     455    ctCDPI_Callouts.CD_starts = pablo.Mask(1,0);
     456    ctCDPI_Callouts.CD_ends = pablo.Mask(1,0);
     457    ctCDPI_Callouts.PI_starts = pablo.Mask(1,0);
     458    ctCDPI_Callouts.PI_name_starts = pablo.Mask(1,0);
     459    ctCDPI_Callouts.PI_name_ends = pablo.Mask(1,0);
     460    ctCDPI_Callouts.PI_ends = pablo.Mask(1,0);
     461    var stream<1> CtCDPI_starts = pablo.Mask(1,0);
     462    var stream<1> CtCDPI_ends = pablo.Mask(1,0);
     463    var stream<1> ctCDPI_mask = pablo.Mask(1,0);
    438464    var stream<1> v = (lex.LAngle | lex.Hyphen);
    439465    var stream<1> w = (lex.Hyphen | lex.QMark);
     
    444470    var stream<1> CtCD_opener = (LAngle_scope & lex.Exclam);
    445471    var stream<1> CtCDPI_opener = (PI_opener | CtCD_opener);
    446     var stream<1> CD_closer = 0;
     472    var stream<1> CD_closer = pablo.Mask(1,0);
    447473    var stream<1> DoubleHyphen = ((v1 & w1) & lex.Hyphen);
    448474    if (lex.RBracket) {
     
    500526
    501527function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
     528    var stream<1> EqExpected = pablo.Mask(1,0);
     529    var stream<1> AttListEnd = pablo.Mask(1,0);
    502530    var stream<1> DQuoteDelim = (lex.DQuote | lex.LAngle);
    503531    var stream<1> SQuoteDelim = (lex.SQuote | lex.LAngle);
     
    507535    tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    508536    var stream<1> ParseError = (tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends);
    509     tag_Callouts.AttName_starts = 0;
    510     tag_Callouts.AttName_ends = 0;
    511     tag_Callouts.AttVal_starts = 0;
    512     tag_Callouts.AttVal_ends = 0;
     537    tag_Callouts.AttName_starts = pablo.Mask(1,0);
     538    tag_Callouts.AttName_ends = pablo.Mask(1,0);
     539    tag_Callouts.AttVal_starts = pablo.Mask(1,0);
     540    tag_Callouts.AttVal_ends = pablo.Mask(1,0);
    513541    if ((tag_Callouts.ElemName_ends & lex.WS)) {
    514542        var stream<1> AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    515         var stream<1> AttListEnd = (AfterWS & AttListDelim);
     543        AttListEnd = (AfterWS & AttListDelim);
    516544        var stream<1> AttNameStart = (AfterWS & (~ AttListDelim));
    517545        while (AttNameStart) {
     
    521549            tag_Callouts.AttName_ends |= AttNameFollow;
    522550            if ((AttNameFollow & lex.WS)) {
    523                 var stream<1> EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
     551                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
    524552            }
    525553            else {
    526                 var stream<1> EqExpected = AttNameFollow;
     554                EqExpected = AttNameFollow;
    527555            }
    528556            ParseError |= (EqExpected & (~ lex.Equals));
     
    544572            else {
    545573                AttListEnd |= (AttValFollow & AttListDelim);
    546                 AttNameStart = 0;
    547                 ParseError |= (AttValFollow & (~ AttListDelim));
     574                AttNameStart = (AttValFollow & (~ AttListDelim));
    548575            }
     576            ParseError |= (AttValFollow & AttNameStart);
    549577        }
    550578    }
    551579    else {
    552         var stream<1> AttListEnd = (tag_Callouts.ElemName_ends & AttListDelim);
     580        AttListEnd = (tag_Callouts.ElemName_ends & AttListDelim);
    553581        ParseError |= (tag_Callouts.ElemName_ends & (~ AttListDelim));
    554582    }
     
    566594
    567595function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    568     ref_Callouts.GenRef_starts = 0;
    569     ref_Callouts.GenRef_ends = 0;
    570     ref_Callouts.DecRef_starts = 0;
    571     ref_Callouts.DecRef_ends = 0;
    572     ref_Callouts.HexRef_starts = 0;
    573     ref_Callouts.HexRef_ends = 0;
    574     var stream<1> ref_error = 0;
     596    ref_Callouts.GenRef_starts = pablo.Mask(1,0);
     597    ref_Callouts.GenRef_ends = pablo.Mask(1,0);
     598    ref_Callouts.DecRef_starts = pablo.Mask(1,0);
     599    ref_Callouts.DecRef_ends = pablo.Mask(1,0);
     600    ref_Callouts.HexRef_starts = pablo.Mask(1,0);
     601    ref_Callouts.HexRef_ends = pablo.Mask(1,0);
     602    var stream<1> ref_error = pablo.Mask(1,0);
    575603    if (marker.Ref_opener) {
    576604        var stream<1> Ref_scope = pablo.Advance(marker.Ref_opener);
     
    619647    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
    620648}
    621 
    622 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) {
    623     Classify_bytes_Validate_utf8(basis_bits, lex, u8);
    624     Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams);
    625     Parse_tags(lex, marker, tag_Callouts);
    626     Parse_refs(lex, marker, ref_Callouts);
    627     Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
    628     Do_check_streams(marker, tag_Callouts, check_streams);
    629 }
    630 
    631 
    632 
    633 function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    634     ctCDPI_Callouts.Ct_starts = 0;
    635     ctCDPI_Callouts.Ct_ends = 0;
    636     ctCDPI_Callouts.CD_starts = 0;
    637     ctCDPI_Callouts.CD_ends = 0;
    638     ctCDPI_Callouts.PI_starts = 0;
    639     ctCDPI_Callouts.PI_name_starts = 0;
    640     ctCDPI_Callouts.PI_name_ends = 0;
    641     ctCDPI_Callouts.PI_ends = 0;
    642     var stream<1> CtCDPI_starts = 0;
    643     var stream<1> CtCDPI_ends = 0;
    644     var stream<1> ctCDPI_mask = 0;
    645     var stream<1> v = (lex.LAngle | lex.Hyphen);
    646     var stream<1> w = (lex.Hyphen | lex.QMark);
    647     var stream<1> v1 = pablo.Advance(v);
    648     var stream<1> w1 = pablo.Advance(w);
    649     var stream<1> LAngle_scope = (v1 & (~ w1));
    650     var stream<1> PI_opener = (LAngle_scope & lex.QMark);
    651     var stream<1> CtCD_opener = (LAngle_scope & lex.Exclam);
    652     var stream<1> CtCDPI_opener = (PI_opener | CtCD_opener);
    653     var stream<1> CD_closer = 0;
    654     var stream<1> DoubleHyphen = ((v1 & w1) & lex.Hyphen);
    655     if (lex.RBracket) {
    656         var stream<1> DoubleRBracket = (pablo.Advance(lex.RBracket) & lex.RBracket);
    657         CD_closer = (pablo.Advance(DoubleRBracket) & lex.RAngle);
    658     }
    659     var stream<1> PI_closer = ((w1 & (~ v1)) & lex.RAngle);
    660     var stream<1> CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
    661     while (CtCDPI_Cursor) {
    662         CtCDPI_starts |= CtCDPI_Cursor;
    663         var stream<1> PI_Cursor = (CtCDPI_Cursor & PI_opener);
    664         var stream<1> CD_Ct_Cursor = pablo.Advance((CtCDPI_Cursor & (~ PI_Cursor)));
    665         var stream<1> CD_Cursor = (CD_Ct_Cursor & lex.LBracket);
    666         var stream<1> Ct_Cursor = (CD_Ct_Cursor & lex.Hyphen);
    667         if (PI_Cursor) {
    668             ctCDPI_Callouts.PI_starts |= PI_Cursor;
    669             PI_Cursor = pablo.AdvanceThenScanTo(PI_Cursor, PI_closer);
    670             ctCDPI_Callouts.PI_ends |= PI_Cursor;
    671             CtCDPI_ends |= PI_Cursor;
    672         }
    673         if (CD_Cursor) {
    674             ctCDPI_Callouts.CD_starts |= CD_Cursor;
    675             CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
    676             ctCDPI_Callouts.CD_ends |= CD_Cursor;
    677             CtCDPI_ends |= CD_Cursor;
    678         }
    679         if (Ct_Cursor) {
    680             ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
    681             Ct_Cursor = pablo.Advance(Ct_Cursor);
    682             Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
    683             Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
    684             ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
    685             CtCDPI_ends |= Ct_Cursor;
    686         }
    687         CtCDPI_Cursor = ((PI_Cursor | CD_Cursor) | Ct_Cursor);
    688         CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener);
    689     }
    690     if (((CtCDPI_starts | ctCDPI_Callouts.Ct_starts) | ctCDPI_Callouts.Ct_ends)) {
    691         ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
    692         var stream<1> ctCDPI_error = pablo.atEOF(ctCDPI_mask);
    693         if (ctCDPI_error) {
    694             error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
    695         }
    696         if (ctCDPI_Callouts.PI_starts) {
    697             ctCDPI_Callouts.PI_name_starts = pablo.Advance(ctCDPI_Callouts.PI_starts);
    698             ctCDPI_Callouts.PI_name_ends = pablo.ScanThru(ctCDPI_Callouts.PI_name_starts, lex.NameScan);
    699             var stream<1> no_PI_name = (ctCDPI_Callouts.PI_name_starts & ctCDPI_Callouts.PI_name_ends);
    700             if (no_PI_name) {
    701                 error_tracker.NoteError("Error in PI syntax", no_PI_name);
    702             }
    703             var stream<1> check_for_PI_closer = (ctCDPI_Callouts.PI_name_ends & (~ lex.WS));
    704             if (check_for_PI_closer) {
    705                 var stream<1> PI_error = (pablo.Advance(check_for_PI_closer) & (~ PI_closer));
    706                 if (PI_error) {
    707                     error_tracker.NoteError("Error in PI syntax", PI_error);
    708                 }
    709             }
    710         }
    711         if (ctCDPI_Callouts.Ct_starts) {
    712             var stream<1> Ct_error = (pablo.Advance(ctCDPI_Callouts.Ct_starts) & (~ lex.Hyphen));
    713             if (Ct_error) {
    714                 error_tracker.NoteError("Error in comment opener", Ct_error);
    715             }
    716         }
    717         if ((ctCDPI_Callouts.Ct_ends & (~ lex.RAngle))) {
    718             error_tracker.NoteError("Error in comment syntax", (ctCDPI_Callouts.Ct_ends & (~ lex.RAngle)));
    719         }
    720     }
    721     check_streams.misc_mask = ((((lex.WS | lex.LAngle) | pablo.InclusiveSpan((ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts), (ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends))) | CtCDPI_starts) & EOF_mask);
    722     marker.LAngle_scope = (LAngle_scope & (~ ctCDPI_mask));
    723     marker.Ref_opener = (lex.RefStart & (~ ctCDPI_mask));
    724     marker.CD_closer &= (CD_closer &~ ctCDPI_mask);
    725 }
     649struct bb {
     650        stream<1> a;
     651
     652};
     653
     654/*
     655function stream<1> Function(stream<1> a, stream<1> b, stream<1> c) {
     656
     657
     658};
     659*/
     660struct B
     661{
     662        stream<1> a;
     663        stream<1> a;
     664        stream<1> a;
     665        stream<1> a;
     666};
     667
     668function struct B Foo() { }
     669function struct Lex ClassifyBytes(struct BasisBit basis) {};
  • proto/pabloj/trunk/input/test/pabloS/proto/parabix2_pablo.pablos

    r2981 r2984  
    1 
     1// PabloS version of parabix2_pablo.py generated with py2pabloS.py
    22
    33struct Basis_bits{
  • proto/pabloj/trunk/input/test/pabloS/statements/localDecl/localDecl5.pablos

    r2981 r2984  
    11function void Assignments() {
    22        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;
    73}
  • proto/pabloj/trunk/runConfigurations/PabloBAST.launch

    r2981 r2984  
    88</listAttribute>
    99<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"/>
     10<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/pabloB/all/all.pablob"/>
    1111<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1212</launchConfiguration>
  • proto/pabloj/trunk/runConfigurations/PabloSAST.launch

    r2981 r2984  
    99</listAttribute>
    1010<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"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/pabloS/all/all.pablos"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313</launchConfiguration>
  • proto/pabloj/trunk/src/compilers/pabloB/ast/Accessors.java

    r2981 r2984  
    261261        // Void Type
    262262        ////////////////////////////////////////////////////////////////////////////   
    263         public static String voidLexeme(VoidNode node) {               
     263        public static String voidLexeme(VoidTypeNode node) {           
    264264                return node.getToken().getLexeme();
    265265        }       
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/visitors/CPPUnparser.java

    r2981 r2984  
    560560
    561561        // Void
    562         public CodeStore visitLeave(VoidNode node, List<CodeStore> childResults) {
     562        public CodeStore visitLeave(VoidTypeNode node, List<CodeStore> childResults) {
    563563                CodeStore code = new CodeStore();
    564564                code.setResultVarName(Accessors.voidLexeme(node));
  • proto/pabloj/trunk/src/compilers/pabloS/ast/Accessors.java

    r2970 r2984  
    305305        }       
    306306
    307         public static String voidValueLexeme(VoidNode node) {           
     307        public static String voidValueLexeme(VoidTypeNode node) {               
    308308                return node.getToken().getLexeme();
    309309        }       
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r2981 r2984  
    518518               
    519519                /*
    520                 public void visitEnter(VoidNode node) {
    521                         defaultVisitEnter(node);
    522                 }
    523                 */
    524                
    525                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.VoidNode node, List<pabloB.ast.ASTNode> childResults) {
    526                         pabloB.ast.ASTNode bNode = new pabloB.ast.VoidNode(Generators.makePabloBToken(node.getToken()));
     520                public void visitEnter(VoidType node) {
     521                        defaultVisitEnter(node);
     522                }
     523                */
     524               
     525                public pabloB.ast.ASTNode visitLeave(pabloS.ast.VoidTypeNode node, List<pabloB.ast.ASTNode> childResults) {
     526                        pabloB.ast.ASTNode bNode = new pabloB.ast.VoidTypeNode(Generators.makePabloBToken(node.getToken()));
    527527                        appendChildResults(bNode, childResults);
    528528                        return bNode;
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r2981 r2984  
    1616        public ASTNode visit(AssignOperatorNode node);
    1717
     18        public ASTNode visit(BitBlockTypeNode node);
     19
    1820        public ASTNode visit(BlockStmtNode node);
    1921
     
    4850        public ASTNode visit(IntegerConstantNode node);
    4951
    50         public ASTNode visit(IntegerTypeNode node);
    51 
    5252        public ASTNode visit(KernelDefNode node);
    5353
     
    8686        public ASTNode visit(TypeDeclNode node);
    8787
    88         public ASTNode visit(VoidNode node);
     88        public ASTNode visit(Uint128TypeNode node);
     89
     90        public ASTNode visit(Uint16TypeNode node);
     91
     92        public ASTNode visit(Uint256TypeNode node);
     93
     94        public ASTNode visit(Uint32TypeNode node);
     95
     96        public ASTNode visit(Uint64TypeNode node);
     97
     98        public ASTNode visit(Uint8TypeNode node);
     99
     100        public ASTNode visit(VoidTypeNode node);
    89101
    90102        public ASTNode visit(WhileStmtNode node);
     
    109121                }
    110122
     123                public ASTNode visit(BitBlockTypeNode node) {
     124                        return defaultVisit(node);
     125                }
     126
    111127                public ASTNode visit(BlockStmtNode node) {
    112128                        return defaultVisit(node);
     
    173189                }
    174190
    175                 public ASTNode visit(IntegerTypeNode node) {
    176                         return defaultVisit(node);
    177                 }
    178 
    179191                public ASTNode visit(KernelDefNode node) {
    180192                        return defaultVisit(node);
     
    249261                }
    250262
    251                 public ASTNode visit(VoidNode node) {
     263                public ASTNode visit(Uint128TypeNode node) {
     264                        return defaultVisit(node);
     265                }
     266
     267                public ASTNode visit(Uint16TypeNode node) {
     268                        return defaultVisit(node);
     269                }
     270
     271                public ASTNode visit(Uint256TypeNode node) {
     272                        return defaultVisit(node);
     273                }
     274
     275                public ASTNode visit(Uint32TypeNode node) {
     276                        return defaultVisit(node);
     277                }
     278
     279                public ASTNode visit(Uint64TypeNode node) {
     280                        return defaultVisit(node);
     281                }
     282
     283                public ASTNode visit(Uint8TypeNode node) {
     284                        return defaultVisit(node);
     285                }
     286
     287                public ASTNode visit(VoidTypeNode node) {
    252288                        return defaultVisit(node);
    253289                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r2981 r2984  
    2020        public T visitLeave(AssignOperatorNode node, List<T> childResults);
    2121
     22        public void visitEnter(BitBlockTypeNode node);
     23        public T visitLeave(BitBlockTypeNode node, List<T> childResults);
     24
    2225        public void visitEnter(BlockStmtNode node);
    2326        public T visitLeave(BlockStmtNode node, List<T> childResults);
     
    6871        public T visitLeave(IntegerConstantNode node, List<T> childResults);
    6972
    70         public void visitEnter(IntegerTypeNode node);
    71         public T visitLeave(IntegerTypeNode node, List<T> childResults);
    72 
    7373        public void visitEnter(KernelDefNode node);
    7474        public T visitLeave(KernelDefNode node, List<T> childResults);
     
    125125        public T visitLeave(TypeDeclNode node, List<T> childResults);
    126126
    127         public void visitEnter(VoidNode node);
    128         public T visitLeave(VoidNode node, List<T> childResults);
     127        public void visitEnter(Uint128TypeNode node);
     128        public T visitLeave(Uint128TypeNode node, List<T> childResults);
     129
     130        public void visitEnter(Uint16TypeNode node);
     131        public T visitLeave(Uint16TypeNode node, List<T> childResults);
     132
     133        public void visitEnter(Uint256TypeNode node);
     134        public T visitLeave(Uint256TypeNode node, List<T> childResults);
     135
     136        public void visitEnter(Uint32TypeNode node);
     137        public T visitLeave(Uint32TypeNode node, List<T> childResults);
     138
     139        public void visitEnter(Uint64TypeNode node);
     140        public T visitLeave(Uint64TypeNode node, List<T> childResults);
     141
     142        public void visitEnter(Uint8TypeNode node);
     143        public T visitLeave(Uint8TypeNode node, List<T> childResults);
     144
     145        public void visitEnter(VoidTypeNode node);
     146        public T visitLeave(VoidTypeNode node, List<T> childResults);
    129147
    130148        public void visitEnter(WhileStmtNode node);
     
    169187                }
    170188
     189                public void visitEnter(BitBlockTypeNode node) {
     190                        defaultVisitEnter(node);
     191                }
     192                public T visitLeave(BitBlockTypeNode node, List<T> childResults) {
     193                        return defaultVisitLeave(node);
     194                }
     195
    171196                public void visitEnter(BlockStmtNode node) {
    172197                        defaultVisitEnter(node);
     
    281306                }
    282307
    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 
    290308                public void visitEnter(KernelDefNode node) {
    291309                        defaultVisitEnter(node);
     
    414432                }
    415433
    416                 public void visitEnter(VoidNode node) {
    417                         defaultVisitEnter(node);
    418                 }
    419                 public T visitLeave(VoidNode node, List<T> childResults) {
     434                public void visitEnter(Uint128TypeNode node) {
     435                        defaultVisitEnter(node);
     436                }
     437                public T visitLeave(Uint128TypeNode node, List<T> childResults) {
     438                        return defaultVisitLeave(node);
     439                }
     440
     441                public void visitEnter(Uint16TypeNode node) {
     442                        defaultVisitEnter(node);
     443                }
     444                public T visitLeave(Uint16TypeNode node, List<T> childResults) {
     445                        return defaultVisitLeave(node);
     446                }
     447
     448                public void visitEnter(Uint256TypeNode node) {
     449                        defaultVisitEnter(node);
     450                }
     451                public T visitLeave(Uint256TypeNode node, List<T> childResults) {
     452                        return defaultVisitLeave(node);
     453                }
     454
     455                public void visitEnter(Uint32TypeNode node) {
     456                        defaultVisitEnter(node);
     457                }
     458                public T visitLeave(Uint32TypeNode node, List<T> childResults) {
     459                        return defaultVisitLeave(node);
     460                }
     461
     462                public void visitEnter(Uint64TypeNode node) {
     463                        defaultVisitEnter(node);
     464                }
     465                public T visitLeave(Uint64TypeNode node, List<T> childResults) {
     466                        return defaultVisitLeave(node);
     467                }
     468
     469                public void visitEnter(Uint8TypeNode node) {
     470                        defaultVisitEnter(node);
     471                }
     472                public T visitLeave(Uint8TypeNode node, List<T> childResults) {
     473                        return defaultVisitLeave(node);
     474                }
     475
     476                public void visitEnter(VoidTypeNode node) {
     477                        defaultVisitEnter(node);
     478                }
     479                public T visitLeave(VoidTypeNode node, List<T> childResults) {
    420480                        return defaultVisitLeave(node);
    421481                }
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r2981 r2984  
    1717        public void visit(AssignOperatorNode node);
    1818
     19        public void visit(BitBlockTypeNode node);
     20
    1921        public void visit(BlockStmtNode node);
    2022
     
    4951        public void visit(IntegerConstantNode node);
    5052
    51         public void visit(IntegerTypeNode node);
    52 
    5353        public void visit(KernelDefNode node);
    5454
     
    8787        public void visit(TypeDeclNode node);
    8888
    89         public void visit(VoidNode node);
     89        public void visit(Uint128TypeNode node);
     90
     91        public void visit(Uint16TypeNode node);
     92
     93        public void visit(Uint256TypeNode node);
     94
     95        public void visit(Uint32TypeNode node);
     96
     97        public void visit(Uint64TypeNode node);
     98
     99        public void visit(Uint8TypeNode node);
     100
     101        public void visit(VoidTypeNode node);
    90102
    91103        public void visit(WhileStmtNode node);
     
    110122                }
    111123
     124                public void visit(BitBlockTypeNode node) {
     125                        defaultVisit(node);
     126                }
     127
    112128                public void visit(BlockStmtNode node) {
    113129                        defaultVisit(node);
     
    174190                }
    175191
    176                 public void visit(IntegerTypeNode node) {
    177                         defaultVisit(node);
    178                 }
    179 
    180192                public void visit(KernelDefNode node) {
    181193                        defaultVisit(node);
     
    250262                }
    251263
    252                 public void visit(VoidNode node) {
     264                public void visit(Uint128TypeNode node) {
     265                        defaultVisit(node);
     266                }
     267
     268                public void visit(Uint16TypeNode node) {
     269                        defaultVisit(node);
     270                }
     271
     272                public void visit(Uint256TypeNode node) {
     273                        defaultVisit(node);
     274                }
     275
     276                public void visit(Uint32TypeNode node) {
     277                        defaultVisit(node);
     278                }
     279
     280                public void visit(Uint64TypeNode node) {
     281                        defaultVisit(node);
     282                }
     283
     284                public void visit(Uint8TypeNode node) {
     285                        defaultVisit(node);
     286                }
     287
     288                public void visit(VoidTypeNode node) {
    253289                        defaultVisit(node);
    254290                }
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r2981 r2984  
    1818        public void visitLeave(AssignOperatorNode node);
    1919
     20        public void visitEnter(BitBlockTypeNode node);
     21        public void visitLeave(BitBlockTypeNode node);
     22
    2023        public void visitEnter(BlockStmtNode node);
    2124        public void visitLeave(BlockStmtNode node);
     
    6669        public void visitLeave(IntegerConstantNode node);
    6770
    68         public void visitEnter(IntegerTypeNode node);
    69         public void visitLeave(IntegerTypeNode node);
    70 
    7171        public void visitEnter(KernelDefNode node);
    7272        public void visitLeave(KernelDefNode node);
     
    123123        public void visitLeave(TypeDeclNode node);
    124124
    125         public void visitEnter(VoidNode node);
    126         public void visitLeave(VoidNode node);
     125        public void visitEnter(Uint128TypeNode node);
     126        public void visitLeave(Uint128TypeNode node);
     127
     128        public void visitEnter(Uint16TypeNode node);
     129        public void visitLeave(Uint16TypeNode node);
     130
     131        public void visitEnter(Uint256TypeNode node);
     132        public void visitLeave(Uint256TypeNode node);
     133
     134        public void visitEnter(Uint32TypeNode node);
     135        public void visitLeave(Uint32TypeNode node);
     136
     137        public void visitEnter(Uint64TypeNode node);
     138        public void visitLeave(Uint64TypeNode node);
     139
     140        public void visitEnter(Uint8TypeNode node);
     141        public void visitLeave(Uint8TypeNode node);
     142
     143        public void visitEnter(VoidTypeNode node);
     144        public void visitLeave(VoidTypeNode node);
    127145
    128146        public void visitEnter(WhileStmtNode node);
     
    166184                }
    167185
     186                public void visitEnter(BitBlockTypeNode node) {
     187                        defaultVisitEnter(node);
     188                }
     189                public void visitLeave(BitBlockTypeNode node) {
     190                        defaultVisitLeave(node);
     191                }
     192
    168193                public void visitEnter(BlockStmtNode node) {
    169194                        defaultVisitEnter(node);
     
    278303                }
    279304
    280                 public void visitEnter(IntegerTypeNode node) {
    281                         defaultVisitEnter(node);
    282                 }
    283                 public void visitLeave(IntegerTypeNode node) {
    284                         defaultVisitLeave(node);
    285                 }
    286 
    287305                public void visitEnter(KernelDefNode node) {
    288306                        defaultVisitEnter(node);
     
    411429                }
    412430
    413                 public void visitEnter(VoidNode node) {
    414                         defaultVisitEnter(node);
    415                 }
    416                 public void visitLeave(VoidNode node) {
     431                public void visitEnter(Uint128TypeNode node) {
     432                        defaultVisitEnter(node);
     433                }
     434                public void visitLeave(Uint128TypeNode node) {
     435                        defaultVisitLeave(node);
     436                }
     437
     438                public void visitEnter(Uint16TypeNode node) {
     439                        defaultVisitEnter(node);
     440                }
     441                public void visitLeave(Uint16TypeNode node) {
     442                        defaultVisitLeave(node);
     443                }
     444
     445                public void visitEnter(Uint256TypeNode node) {
     446                        defaultVisitEnter(node);
     447                }
     448                public void visitLeave(Uint256TypeNode node) {
     449                        defaultVisitLeave(node);
     450                }
     451
     452                public void visitEnter(Uint32TypeNode node) {
     453                        defaultVisitEnter(node);
     454                }
     455                public void visitLeave(Uint32TypeNode node) {
     456                        defaultVisitLeave(node);
     457                }
     458
     459                public void visitEnter(Uint64TypeNode node) {
     460                        defaultVisitEnter(node);
     461                }
     462                public void visitLeave(Uint64TypeNode node) {
     463                        defaultVisitLeave(node);
     464                }
     465
     466                public void visitEnter(Uint8TypeNode node) {
     467                        defaultVisitEnter(node);
     468                }
     469                public void visitLeave(Uint8TypeNode node) {
     470                        defaultVisitLeave(node);
     471                }
     472
     473                public void visitEnter(VoidTypeNode node) {
     474                        defaultVisitEnter(node);
     475                }
     476                public void visitLeave(VoidTypeNode node) {
    417477                        defaultVisitLeave(node);
    418478                }
  • proto/pabloj/trunk/src/pabloB/lexicalAnalyzer/Lextant.java

    r2981 r2984  
    2727        LANGLE("<", "main"),
    2828        UINT128("uint128", "main"),
     29        BITBLOCK("BitBlock", "main"),
    2930        VOID("void", "main"),
    3031        ASSIGN("=", "main"),
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r2981 r2984  
    4848                result.setProductionTag(1);
    4949                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    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)) ) {
     50                while( nowReading.isLextant(Lextant.BITBLOCK, 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.BITBLOCK, 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.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¹]");
     73                if( !(nowReading.isLextant(Lextant.BITBLOCK, 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² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    7575                }
    7676       
     
    124124                        }
    125125                }
     126                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     127                        {
     128                                ASTNode child = parseCompoundIdentifier();
     129                                result.appendChild(child);
     130                                allChildren.add(child);
     131                        }
     132                        {
     133                                ASTNode child = parseFuncCallRest();
     134                                result.appendChild(child);
     135                                allChildren.add(child);
     136                        }
     137                        result = promoteLastChild(result);
     138                        allowCompression = false;
     139                }
    126140                expect(Lextant.RCURLY);
    127141                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
     
    348362                }
    349363                expect(Lextant.LROUND);
    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)) ) {
     364                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    351365                        {
    352366                                ASTNode child = parseParameterList();
     
    371385         
    372386        public ASTNode parseReturnType() {
    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¹]");
     387                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     388                        return syntaxErrorNode("returnType² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    375389                }
    376390       
     
    391405         
    392406        public ASTNode parseParameterList() {
    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¹]");
     407                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     408                        return syntaxErrorNode("parameterList² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    395409                }
    396410       
     
    439453         
    440454        public ASTNode parseParameter() {
    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¹]");
     455                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     456                        return syntaxErrorNode("parameter² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    443457                }
    444458       
     
    652666                result.setProductionTag(23);
    653667                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    654                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     668                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    655669                        {
    656670                                ASTNode child = parseExpr();
     
    708722                result.setProductionTag(25);
    709723                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)) ) {
     724                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    711725                        {
    712726                                ASTNode child = parseExpr();
     
    845859                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    846860                expect(Lextant.RETURN);
    847                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     861                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    848862                        {
    849863                                ASTNode child = parseExpr();
     
    943957         
    944958        public ASTNode parseExpr() {
    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¹]");
     959                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     960                        return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
    947961                }
    948962       
     
    951965                result.setProductionTag(34);
    952966                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    953                 if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     967                if( nowReading.isLextant(Lextant.LROUND) ) {
     968                        expect(Lextant.LROUND);
     969                        {
     970                                ASTNode child = parseExpr();
     971                                result.appendChild(child);
     972                                allChildren.add(child);
     973                        }
     974                        expect(Lextant.RROUND);
     975                }
     976                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    954977                        {
    955978                                ASTNode child = parseIntegerConstant();
     
    11291152         
    11301153        public ASTNode parseType() {
    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¹]");
     1154                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     1155                        return syntaxErrorNode("type² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    11331156                }
    11341157       
     
    11371160                result.setProductionTag(40);
    11381161                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1139                 if( nowReading.isLextant(Lextant.STREAM) ) {
     1162                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     1163                        {
     1164                                ASTNode child = parseIdentifier();
     1165                                result.appendChild(child);
     1166                                allChildren.add(child);
     1167                        }
     1168                }
     1169                else if( nowReading.isLextant(Lextant.VOID) ) {
     1170                        {
     1171                                ASTNode child = parseVoidType();
     1172                                result.appendChild(child);
     1173                                allChildren.add(child);
     1174                        }
     1175                }
     1176                else if( nowReading.isLextant(Lextant.STREAM) ) {
    11401177                        {
    11411178                                ASTNode child = parseStreamType();
     
    11511188                        }
    11521189                }
    1153                 else if( nowReading.isLextant(Lextant.VOID) ) {
    1154                         {
    1155                                 ASTNode child = parseVoid();
    1156                                 result.appendChild(child);
    1157                                 allChildren.add(child);
    1158                         }
    1159                 }
    1160                 else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    1161                         {
    1162                                 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();
     1190                else if( nowReading.isLextant(Lextant.UINT8) ) {
     1191                        {
     1192                                ASTNode child = parseUint8Type();
     1193                                result.appendChild(child);
     1194                                allChildren.add(child);
     1195                        }
     1196                }
     1197                else if( nowReading.isLextant(Lextant.UINT16) ) {
     1198                        {
     1199                                ASTNode child = parseUint16Type();
     1200                                result.appendChild(child);
     1201                                allChildren.add(child);
     1202                        }
     1203                }
     1204                else if( nowReading.isLextant(Lextant.UINT32) ) {
     1205                        {
     1206                                ASTNode child = parseUint32Type();
     1207                                result.appendChild(child);
     1208                                allChildren.add(child);
     1209                        }
     1210                }
     1211                else if( nowReading.isLextant(Lextant.UINT64) ) {
     1212                        {
     1213                                ASTNode child = parseUint64Type();
     1214                                result.appendChild(child);
     1215                                allChildren.add(child);
     1216                        }
     1217                }
     1218                else if( nowReading.isLextant(Lextant.UINT128) ) {
     1219                        {
     1220                                ASTNode child = parseUint128Type();
     1221                                result.appendChild(child);
     1222                                allChildren.add(child);
     1223                        }
     1224                }
     1225                else if( nowReading.isLextant(Lextant.UINT256) ) {
     1226                        {
     1227                                ASTNode child = parseUint256Type();
     1228                                result.appendChild(child);
     1229                                allChildren.add(child);
     1230                        }
     1231                }
     1232                else if( nowReading.isLextant(Lextant.BITBLOCK) ) {
     1233                        {
     1234                                ASTNode child = parseBitBlockType();
    11701235                                result.appendChild(child);
    11711236                                allChildren.add(child);
     
    11881253                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11891254                expect(Lextant.STREAM);
    1190                 if( nowReading.isLextant(Lextant.LANGLE) ) {
    1191                         expect(Lextant.LANGLE);
    1192                         {
    1193                                 ASTNode child = parseFieldWidth();
    1194                                 result.appendChild(child);
    1195                                 allChildren.add(child);
    1196                         }
    1197                         expect(Lextant.RANGLE);
    1198                 }
     1255                expect(Lextant.LANGLE);
     1256                {
     1257                        ASTNode child = parseFieldWidth();
     1258                        result.appendChild(child);
     1259                        allChildren.add(child);
     1260                }
     1261                expect(Lextant.RANGLE);
    11991262                if(allowCompression) {
    12001263                        return result;
     
    12431306        }
    12441307         
    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);
     1308        public ASTNode parseUint8Type() {
     1309                if( !(nowReading.isLextant(Lextant.UINT8)) ) {
     1310                        return syntaxErrorNode("uint8Type² [UINT8¹]");
     1311                }
     1312       
     1313                boolean allowCompression = true;
     1314                ASTNode result = new Uint8TypeNode(nowReading);
    12521315                result.setProductionTag(44);
    12531316                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                 }
     1317                expect(Lextant.UINT8);
     1318                if(allowCompression) {
     1319                        return result;
     1320                }
     1321                return result;
     1322        }
     1323         
     1324        public ASTNode parseUint16Type() {
     1325                if( !(nowReading.isLextant(Lextant.UINT16)) ) {
     1326                        return syntaxErrorNode("uint16Type² [UINT16¹]");
     1327                }
     1328       
     1329                boolean allowCompression = true;
     1330                ASTNode result = new Uint16TypeNode(nowReading);
     1331                result.setProductionTag(45);
     1332                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1333                expect(Lextant.UINT16);
     1334                if(allowCompression) {
     1335                        return result;
     1336                }
     1337                return result;
     1338        }
     1339         
     1340        public ASTNode parseUint32Type() {
     1341                if( !(nowReading.isLextant(Lextant.UINT32)) ) {
     1342                        return syntaxErrorNode("uint32Type² [UINT32¹]");
     1343                }
     1344       
     1345                boolean allowCompression = true;
     1346                ASTNode result = new Uint32TypeNode(nowReading);
     1347                result.setProductionTag(46);
     1348                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1349                expect(Lextant.UINT32);
     1350                if(allowCompression) {
     1351                        return result;
     1352                }
     1353                return result;
     1354        }
     1355         
     1356        public ASTNode parseUint64Type() {
     1357                if( !(nowReading.isLextant(Lextant.UINT64)) ) {
     1358                        return syntaxErrorNode("uint64Type² [UINT64¹]");
     1359                }
     1360       
     1361                boolean allowCompression = true;
     1362                ASTNode result = new Uint64TypeNode(nowReading);
     1363                result.setProductionTag(47);
     1364                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1365                expect(Lextant.UINT64);
     1366                if(allowCompression) {
     1367                        return result;
     1368                }
     1369                return result;
     1370        }
     1371         
     1372        public ASTNode parseUint128Type() {
     1373                if( !(nowReading.isLextant(Lextant.UINT128)) ) {
     1374                        return syntaxErrorNode("uint128Type² [UINT128¹]");
     1375                }
     1376       
     1377                boolean allowCompression = true;
     1378                ASTNode result = new Uint128TypeNode(nowReading);
     1379                result.setProductionTag(48);
     1380                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1381                expect(Lextant.UINT128);
     1382                if(allowCompression) {
     1383                        return result;
     1384                }
     1385                return result;
     1386        }
     1387         
     1388        public ASTNode parseUint256Type() {
     1389                if( !(nowReading.isLextant(Lextant.UINT256)) ) {
     1390                        return syntaxErrorNode("uint256Type² [UINT256¹]");
     1391                }
     1392       
     1393                boolean allowCompression = true;
     1394                ASTNode result = new Uint256TypeNode(nowReading);
     1395                result.setProductionTag(49);
     1396                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1397                expect(Lextant.UINT256);
     1398                if(allowCompression) {
     1399                        return result;
     1400                }
     1401                return result;
     1402        }
     1403         
     1404        public ASTNode parseBitBlockType() {
     1405                if( !(nowReading.isLextant(Lextant.BITBLOCK)) ) {
     1406                        return syntaxErrorNode("bitBlockType² [BITBLOCK¹]");
     1407                }
     1408       
     1409                boolean allowCompression = true;
     1410                ASTNode result = new BitBlockTypeNode(nowReading);
     1411                result.setProductionTag(50);
     1412                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1413                expect(Lextant.BITBLOCK);
    12721414                if(allowCompression) {
    12731415                        return result;
     
    12831425                boolean allowCompression = true;
    12841426                ASTNode result = new StructTypeNode(nowReading);
    1285                 result.setProductionTag(45);
     1427                result.setProductionTag(51);
    12861428                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12871429                expect(Lextant.STRUCT);
     
    13111453                boolean allowCompression = true;
    13121454                ASTNode result = new ASTNode(nowReading);
    1313                 result.setProductionTag(46);
     1455                result.setProductionTag(52);
    13141456                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13151457                {
     
    13311473                boolean allowCompression = true;
    13321474                ASTNode result = new StructTypeBodyNode(nowReading);
    1333                 result.setProductionTag(47);
     1475                result.setProductionTag(53);
    13341476                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13351477                expect(Lextant.LCURLY);
     
    13401482                }
    13411483                expect(Lextant.TERMINATOR);
    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)) ) {
     1484                while( nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    13431485                        {
    13441486                                ASTNode child = parseStructMember();
     
    13561498         
    13571499        public ASTNode parseStructMember() {
    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¹]");
     1500                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.STREAM, Lextant.STRUCT, Lextant.UINT128, Lextant.UINT16, Lextant.UINT256, Lextant.UINT32, Lextant.UINT64, Lextant.UINT8, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     1501                        return syntaxErrorNode("structMember² [BITBLOCK¹, IDENTIFIER¹, STREAM¹, STRUCT¹, UINT128¹, UINT16¹, UINT256¹, UINT32¹, UINT64¹, UINT8¹, VOID¹]");
    13601502                }
    13611503       
    13621504                boolean allowCompression = true;
    13631505                ASTNode result = new StructMemberNode(nowReading);
    1364                 result.setProductionTag(48);
     1506                result.setProductionTag(54);
    13651507                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13661508                {
     
    13871529                boolean allowCompression = true;
    13881530                ASTNode result = new ASTNode(nowReading);
    1389                 result.setProductionTag(49);
     1531                result.setProductionTag(55);
    13901532                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13911533                {
     
    14001542        }
    14011543         
    1402         public ASTNode parseVoid() {
     1544        public ASTNode parseVoidType() {
    14031545                if( !(nowReading.isLextant(Lextant.VOID)) ) {
    1404                         return syntaxErrorNode("void² [VOID¹]");
    1405                 }
    1406        
    1407                 boolean allowCompression = true;
    1408                 ASTNode result = new VoidNode(nowReading);
    1409                 result.setProductionTag(50);
     1546                        return syntaxErrorNode("voidType² [VOID¹]");
     1547                }
     1548       
     1549                boolean allowCompression = true;
     1550                ASTNode result = new VoidTypeNode(nowReading);
     1551                result.setProductionTag(56);
    14101552                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14111553                expect(Lextant.VOID);
  • proto/pabloj/trunk/src/pabloS/applications/SampleApplication.java

    r2834 r2984  
    66
    77package  pabloS.applications;
     8
     9import java.io.File;
    810
    911public class SampleApplication {
     
    1618                super();
    1719        }
    18        
    1920       
    2021        protected static void checkArguments(String[] args, String applicationName) {
     
    4546                }
    4647        }
     48       
     49        protected static boolean makeDirectoryIfNecessary(String directoryName) {
     50                return directoryExists(directoryName) || createDirectory(directoryName);
     51        }
     52        protected static boolean fileExists(String filePath) {
     53                return (new File(filePath)).exists();
     54        }
     55        protected static boolean directoryExists(String filePath) {
     56                return fileExists(filePath) && (new File(filePath)).isDirectory();
     57        }
     58        protected static boolean createDirectory(String filePath) {
     59                return (new File(filePath)).mkdirs();
     60        }
     61
     62
     63        protected static void printUsageMessage(String applicationName, String errorMessage) {
     64                System.err.println("usage: " + applicationName + " filename" + " [target output directory]");
     65                System.err.println(errorMessage);
     66                System.exit(EXIT_CODE_FOR_ERROR);
     67        }       
     68       
    4769        private static void exitWithUsageMessage(String applicationName) {
    4870                System.err.println("usage: " + applicationName + " filename [-o outputDirectory]");
  • proto/pabloj/trunk/src/pabloS/ast/ASTTransformer.java

    r2981 r2984  
    6868        public ASTNode visit(UnaryOperatorNode node);
    6969
    70         public ASTNode visit(VoidNode node);
     70        public ASTNode visit(VoidTypeNode node);
    7171
    7272        public ASTNode visit(WhileStmtNode node);
     
    195195                }
    196196
    197                 public ASTNode visit(VoidNode node) {
     197                public ASTNode visit(VoidTypeNode node) {
    198198                        return defaultVisit(node);
    199199                }
  • proto/pabloj/trunk/src/pabloS/ast/ASTVisitor.java

    r2981 r2984  
    9898        public T visitLeave(UnaryOperatorNode node, List<T> childResults);
    9999
    100         public void visitEnter(VoidNode node);
    101         public T visitLeave(VoidNode node, List<T> childResults);
     100        public void visitEnter(VoidTypeNode node);
     101        public T visitLeave(VoidTypeNode node, List<T> childResults);
    102102
    103103        public void visitEnter(WhileStmtNode node);
     
    324324                }
    325325
    326                 public void visitEnter(VoidNode node) {
    327                         defaultVisitEnter(node);
    328                 }
    329                 public T visitLeave(VoidNode node, List<T> childResults) {
     326                public void visitEnter(VoidTypeNode node) {
     327                        defaultVisitEnter(node);
     328                }
     329                public T visitLeave(VoidTypeNode node, List<T> childResults) {
    330330                        return defaultVisitLeave(node);
    331331                }
  • proto/pabloj/trunk/src/pabloS/ast/SimpleVisitor.java

    r2981 r2984  
    6969        public void visit(UnaryOperatorNode node);
    7070
    71         public void visit(VoidNode node);
     71        public void visit(VoidTypeNode node);
    7272
    7373        public void visit(WhileStmtNode node);
     
    196196                }
    197197
    198                 public void visit(VoidNode node) {
     198                public void visit(VoidTypeNode node) {
    199199                        defaultVisit(node);
    200200                }
  • proto/pabloj/trunk/src/pabloS/ast/VoidVisitor.java

    r2981 r2984  
    9696        public void visitLeave(UnaryOperatorNode node);
    9797
    98         public void visitEnter(VoidNode node);
    99         public void visitLeave(VoidNode node);
     98        public void visitEnter(VoidTypeNode node);
     99        public void visitLeave(VoidTypeNode node);
    100100
    101101        public void visitEnter(WhileStmtNode node);
     
    321321                }
    322322
    323                 public void visitEnter(VoidNode node) {
    324                         defaultVisitEnter(node);
    325                 }
    326                 public void visitLeave(VoidNode node) {
     323                public void visitEnter(VoidTypeNode node) {
     324                        defaultVisitEnter(node);
     325                }
     326                public void visitLeave(VoidTypeNode node) {
    327327                        defaultVisitLeave(node);
    328328                }
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r2981 r2984  
    911911                result.setProductionTag(31);
    912912                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    913                 if( nowReading.isLextant(Lextant.STREAM) ) {
     913                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     914                        {
     915                                ASTNode child = parseIdentifier();
     916                                result.appendChild(child);
     917                                allChildren.add(child);
     918                        }
     919                }
     920                else if( nowReading.isLextant(Lextant.STREAM) ) {
    914921                        {
    915922                                ASTNode child = parseStreamType();
     
    927934                else if( nowReading.isLextant(Lextant.VOID) ) {
    928935                        {
    929                                 ASTNode child = parseVoid();
    930                                 result.appendChild(child);
    931                                 allChildren.add(child);
    932                         }
    933                 }
    934                 else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    935                         {
    936                                 ASTNode child = parseIdentifier();
     936                                ASTNode child = parseVoidType();
    937937                                result.appendChild(child);
    938938                                allChildren.add(child);
     
    11121112        }
    11131113         
    1114         public ASTNode parseVoid() {
     1114        public ASTNode parseVoidType() {
    11151115                if( !(nowReading.isLextant(Lextant.VOID)) ) {
    1116                         return syntaxErrorNode("void² [VOID¹]");
    1117                 }
    1118        
    1119                 boolean allowCompression = true;
    1120                 ASTNode result = new VoidNode(nowReading);
     1116                        return syntaxErrorNode("voidType² [VOID¹]");
     1117                }
     1118       
     1119                boolean allowCompression = true;
     1120                ASTNode result = new VoidTypeNode(nowReading);
    11211121                result.setProductionTag(39);
    11221122                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
Note: See TracChangeset for help on using the changeset viewer.