Changeset 3166 for proto/pabloj


Ignore:
Timestamp:
May 21, 2013, 5:42:56 PM (6 years ago)
Author:
ksherdy
Message:

Minor grammar updates to handle terminators correctly. Updates to sample test files. Minor updates to temp pabloS type system classes.

Location:
proto/pabloj/branches/refactor-experimental
Files:
12 added
8 deleted
39 edited
2 copied
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloS.scatter

    r3161 r3166  
    4242        INT,
    4343//      STRING,
    44        
    4544        IF,
    4645        ELSE,
    4746        WHILE,
    4847        RETURN,
    49 
    5048        AND             "&",
    5149        OR              "|",
     
    9088  funcCall {} [funcCallRest],
    9189  // streamCall {} [streamCallRest],
    92   integerConstant{intValued;} [fieldWidthSpec],
     90  integerConstant{intValued;} [fieldWidthSpecifier],
    9391  primitiveType{} [intType voidType],
    9492  streamType{int fieldWidth = 1;} [],
     
    10199        // s t r e a m   s t r u c t   d e c l a r a t i o n s 
    102100        //
    103         structDecl                      ->  STRUCT structName structTypeBody ;
     101        structDecl                      ->  STRUCT structName structTypeBody TERMINATOR? ;
    104102        structTypeBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
    105103        structMember            ->      structMemberType structMemberName ;
     
    110108        // s t r e a m   f u n c t i o n   d e c l a r a t i o n s                                                     
    111109        //
    112         funcDef                 -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR?;                             
     110        funcDef                 -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;                           
    113111        returnType              #-> type ;     
    114112        parameterList   -> parameter (COMMA parameter)*;
     
    120118        // s t a t e m e n t s
    121119        //
    122         stmt                                    #->     funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl ;
    123 
     120        stmt                                    #->     localVarDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
     121        blockStmt                               ->      LCURLY stmt* RCURLY ;
     122        localVarDecl                    ->      type varName (ASSIGN^ expr) ? TERMINATOR;
     123        varName                                 #-> compoundIdentifier ;
    124124        funcCallOrAssignStmt    #-> expr (assignRest _promote_)? TERMINATOR ;
    125125        assignRest                              ->      assignOperator^! expr ;
     
    129129        whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
    130130        returnStmt                              ->      RETURN (expr)? TERMINATOR;
    131         blockStmt                               ->      LCURLY stmt* RCURLY ;
    132         localVarDecl                    ->      type varName (ASSIGN^ expr) ? ;
    133         varName                                 #-> compoundIdentifier ;
    134131
    135132        //
     
    152149        compoundIdentifier              #-> identifier (DOT^ identifier)*;
    153150        identifier                              -> IDENTIFIER ;
    154 
    155151    funcCallRest                        -> LROUND^ funcCallArgList RROUND ;
    156152        funcCallArgList                 -> (expr (COMMA expr)*) ? ;     
     
    163159        // t y p e s
    164160        //
    165         type                    #->     primitiveType   |
    166                                                         streamType              |
    167                                                         structType              ;
     161        type                            #->     primitiveType   |
     162                                                                streamType              |
     163                                                                structType              ;
    168164
    169         primitiveType   #-> ( intType | voidType ) ;
    170         intType                 -> INT    { @type = {{PrimitiveType.INTEGER}};  } ;
    171         voidType                -> VOID   { @type = {{PrimitiveType.VOID}}; } ;
     165        primitiveType           #-> ( intType | voidType ) ;
     166        intType                         -> INT    { @type = {{PrimitiveType.INTEGER}};  } ;
     167        voidType                        -> VOID   { @type = {{PrimitiveType.VOID}}; } ;
    172168
    173         streamType              ->      STREAM fieldWidthSpec! {        @fieldWidth = @:value;
    174                                                                                                         @type = {{ new StreamType(%?) }} , @fieldWidth ;
    175                                                                                        } ;
     169        streamType                      ->      STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
     170                                                                                                                        @type = {{ new StreamType(%?) }} , @fieldWidth ;
     171                                                                                                        } ;
    176172                                       
    177         fieldWidthSpec  #->  (LANGLE integerConstant RANGLE ) |
    178                                                  (epsilon {@value = 1;}) ;     
    179        
    180         structType              ->      STRUCT structName ;             
    181         structName              #->  identifier ;                               
     173        fieldWidthSpecifier     #->  (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;       
     174        structType                      ->      STRUCT structName ;             
     175        structName                      #->  identifier ;                               
    182176       
    183177        //      tupleType                               ->      tupleTypeSpecifier (LROUND tupleTypeBody RROUND)? ;
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/all/all.pablos

    r2984 r3166  
    1414function void Foo() {
    1515
    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                
    25 };function void BasicExpressions() {
    26 
    27         temp4 = temp;
    28         temp4 = temp1 | temp2;
    29         temp4 = temp1 ^ temp2;
    30         temp4 = temp1 & temp2;
    31         temp4 = temp1 ^ temp2 | temp3;
    32         temp4 = temp1 | temp2 ^ temp3;
    33         temp4 = temp1 & temp2 | temp3;
    34         temp4 = temp1 | temp2 & temp3;
    35         temp4 = temp1 & (temp2 | temp3);
    36         temp4 = (temp1 | temp2) & temp3;
    37 //      temp4 = ~temp;
    38        
    39 };
    40 
    41 function void Assignments() {
    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 
    57 function 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;
    65         s = 0;
    66         s &= 0;
    67         s |= 0;
    68 //      s ~= 0;
    69         s ^= 0;
    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 };
    85 function void While() {
    86                        
    87         var stream<1> cursor = 1;
    88        
    89         while (cursor) {
    90           cursor = pablo.Advance(cursor);
    91         };
    92 }
    93 function void While() {
    94        
    95         var stream<1> cursor;
    96        
    97         while (cursor) {
    98                 cursor = pablo.Advance(cursor);
    99                 cursor = cursor &~ terminator;
    100         };
    101 }
    102 function 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 }
    113 function void localDecl() {
    114 
    115 var struct BasisBits {
    116 stream<1> b1;
    117 stream<1> b2;
    118 stream<1> b3;
    119 stream<1> b4;
    120 } A;
    121 
    122 };function void localDecl() {
    123         var stream<1> A;
    124         var stream<1> A=0;
    125 }function void localDecl() {
    126 
    127         var struct BasisBits {
    128         stream<1> b1;
    129         stream<1> b2;
    130         stream<1> b3;
    131         stream<1> b4;
    132         } A;
    133 
    134 } function void Assignments() {
    135         var stream<1> s = 4;
    136 }function void Function() {             
    137         if(cursor) {
    138 
    139         }
    140 }
    141 function void Function() {     
    142        
    143         if(cursor & a) {
    144                 if(cursor & b) {
    145                
    146                 } else {
    147                
    148                 }
    149 
    150         } else {
    151 
    152         }
    153        
    154 }
    155 function void Function() {     
    156        
    157         if(cursor & a) {
    158                 if(cursor & b) {
    159                
    160                 }
    161         }
    162        
    163 }
    164 function void Function() {     
    165        
    166         if(cursor & a) {
    167 
    168         } else {
    169 
    170         }
    171        
    172 }
     16}struct B
     17{
     18        stream<1> a;
     19        stream<1> a;
     20        stream<1> a;
     21        stream<1> a;
     22};
     23
     24function struct B Foo() { }
     25struct bb {
     26        stream<1> a;
     27
     28};
     29
     30/*
     31function stream<1> Function(stream<1> a, stream<1> b, stream<1> c) {
     32
     33
     34};
     35*/
     36function struct Lex ClassifyBytes(struct BasisBit basis) {};
    17337// PabloS version of parabix2_pablo.py generated with py2pabloS.py
    17438
    17539struct Basis_bits{
    176     stream<1> bit_0;
    177     stream<1> bit_1;
    178     stream<1> bit_2;
    179     stream<1> bit_3;
    180     stream<1> bit_4;
    181     stream<1> bit_5;
    182     stream<1> bit_6;
    183     stream<1> bit_7;
     40    stream bit_0;
     41    stream bit_1;
     42    stream bit_2;
     43    stream bit_3;
     44    stream bit_4;
     45    stream bit_5;
     46    stream bit_6;
     47    stream bit_7;
    18448};
    18549
    18650struct U8{
    187     stream<1> unibyte;
    188     stream<1> prefix;
    189     stream<1> prefix2;
    190     stream<1> prefix3;
    191     stream<1> prefix4;
    192     stream<1> suffix;
    193     stream<1> badprefix;
    194     stream<1> xE0;
    195     stream<1> xED;
    196     stream<1> xF0;
    197     stream<1> xF4;
    198     stream<1> xA0_xBF;
    199     stream<1> x80_x9F;
    200     stream<1> x90_xBF;
    201     stream<1> x80_x8F;
    202     stream<1> xEF;
    203     stream<1> xBF;
    204     stream<1> xBE;
    205     stream<1> scope22;
    206     stream<1> scope32;
    207     stream<1> scope33;
    208     stream<1> scope42;
    209     stream<1> scope43;
    210     stream<1> scope44;
    211     stream<1> xE0_scope;
    212     stream<1> xED_scope;
    213     stream<1> xF0_scope;
    214     stream<1> xF4_scope;
    215     stream<1> xEF_scope;
     51    stream unibyte;
     52    stream prefix;
     53    stream prefix2;
     54    stream prefix3;
     55    stream prefix4;
     56    stream suffix;
     57    stream badprefix;
     58    stream xE0;
     59    stream xED;
     60    stream xF0;
     61    stream xF4;
     62    stream xA0_xBF;
     63    stream x80_x9F;
     64    stream x90_xBF;
     65    stream x80_x8F;
     66    stream xEF;
     67    stream xBF;
     68    stream xBE;
     69    stream scope22;
     70    stream scope32;
     71    stream scope33;
     72    stream scope42;
     73    stream scope43;
     74    stream scope44;
     75    stream xE0_scope;
     76    stream xED_scope;
     77    stream xF0_scope;
     78    stream xF4_scope;
     79    stream xEF_scope;
    21680};
    21781
    21882struct Lex{
    219     stream<1> CR;
    220     stream<1> LF;
    221     stream<1> HT;
    222     stream<1> SP;
    223     stream<1> CRLF;
    224     stream<1> RefStart;
    225     stream<1> Semicolon;
    226     stream<1> Colon;
    227     stream<1> LAngle;
    228     stream<1> RAngle;
    229     stream<1> LBracket;
    230     stream<1> RBracket;
    231     stream<1> Exclam;
    232     stream<1> QMark;
    233     stream<1> Hyphen;
    234     stream<1> Equals;
    235     stream<1> SQuote;
    236     stream<1> DQuote;
    237     stream<1> Slash;
    238     stream<1> Hash;
    239     stream<1> x;
    240     stream<1> ASCII_name_start;
    241     stream<1> ASCII_name_char;
    242     stream<1> NameScan;
    243     stream<1> Digit;
    244     stream<1> Hex;
    245     stream<1> WS;
     83    stream CR;
     84    stream LF;
     85    stream HT;
     86    stream SP;
     87    stream CRLF;
     88    stream RefStart;
     89    stream Semicolon;
     90    stream Colon;
     91    stream LAngle;
     92    stream RAngle;
     93    stream LBracket;
     94    stream RBracket;
     95    stream Exclam;
     96    stream QMark;
     97    stream Hyphen;
     98    stream Equals;
     99    stream SQuote;
     100    stream DQuote;
     101    stream Slash;
     102    stream Hash;
     103    stream x;
     104    stream ASCII_name_start;
     105    stream ASCII_name_char;
     106    stream NameScan;
     107    stream Digit;
     108    stream Hex;
     109    stream WS;
    246110};
    247111
    248112struct Marker{
    249     stream<1> LAngle_scope;
    250     stream<1> Ref_opener;
    251     stream<1> CD_closer;
     113    stream LAngle_scope;
     114    stream Ref_opener;
     115    stream CD_closer;
    252116};
    253117
    254118struct CtCDPI_Callouts{
    255     stream<1> Ct_starts;
    256     stream<1> Ct_ends;
    257     stream<1> CD_starts;
    258     stream<1> CD_ends;
    259     stream<1> PI_starts;
    260     stream<1> PI_name_starts;
    261     stream<1> PI_name_ends;
    262     stream<1> PI_ends;
     119    stream Ct_starts;
     120    stream Ct_ends;
     121    stream CD_starts;
     122    stream CD_ends;
     123    stream PI_starts;
     124    stream PI_name_starts;
     125    stream PI_name_ends;
     126    stream PI_ends;
    263127};
    264128
    265129struct Ref_Callouts{
    266     stream<1> GenRef_starts;
    267     stream<1> GenRef_ends;
    268     stream<1> DecRef_starts;
    269     stream<1> DecRef_ends;
    270     stream<1> HexRef_starts;
    271     stream<1> HexRef_ends;
     130    stream GenRef_starts;
     131    stream GenRef_ends;
     132    stream DecRef_starts;
     133    stream DecRef_ends;
     134    stream HexRef_starts;
     135    stream HexRef_ends;
    272136};
    273137
    274138struct Tag_Callouts{
    275     stream<1> ElemName_starts;
    276     stream<1> ElemName_ends;
    277     stream<1> AttName_starts;
    278     stream<1> AttName_ends;
    279     stream<1> AttVal_starts;
    280     stream<1> AttVal_ends;
    281     stream<1> AttVal_spans;
    282     stream<1> EmptyTag_marks;
    283     stream<1> EndTag_marks;
     139    stream ElemName_starts;
     140    stream ElemName_ends;
     141    stream AttName_starts;
     142    stream AttName_ends;
     143    stream AttVal_starts;
     144    stream AttVal_ends;
     145    stream AttVal_spans;
     146    stream EmptyTag_marks;
     147    stream EndTag_marks;
    284148};
    285149
    286150struct Check_streams{
    287     stream<1> misc_mask;
    288     stream<1> non_ascii_name_starts;
    289     stream<1> non_ascii_names;
    290     stream<1> tag_marks;
    291     stream<1> name_follows;
    292     stream<1> att_refs;
     151    stream misc_mask;
     152    stream non_ascii_name_starts;
     153    stream non_ascii_names;
     154    stream tag_marks;
     155    stream name_follows;
     156    stream att_refs;
    293157};
    294158
    295159function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
    296     var stream<1> temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    297     var stream<1> temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
    298     var stream<1> temp3 = (temp2 & (~ temp1));
    299     var stream<1> temp4 = (basis_bits.bit_5 & (~ basis_bits.bit_4));
    300     var stream<1> temp5 = (basis_bits.bit_6 & (~ basis_bits.bit_7));
    301     var stream<1> temp6 = (temp4 & temp5);
     160    stream temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
     161    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     162    stream temp3 = (temp2 & (~ temp1));
     163    stream temp4 = (basis_bits.bit_5 & (~ basis_bits.bit_4));
     164    stream temp5 = (basis_bits.bit_6 & (~ basis_bits.bit_7));
     165    stream temp6 = (temp4 & temp5);
    302166    lex.RefStart = (temp3 & temp6);
    303     var stream<1> temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
    304     var stream<1> temp8 = (temp7 & (~ temp1));
    305     var stream<1> temp9 = (basis_bits.bit_4 & (~ basis_bits.bit_5));
    306     var stream<1> temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
    307     var stream<1> temp11 = (temp9 & temp10);
     167    stream temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
     168    stream temp8 = (temp7 & (~ temp1));
     169    stream temp9 = (basis_bits.bit_4 & (~ basis_bits.bit_5));
     170    stream temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
     171    stream temp11 = (temp9 & temp10);
    308172    lex.Semicolon = (temp8 & temp11);
    309     var stream<1> temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
    310     var stream<1> temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
    311     var stream<1> temp14 = (temp12 & (~ temp13));
     173    stream temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
     174    stream temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
     175    stream temp14 = (temp12 & (~ temp13));
    312176    lex.LAngle = (temp8 & temp14);
    313     var stream<1> temp15 = (temp12 & temp5);
     177    stream temp15 = (temp12 & temp5);
    314178    lex.RAngle = (temp8 & temp15);
    315     var stream<1> temp16 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    316     var stream<1> temp17 = (basis_bits.bit_3 & (~ basis_bits.bit_2));
    317     var stream<1> temp18 = (temp16 & temp17);
     179    stream temp16 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
     180    stream temp17 = (basis_bits.bit_3 & (~ basis_bits.bit_2));
     181    stream temp18 = (temp16 & temp17);
    318182    lex.LBracket = (temp18 & temp11);
    319     var stream<1> temp19 = (basis_bits.bit_7 & (~ basis_bits.bit_6));
    320     var stream<1> temp20 = (temp12 & temp19);
     183    stream temp19 = (basis_bits.bit_7 & (~ basis_bits.bit_6));
     184    stream temp20 = (temp12 & temp19);
    321185    lex.RBracket = (temp18 & temp20);
    322     var stream<1> temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
    323     var stream<1> temp22 = (temp19 & (~ temp21));
     186    stream temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
     187    stream temp22 = (temp19 & (~ temp21));
    324188    lex.Exclam = (temp3 & temp22);
    325     var stream<1> temp23 = (temp12 & temp10);
     189    stream temp23 = (temp12 & temp10);
    326190    lex.QMark = (temp8 & temp23);
    327191    lex.Hyphen = (temp3 & temp20);
    328192    lex.Equals = (temp8 & temp20);
    329     var stream<1> temp24 = (temp4 & temp10);
     193    stream temp24 = (temp4 & temp10);
    330194    lex.SQuote = (temp3 & temp24);
    331     var stream<1> temp25 = (temp5 & (~ temp21));
     195    stream temp25 = (temp5 & (~ temp21));
    332196    lex.DQuote = (temp3 & temp25);
    333197    lex.Slash = (temp3 & temp23);
    334     var stream<1> temp26 = (temp10 & (~ temp21));
     198    stream temp26 = (temp10 & (~ temp21));
    335199    lex.Hash = (temp3 & temp26);
    336     var stream<1> temp27 = (temp16 & temp7);
    337     var stream<1> temp28 = (temp9 & (~ temp13));
     200    stream temp27 = (temp16 & temp7);
     201    stream temp28 = (temp9 & (~ temp13));
    338202    lex.x = (temp27 & temp28);
    339     var stream<1> temp29 = (temp9 & temp5);
     203    stream temp29 = (temp9 & temp5);
    340204    lex.Colon = (temp8 & temp29);
    341     var stream<1> temp30 = (temp18 & temp23);
    342     var stream<1> temp31 = (temp30 | lex.Colon);
    343     var stream<1> temp32 = (temp16 & (~ basis_bits.bit_2));
    344     var stream<1> temp33 = (basis_bits.bit_5 | temp10);
    345     var stream<1> temp34 = (basis_bits.bit_4 & temp33);
    346     var stream<1> temp35 = (~ temp34);
    347     var stream<1> temp36 = (temp21 | temp13);
    348     var stream<1> temp37 = ((basis_bits.bit_3 & temp35) | ((~ basis_bits.bit_3) & temp36));
    349     var stream<1> temp38 = (temp32 & temp37);
    350     var stream<1> temp39 = (temp31 | temp38);
    351     var stream<1> temp40 = (temp16 & basis_bits.bit_2);
    352     var stream<1> temp41 = (temp40 & temp37);
     205    stream temp30 = (temp18 & temp23);
     206    stream temp31 = (temp30 | lex.Colon);
     207    stream temp32 = (temp16 & (~ basis_bits.bit_2));
     208    stream temp33 = (basis_bits.bit_5 | temp10);
     209    stream temp34 = (basis_bits.bit_4 & temp33);
     210    stream temp35 = (~ temp34);
     211    stream temp36 = (temp21 | temp13);
     212    stream temp37 = ((basis_bits.bit_3 & temp35) | ((~ basis_bits.bit_3) & temp36));
     213    stream temp38 = (temp32 & temp37);
     214    stream temp39 = (temp31 | temp38);
     215    stream temp40 = (temp16 & basis_bits.bit_2);
     216    stream temp41 = (temp40 & temp37);
    353217    lex.ASCII_name_start = (temp39 | temp41);
    354     var stream<1> temp42 = (temp30 | lex.Hyphen);
    355     var stream<1> temp43 = (temp3 & temp15);
    356     var stream<1> temp44 = (temp42 | temp43);
    357     var stream<1> temp45 = (temp8 & (~ temp34));
    358     var stream<1> temp46 = (temp44 | temp45);
    359     var stream<1> temp47 = (temp46 | temp38);
     218    stream temp42 = (temp30 | lex.Hyphen);
     219    stream temp43 = (temp3 & temp15);
     220    stream temp44 = (temp42 | temp43);
     221    stream temp45 = (temp8 & (~ temp34));
     222    stream temp46 = (temp44 | temp45);
     223    stream temp47 = (temp46 | temp38);
    360224    lex.ASCII_name_char = (temp47 | temp41);
    361225    lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
    362     var stream<1> temp48 = (temp1 | basis_bits.bit_2);
    363     var stream<1> x00_x1F = (~ temp48);
    364     var stream<1> temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
    365     var stream<1> temp50 = (temp1 | temp49);
     226    stream temp48 = (temp1 | basis_bits.bit_2);
     227    stream x00_x1F = (~ temp48);
     228    stream temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
     229    stream temp50 = (temp1 | temp49);
    366230    lex.CR = (temp20 & (~ temp50));
    367231    lex.LF = (temp29 & (~ temp50));
    368     var stream<1> temp51 = (temp9 & temp19);
     232    stream temp51 = (temp9 & temp19);
    369233    lex.HT = (temp51 & (~ temp50));
    370234    lex.SP = (temp3 & (~ temp36));
    371     var stream<1> temp52 = (temp20 | temp29);
    372     var stream<1> temp53 = (temp52 | temp51);
    373     var stream<1> temp54 = (temp53 & (~ temp50));
     235    stream temp52 = (temp20 | temp29);
     236    stream temp53 = (temp52 | temp51);
     237    stream temp54 = (temp53 & (~ temp50));
    374238    lex.WS = (temp54 | lex.SP);
    375     var stream<1> temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
    376     var stream<1> temp56 = (basis_bits.bit_4 & temp55);
     239    stream temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
     240    stream temp56 = (basis_bits.bit_4 & temp55);
    377241    lex.Digit = (temp8 & (~ temp56));
    378     var stream<1> temp57 = (temp16 & (~ temp49));
    379     var stream<1> temp58 = (temp57 & (~ basis_bits.bit_4));
    380     var stream<1> temp59 = (~ temp10);
    381     var stream<1> temp60 = ((basis_bits.bit_5 & temp59) | ((~ basis_bits.bit_5) & temp13));
    382     var stream<1> temp61 = (temp58 & temp60);
    383     var stream<1> temp62 = (lex.Digit | temp61);
    384     var stream<1> temp63 = (temp16 & temp2);
    385     var stream<1> temp64 = (temp63 & (~ basis_bits.bit_4));
    386     var stream<1> temp65 = (temp64 & temp60);
     242    stream temp57 = (temp16 & (~ temp49));
     243    stream temp58 = (temp57 & (~ basis_bits.bit_4));
     244    stream temp59 = (~ temp10);
     245    stream temp60 = ((basis_bits.bit_5 & temp59) | ((~ basis_bits.bit_5) & temp13));
     246    stream temp61 = (temp58 & temp60);
     247    stream temp62 = (lex.Digit | temp61);
     248    stream temp63 = (temp16 & temp2);
     249    stream temp64 = (temp63 & (~ basis_bits.bit_4));
     250    stream temp65 = (temp64 & temp60);
    387251    lex.Hex = (temp62 | temp65);
    388     var stream<1> lex_error = (x00_x1F & (~ lex.WS));
     252    stream lex_error = (x00_x1F & (~ lex.WS));
    389253    pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    390254    u8.unibyte = (~ basis_bits.bit_0);
    391255    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);
     256    stream u8_error = pablo.Mask(1,0);
     257    stream u8_FFFE_FFFF = pablo.Mask(1,0);
     258    stream u8anyscope = pablo.Mask(1,0);
    395259    if (basis_bits.bit_0) {
    396260        u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     
    399263        u8.prefix4 = (u8.prefix & temp7);
    400264        u8.suffix = (basis_bits.bit_0 & (~ basis_bits.bit_1));
    401         var stream<1> temp66 = (u8.prefix & (~ temp49));
    402         var stream<1> temp67 = (temp21 | basis_bits.bit_6);
    403         var stream<1> temp68 = (temp66 & (~ temp67));
    404         var stream<1> temp69 = (basis_bits.bit_5 & temp13);
    405         var stream<1> temp70 = (basis_bits.bit_4 | temp69);
    406         var stream<1> temp71 = (u8.prefix4 & temp70);
     265        stream temp66 = (u8.prefix & (~ temp49));
     266        stream temp67 = (temp21 | basis_bits.bit_6);
     267        stream temp68 = (temp66 & (~ temp67));
     268        stream temp69 = (basis_bits.bit_5 & temp13);
     269        stream temp70 = (basis_bits.bit_4 | temp69);
     270        stream temp71 = (u8.prefix4 & temp70);
    407271        u8.badprefix = (temp68 | temp71);
    408272        u8_error = u8.badprefix;
     
    410274        u8anyscope = u8.scope22;
    411275        if ((u8.prefix3 | u8.prefix4)) {
    412             var stream<1> xE0 = (u8.prefix3 & (~ temp36));
    413             var stream<1> xED = (u8.prefix3 & temp20);
    414             var stream<1> xF0 = (u8.prefix4 & (~ temp36));
    415             var stream<1> temp72 = (temp4 & (~ temp13));
    416             var stream<1> xF4 = (u8.prefix4 & temp72);
     276            stream xE0 = (u8.prefix3 & (~ temp36));
     277            stream xED = (u8.prefix3 & temp20);
     278            stream xF0 = (u8.prefix4 & (~ temp36));
     279            stream temp72 = (temp4 & (~ temp13));
     280            stream xF4 = (u8.prefix4 & temp72);
    417281            u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
    418282            u8.x80_x9F = (u8.suffix & (~ basis_bits.bit_2));
    419283            u8.x90_xBF = (u8.suffix & temp49);
    420284            u8.x80_x8F = (u8.suffix & (~ temp49));
    421             var stream<1> xEF = (u8.prefix3 & temp23);
    422             var stream<1> temp73 = (u8.suffix & temp7);
     285            stream xEF = (u8.prefix3 & temp23);
     286            stream temp73 = (u8.suffix & temp7);
    423287            u8.xBF = (temp73 & temp23);
    424288            u8.xBE = (temp73 & temp15);
     
    428292            u8.scope43 = pablo.Advance(u8.scope42);
    429293            u8.scope44 = pablo.Advance(u8.scope43);
    430             var stream<1> E0_F0_scope = pablo.Advance((xE0 | xF0));
    431             var stream<1> ED_F4_scope = pablo.Advance((xED | xF4));
     294            stream E0_F0_scope = pablo.Advance((xE0 | xF0));
     295            stream ED_F4_scope = pablo.Advance((xED | xF4));
    432296            u8.xE0_scope = (u8.scope32 & E0_F0_scope);
    433297            u8.xED_scope = (u8.scope32 & ED_F4_scope);
     
    435299            u8.xF4_scope = (u8.scope42 & ED_F4_scope);
    436300            u8.xEF_scope = pablo.Advance(xEF);
    437             var stream<1> u8lastscope = ((u8.scope22 | u8.scope33) | u8.scope44);
     301            stream u8lastscope = ((u8.scope22 | u8.scope33) | u8.scope44);
    438302            u8anyscope = (((u8lastscope | u8.scope32) | u8.scope42) | u8.scope43);
    439             var stream<1> u8error1 = (u8.xE0_scope & u8.x80_x9F);
    440             var stream<1> u8error2 = (u8.xED_scope & u8.xA0_xBF);
    441             var stream<1> u8error3 = (u8.xF0_scope & u8.x80_x8F);
    442             var stream<1> u8error4 = (u8.xF4_scope & u8.x90_xBF);
     303            stream u8error1 = (u8.xE0_scope & u8.x80_x9F);
     304            stream u8error2 = (u8.xED_scope & u8.xA0_xBF);
     305            stream u8error3 = (u8.xF0_scope & u8.x80_x8F);
     306            stream u8error4 = (u8.xF4_scope & u8.x90_xBF);
    443307            u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
    444             var stream<1> EF_BF_pending = pablo.Advance((u8.xEF_scope & u8.xBF));
     308            stream EF_BF_pending = pablo.Advance((u8.xEF_scope & u8.xBF));
    445309            u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
    446310        }
    447         var stream<1> u8mismatch = (u8anyscope ^ u8.suffix);
     311        stream u8mismatch = (u8anyscope ^ u8.suffix);
    448312        pablo.assert_0(((u8_error | u8mismatch) | u8_FFFE_FFFF), "UTF-8 error found");
    449313    }
     
    459323    ctCDPI_Callouts.PI_name_ends = pablo.Mask(1,0);
    460324    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);
    464     var stream<1> v = (lex.LAngle | lex.Hyphen);
    465     var stream<1> w = (lex.Hyphen | lex.QMark);
    466     var stream<1> v1 = pablo.Advance(v, 1);
    467     var stream<1> w1 = pablo.Advance(w, 1);
    468     var stream<1> LAngle_scope = (v1 & (~ w1));
    469     var stream<1> PI_opener = (LAngle_scope & lex.QMark);
    470     var stream<1> CtCD_opener = (LAngle_scope & lex.Exclam);
    471     var stream<1> CtCDPI_opener = (PI_opener | CtCD_opener);
    472     var stream<1> CD_closer = pablo.Mask(1,0);
    473     var stream<1> DoubleHyphen = ((v1 & w1) & lex.Hyphen);
     325    stream CtCDPI_starts = pablo.Mask(1,0);
     326    stream CtCDPI_ends = pablo.Mask(1,0);
     327    stream ctCDPI_mask = pablo.Mask(1,0);
     328    stream v = (lex.LAngle | lex.Hyphen);
     329    stream w = (lex.Hyphen | lex.QMark);
     330    stream v1 = pablo.Advance(v, 1);
     331    stream w1 = pablo.Advance(w, 1);
     332    stream LAngle_scope = (v1 & (~ w1));
     333    stream PI_opener = (LAngle_scope & lex.QMark);
     334    stream CtCD_opener = (LAngle_scope & lex.Exclam);
     335    stream CtCDPI_opener = (PI_opener | CtCD_opener);
     336    stream CD_closer = pablo.Mask(1,0);
     337    stream DoubleHyphen = ((v1 & w1) & lex.Hyphen);
    474338    if (lex.RBracket) {
    475         var stream<1> DoubleRBracket = (pablo.Advance(lex.RBracket) & lex.RBracket);
     339        stream DoubleRBracket = (pablo.Advance(lex.RBracket) & lex.RBracket);
    476340        CD_closer = (pablo.Advance(DoubleRBracket) & lex.RAngle);
    477341    }
    478     var stream<1> PI_closer = ((w1 & (~ v1)) & lex.RAngle);
    479     var stream<1> CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     342    stream PI_closer = ((w1 & (~ v1)) & lex.RAngle);
     343    stream CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
    480344    while (CtCDPI_Cursor) {
    481345        CtCDPI_starts |= CtCDPI_Cursor;
    482         var stream<1> PI_Cursor = (CtCDPI_Cursor & PI_opener);
    483         var stream<1> CD_Ct_Cursor = pablo.Advance((CtCDPI_Cursor & (~ PI_Cursor)));
    484         var stream<1> CD_Cursor = (CD_Ct_Cursor & lex.LBracket);
    485         var stream<1> Ct_Cursor = (CD_Ct_Cursor & lex.Hyphen);
     346        stream PI_Cursor = (CtCDPI_Cursor & PI_opener);
     347        stream CD_Ct_Cursor = pablo.Advance((CtCDPI_Cursor & (~ PI_Cursor)));
     348        stream CD_Cursor = (CD_Ct_Cursor & lex.LBracket);
     349        stream Ct_Cursor = (CD_Ct_Cursor & lex.Hyphen);
    486350        if (PI_Cursor) {
    487351            ctCDPI_Callouts.PI_starts |= PI_Cursor;
    488352            PI_Cursor = pablo.Advance(PI_Cursor);
    489353            ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
    490             var stream<1> PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
    491             var stream<1> PI_error = (PI_Cursor & PI_name_end);
    492             var stream<1> PI_noWS = (PI_name_end & (~ lex.WS));
     354            stream PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
     355            stream PI_error = (PI_Cursor & PI_name_end);
     356            stream PI_noWS = (PI_name_end & (~ lex.WS));
    493357            PI_error |= ((PI_noWS & (~ lex.QMark)) | (pablo.Advance(PI_noWS) & (~ PI_closer)));
    494358            pablo.assert_0(PI_error, "Error in PI syntax");
     
    507371            ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
    508372            Ct_Cursor = pablo.Advance(Ct_Cursor);
    509             var stream<1> Ct_error = (Ct_Cursor & (~ lex.Hyphen));
     373            stream Ct_error = (Ct_Cursor & (~ lex.Hyphen));
    510374            Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
    511375            Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
     
    526390
    527391function 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);
    530     var stream<1> DQuoteDelim = (lex.DQuote | lex.LAngle);
    531     var stream<1> SQuoteDelim = (lex.SQuote | lex.LAngle);
    532     var stream<1> AttListDelim = (lex.Slash | lex.RAngle);
     392    stream EqExpected = pablo.Mask(1,0);
     393    stream AttListEnd = pablo.Mask(1,0);
     394    stream DQuoteDelim = (lex.DQuote | lex.LAngle);
     395    stream SQuoteDelim = (lex.SQuote | lex.LAngle);
     396    stream AttListDelim = (lex.Slash | lex.RAngle);
    533397    tag_Callouts.ElemName_starts = (marker.LAngle_scope & (~ lex.Slash));
    534398    tag_Callouts.EndTag_marks = (marker.LAngle_scope & lex.Slash);
    535399    tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    536     var stream<1> ParseError = (tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends);
     400    stream ParseError = (tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends);
    537401    tag_Callouts.AttName_starts = pablo.Mask(1,0);
    538402    tag_Callouts.AttName_ends = pablo.Mask(1,0);
     
    540404    tag_Callouts.AttVal_ends = pablo.Mask(1,0);
    541405    if ((tag_Callouts.ElemName_ends & lex.WS)) {
    542         var stream<1> AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
     406        stream AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    543407        AttListEnd = (AfterWS & AttListDelim);
    544         var stream<1> AttNameStart = (AfterWS & (~ AttListDelim));
     408        stream AttNameStart = (AfterWS & (~ AttListDelim));
    545409        while (AttNameStart) {
    546410            ParseError |= (AttNameStart & (~ lex.NameScan));
    547411            tag_Callouts.AttName_starts |= AttNameStart;
    548             var stream<1> AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
     412            stream AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
    549413            tag_Callouts.AttName_ends |= AttNameFollow;
    550414            if ((AttNameFollow & lex.WS)) {
     
    555419            }
    556420            ParseError |= (EqExpected & (~ lex.Equals));
    557             var stream<1> AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
     421            stream AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
    558422            tag_Callouts.AttVal_starts |= AttValPos;
    559             var stream<1> DQuoteAttVal = (AttValPos & lex.DQuote);
    560             var stream<1> SQuoteAttVal = (AttValPos & lex.SQuote);
    561             var stream<1> DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
    562             var stream<1> SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
    563             var stream<1> AttValEnd = (DQuoteAttEnd | SQuoteAttEnd);
     423            stream DQuoteAttVal = (AttValPos & lex.DQuote);
     424            stream SQuoteAttVal = (AttValPos & lex.SQuote);
     425            stream DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
     426            stream SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
     427            stream AttValEnd = (DQuoteAttEnd | SQuoteAttEnd);
    564428            ParseError |= ((AttValPos | AttValEnd) & (~ (lex.DQuote | lex.SQuote)));
    565             var stream<1> AttValFollow = pablo.Advance(AttValEnd);
     429            stream AttValFollow = pablo.Advance(AttValEnd);
    566430            tag_Callouts.AttVal_ends |= AttValFollow;
    567431            if ((AttValFollow & lex.WS)) {
     
    581445        ParseError |= (tag_Callouts.ElemName_ends & (~ AttListDelim));
    582446    }
    583     var stream<1> STagEnds = (AttListEnd & lex.RAngle);
     447    stream STagEnds = (AttListEnd & lex.RAngle);
    584448    tag_Callouts.EmptyTag_marks = pablo.Advance((AttListEnd & lex.Slash));
    585449    ParseError |= (tag_Callouts.EmptyTag_marks & (~ lex.RAngle));
    586     var stream<1> EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
     450    stream EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
    587451    if ((EndTagEnds & lex.WS)) {
    588452        EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
     
    600464    ref_Callouts.HexRef_starts = pablo.Mask(1,0);
    601465    ref_Callouts.HexRef_ends = pablo.Mask(1,0);
    602     var stream<1> ref_error = pablo.Mask(1,0);
     466    stream ref_error = pablo.Mask(1,0);
    603467    if (marker.Ref_opener) {
    604         var stream<1> Ref_scope = pablo.Advance(marker.Ref_opener);
    605         var stream<1> NumRef2 = (Ref_scope & lex.Hash);
     468        stream Ref_scope = pablo.Advance(marker.Ref_opener);
     469        stream NumRef2 = (Ref_scope & lex.Hash);
    606470        ref_Callouts.GenRef_starts = (Ref_scope & (~ lex.Hash));
    607         var stream<1> NumRef3 = pablo.Advance(NumRef2);
    608         var stream<1> HexRef3 = (NumRef3 & lex.x);
     471        stream NumRef3 = pablo.Advance(NumRef2);
     472        stream HexRef3 = (NumRef3 & lex.x);
    609473        ref_Callouts.DecRef_starts = (NumRef3 & (~ lex.x));
    610474        ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
     
    612476        ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
    613477        ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
    614         var stream<1> ref_error1 = (ref_Callouts.DecRef_starts & (~ lex.Digit));
    615         var stream<1> ref_error2 = (ref_Callouts.HexRef_starts & (~ lex.Hex));
    616         var stream<1> ref_ends = ((ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends) | ref_Callouts.HexRef_ends);
    617         var stream<1> ref_error3 = (ref_ends & (~ lex.Semicolon));
     478        stream ref_error1 = (ref_Callouts.DecRef_starts & (~ lex.Digit));
     479        stream ref_error2 = (ref_Callouts.HexRef_starts & (~ lex.Hex));
     480        stream ref_ends = ((ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends) | ref_Callouts.HexRef_ends);
     481        stream ref_error3 = (ref_ends & (~ lex.Semicolon));
    618482        pablo.assert_0(((ref_error1 | ref_error2) | ref_error3), "Reference error found");
    619483    }
     
    621485
    622486function void Validate_xml_names(struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Lex lex, struct U8 u8, struct Check_streams check_streams) {
    623     var stream<1> PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    624     var stream<1> GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
    625     var stream<1> ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    626     var stream<1> AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
    627     var stream<1> qname_stream = (ElemNames | AttNames);
    628     var stream<1> ncname_stream = (PI_names | GenRefs);
    629     var stream<1> name_stream = (qname_stream | ncname_stream);
    630     var stream<1> name_start = (name_stream & (~ pablo.Advance(name_stream)));
    631     var stream<1> name_cursor = (name_stream & (~ pablo.Advance(name_stream)));
    632     var stream<1> void_prefix_err = (name_cursor & lex.Colon);
    633     var stream<1> namespace_sep = (pablo.ScanThru(name_cursor, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
    634     var stream<1> local_part_start = pablo.Advance(namespace_sep);
    635     var stream<1> local_part_err = (local_part_start & (~ lex.NameScan));
    636     var stream<1> colon2_err = (pablo.ScanThru(local_part_start, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
    637     var stream<1> ncname_err = (ncname_stream & lex.Colon);
     487    stream PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
     488    stream GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
     489    stream ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
     490    stream AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
     491    stream qname_stream = (ElemNames | AttNames);
     492    stream ncname_stream = (PI_names | GenRefs);
     493    stream name_stream = (qname_stream | ncname_stream);
     494    stream name_start = (name_stream & (~ pablo.Advance(name_stream)));
     495    stream name_cursor = (name_stream & (~ pablo.Advance(name_stream)));
     496    stream void_prefix_err = (name_cursor & lex.Colon);
     497    stream namespace_sep = (pablo.ScanThru(name_cursor, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
     498    stream local_part_start = pablo.Advance(namespace_sep);
     499    stream local_part_err = (local_part_start & (~ lex.NameScan));
     500    stream colon2_err = (pablo.ScanThru(local_part_start, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
     501    stream ncname_err = (ncname_stream & lex.Colon);
    638502    pablo.assert_0((((void_prefix_err | local_part_err) | colon2_err) | ncname_err), "name syntax error");
    639503    check_streams.non_ascii_name_starts = (name_start & (~ lex.ASCII_name_start));
     
    647511    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
    648512}
    649 struct bb {
     513function void While() {
     514                       
     515        stream<1> cursor = 1;
     516       
     517        while (cursor) {
     518          cursor = pablo.Advance(cursor);
     519        }
     520}
     521function void Function() {     
     522        stream<1> cursor1;
     523       
     524        while (cursor1) {
     525                stream<1> cursor2;
     526                while(cursor2) {
     527                        cursor = pablo.Advance(cursor);
     528                        // cursor = cursor &~ terminator;
     529                }
     530        }
     531}
     532function void While() {
     533       
     534        stream<1> cursor;
     535       
     536        while (cursor) {
     537                cursor = pablo.Advance(cursor);
     538                cursor = cursor &~ terminator;
     539        }
     540}
     541function void Function(struct TagCallouts tagCallouts, struct Lex lex) {       
     542
     543        stream<1> starts_accum = 0;
     544        stream<1> ends_accum = 0;       
     545        stream<1> cursor = pablo.ScanToFirst(lex.opener);
     546       
     547        while (cursor) {
     548                starts_accum |= cursor;
     549                cursor = pablo.ScanTo(cursor, lex.marker &~ cursor);
     550                ends_accum |= cursor;
     551                cursor = pablo.ScanTo(cursor, (lex.marker | lex.terminator) &~ cursor);
     552                cursor = cursor & lex.marker;
     553        }
     554};
     555function void Function() {     
     556       
     557        stream cursor;
     558       
     559        if(cursor & a) {
     560
     561        } else {
     562
     563        }
     564       
     565}
     566function void Function() {     
     567       
     568        stream cursor;
     569       
     570        if(cursor & a) {
     571                if(cursor & b) {
     572               
     573                } else {
     574               
     575                }
     576
     577        } else {
     578
     579        }
     580       
     581}
     582function void Function() {     
     583       
     584        stream cursor;
     585       
     586        if(cursor & a) {
     587                if(cursor & b) {
     588               
     589                }
     590        }
     591       
     592}
     593function void Function() {             
     594        stream cursor;
     595        if(cursor) {
     596
     597        }
     598}
     599function void Assignments() {
     600        stream<1> s;
     601        s = 0;
     602};function void Assignments() {
     603        stream<1> s;
    650604        stream<1> a;
    651 
    652 };
    653 
    654 /*
    655 function stream<1> Function(stream<1> a, stream<1> b, stream<1> c) {
    656 
    657 
    658 };
    659 */
    660 struct B
    661 {
    662         stream<1> a;
    663         stream<1> a;
    664         stream<1> a;
    665         stream<1> a;
    666 };
    667 
    668 function struct B Foo() { }
    669 function struct Lex ClassifyBytes(struct BasisBit basis) {};
     605        stream<1> b;
     606        stream<1> c;
     607        //s |= 0;
     608        //s = a | b | c;
     609        s |= a;
     610        s |= a | b;
     611        s |= a | b | c;
     612        s |= a | b | c | d;
     613        // s = s | a | b | c;
     614};function void StreamStructs() {
     615
     616        // records
     617        temp4 = temp1.temp2;
     618        temp4 = temp1.temp2.temp3;
     619       
     620        temp1.temp2 = temp4;
     621        temp1.temp2.temp3 = temp4;
     622               
     623};function void AssignmentExpressions() {       
     624        temp4 = temp;
     625        temp4 &= temp1 | temp2;
     626        temp4 |= temp1 ^ temp2;
     627        temp4 ^= temp1 & temp2;
     628};function void BasicExpressions() {
     629
     630        temp4 = temp;
     631        temp4 = temp1 | temp2;
     632        temp4 = temp1 ^ temp2;
     633        temp4 = temp1 & temp2;
     634        temp4 = temp1 ^ temp2 | temp3;
     635        temp4 = temp1 | temp2 ^ temp3;
     636        temp4 = temp1 & temp2 | temp3;
     637        temp4 = temp1 | temp2 & temp3;
     638        temp4 = temp1 & (temp2 | temp3);
     639        temp4 = (temp1 | temp2) & temp3;
     640//      temp4 = ~temp;
     641       
     642};
     643
     644function struct A FunctionExpressions() {
     645         stream<1> a = b.Advance();
     646};
     647function void localDecl() {
     648
     649        struct BasisBits A;
     650
     651} function void localDecl() {
     652
     653        struct BasisBits A;
     654        struct BasisBits A;
     655        struct BasisBits A;
     656       
     657
     658};function void localDecl() {
     659        stream<1> A;
     660        stream B;
     661}function void Assignments() {
     662        stream a;
     663        stream<1> s = a;
     664}
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/statements/localDecl/localDecl1.pablos

    r3160 r3166  
    11function void localDecl() {
    22
    3         struct BasisBits {
    4                 stream<1> b1;
    5                 stream<1> b2;
    6                 stream<1> b3;
    7                 stream<1> b4;
    8         } A;
     3        struct BasisBits A;
    94
    105}
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/statements/localDecl/localDecl2.pablos

    r3160 r3166  
    11function void localDecl() {
    2 
    3         var struct BasisBits {
    4                 stream<1> b1;
    5                 stream<1> b2;
    6                 stream<1> b3;
    7                 stream<1> b4;
    8         } A;
    9 
     2        struct BasisBits A;
     3        struct BasisBits B;
     4        struct BasisBits C;
    105};
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/statements/localDecl/localDecl3.pablos

    r3160 r3166  
    11function void localDecl() {
    22        stream<1> A;
    3         stream<1> A=0;
     3        stream B;
    44}
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/statements/localDecl/localDecl4.pablos

    r3160 r3166  
    11function void Assignments() {
    2         stream<1> s = 4;
     2        stream a;
     3        stream<1> s = a;
    34}
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/statements/while/while1.pablos

    r3160 r3166  
    55        while (cursor) {
    66          cursor = pablo.Advance(cursor);
    7         };
     7        }
    88}
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/statements/while/while2.pablos

    r3160 r3166  
    66                cursor = pablo.Advance(cursor);
    77                cursor = cursor &~ terminator;
    8         };
     8        }
    99}
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/test.pablos

    r3115 r3166  
    1 function void Test() {
    2         a.b();
    3 };
     1struct BasisBits {
     2        stream<1> b1;
     3        stream<1> b2;
     4        stream<1> b3;
     5        stream<1> b4;
     6};
     7struct BasisBits {
     8        stream<1> b1;
     9        stream<1> b2;
     10        stream<1> b3;
     11        stream<1> b4;
     12};
     13
     14function void Foo() {
     15
     16}struct B
     17{
     18        stream<1> a;
     19        stream<1> a;
     20        stream<1> a;
     21        stream<1> a;
     22};
     23
     24function struct B Foo() { }
     25struct bb {
     26        stream<1> a;
     27
     28};
     29
     30/*
     31function stream<1> Function(stream<1> a, stream<1> b, stream<1> c) {
     32
     33
     34};
     35*/
     36function struct Lex ClassifyBytes(struct BasisBit basis) {};
     37// PabloS version of parabix2_pablo.py generated with py2pabloS.py
     38
     39struct Basis_bits{
     40    stream bit_0;
     41    stream bit_1;
     42    stream bit_2;
     43    stream bit_3;
     44    stream bit_4;
     45    stream bit_5;
     46    stream bit_6;
     47    stream bit_7;
     48};
     49
     50struct U8{
     51    stream unibyte;
     52    stream prefix;
     53    stream prefix2;
     54    stream prefix3;
     55    stream prefix4;
     56    stream suffix;
     57    stream badprefix;
     58    stream xE0;
     59    stream xED;
     60    stream xF0;
     61    stream xF4;
     62    stream xA0_xBF;
     63    stream x80_x9F;
     64    stream x90_xBF;
     65    stream x80_x8F;
     66    stream xEF;
     67    stream xBF;
     68    stream xBE;
     69    stream scope22;
     70    stream scope32;
     71    stream scope33;
     72    stream scope42;
     73    stream scope43;
     74    stream scope44;
     75    stream xE0_scope;
     76    stream xED_scope;
     77    stream xF0_scope;
     78    stream xF4_scope;
     79    stream xEF_scope;
     80};
     81
     82struct Lex{
     83    stream CR;
     84    stream LF;
     85    stream HT;
     86    stream SP;
     87    stream CRLF;
     88    stream RefStart;
     89    stream Semicolon;
     90    stream Colon;
     91    stream LAngle;
     92    stream RAngle;
     93    stream LBracket;
     94    stream RBracket;
     95    stream Exclam;
     96    stream QMark;
     97    stream Hyphen;
     98    stream Equals;
     99    stream SQuote;
     100    stream DQuote;
     101    stream Slash;
     102    stream Hash;
     103    stream x;
     104    stream ASCII_name_start;
     105    stream ASCII_name_char;
     106    stream NameScan;
     107    stream Digit;
     108    stream Hex;
     109    stream WS;
     110};
     111
     112struct Marker{
     113    stream LAngle_scope;
     114    stream Ref_opener;
     115    stream CD_closer;
     116};
     117
     118struct CtCDPI_Callouts{
     119    stream Ct_starts;
     120    stream Ct_ends;
     121    stream CD_starts;
     122    stream CD_ends;
     123    stream PI_starts;
     124    stream PI_name_starts;
     125    stream PI_name_ends;
     126    stream PI_ends;
     127};
     128
     129struct Ref_Callouts{
     130    stream GenRef_starts;
     131    stream GenRef_ends;
     132    stream DecRef_starts;
     133    stream DecRef_ends;
     134    stream HexRef_starts;
     135    stream HexRef_ends;
     136};
     137
     138struct Tag_Callouts{
     139    stream ElemName_starts;
     140    stream ElemName_ends;
     141    stream AttName_starts;
     142    stream AttName_ends;
     143    stream AttVal_starts;
     144    stream AttVal_ends;
     145    stream AttVal_spans;
     146    stream EmptyTag_marks;
     147    stream EndTag_marks;
     148};
     149
     150struct Check_streams{
     151    stream misc_mask;
     152    stream non_ascii_name_starts;
     153    stream non_ascii_names;
     154    stream tag_marks;
     155    stream name_follows;
     156    stream att_refs;
     157};
     158
     159function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
     160    stream temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
     161    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     162    stream temp3 = (temp2 & (~ temp1));
     163    stream temp4 = (basis_bits.bit_5 & (~ basis_bits.bit_4));
     164    stream temp5 = (basis_bits.bit_6 & (~ basis_bits.bit_7));
     165    stream temp6 = (temp4 & temp5);
     166    lex.RefStart = (temp3 & temp6);
     167    stream temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
     168    stream temp8 = (temp7 & (~ temp1));
     169    stream temp9 = (basis_bits.bit_4 & (~ basis_bits.bit_5));
     170    stream temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
     171    stream temp11 = (temp9 & temp10);
     172    lex.Semicolon = (temp8 & temp11);
     173    stream temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
     174    stream temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
     175    stream temp14 = (temp12 & (~ temp13));
     176    lex.LAngle = (temp8 & temp14);
     177    stream temp15 = (temp12 & temp5);
     178    lex.RAngle = (temp8 & temp15);
     179    stream temp16 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
     180    stream temp17 = (basis_bits.bit_3 & (~ basis_bits.bit_2));
     181    stream temp18 = (temp16 & temp17);
     182    lex.LBracket = (temp18 & temp11);
     183    stream temp19 = (basis_bits.bit_7 & (~ basis_bits.bit_6));
     184    stream temp20 = (temp12 & temp19);
     185    lex.RBracket = (temp18 & temp20);
     186    stream temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
     187    stream temp22 = (temp19 & (~ temp21));
     188    lex.Exclam = (temp3 & temp22);
     189    stream temp23 = (temp12 & temp10);
     190    lex.QMark = (temp8 & temp23);
     191    lex.Hyphen = (temp3 & temp20);
     192    lex.Equals = (temp8 & temp20);
     193    stream temp24 = (temp4 & temp10);
     194    lex.SQuote = (temp3 & temp24);
     195    stream temp25 = (temp5 & (~ temp21));
     196    lex.DQuote = (temp3 & temp25);
     197    lex.Slash = (temp3 & temp23);
     198    stream temp26 = (temp10 & (~ temp21));
     199    lex.Hash = (temp3 & temp26);
     200    stream temp27 = (temp16 & temp7);
     201    stream temp28 = (temp9 & (~ temp13));
     202    lex.x = (temp27 & temp28);
     203    stream temp29 = (temp9 & temp5);
     204    lex.Colon = (temp8 & temp29);
     205    stream temp30 = (temp18 & temp23);
     206    stream temp31 = (temp30 | lex.Colon);
     207    stream temp32 = (temp16 & (~ basis_bits.bit_2));
     208    stream temp33 = (basis_bits.bit_5 | temp10);
     209    stream temp34 = (basis_bits.bit_4 & temp33);
     210    stream temp35 = (~ temp34);
     211    stream temp36 = (temp21 | temp13);
     212    stream temp37 = ((basis_bits.bit_3 & temp35) | ((~ basis_bits.bit_3) & temp36));
     213    stream temp38 = (temp32 & temp37);
     214    stream temp39 = (temp31 | temp38);
     215    stream temp40 = (temp16 & basis_bits.bit_2);
     216    stream temp41 = (temp40 & temp37);
     217    lex.ASCII_name_start = (temp39 | temp41);
     218    stream temp42 = (temp30 | lex.Hyphen);
     219    stream temp43 = (temp3 & temp15);
     220    stream temp44 = (temp42 | temp43);
     221    stream temp45 = (temp8 & (~ temp34));
     222    stream temp46 = (temp44 | temp45);
     223    stream temp47 = (temp46 | temp38);
     224    lex.ASCII_name_char = (temp47 | temp41);
     225    lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
     226    stream temp48 = (temp1 | basis_bits.bit_2);
     227    stream x00_x1F = (~ temp48);
     228    stream temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
     229    stream temp50 = (temp1 | temp49);
     230    lex.CR = (temp20 & (~ temp50));
     231    lex.LF = (temp29 & (~ temp50));
     232    stream temp51 = (temp9 & temp19);
     233    lex.HT = (temp51 & (~ temp50));
     234    lex.SP = (temp3 & (~ temp36));
     235    stream temp52 = (temp20 | temp29);
     236    stream temp53 = (temp52 | temp51);
     237    stream temp54 = (temp53 & (~ temp50));
     238    lex.WS = (temp54 | lex.SP);
     239    stream temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
     240    stream temp56 = (basis_bits.bit_4 & temp55);
     241    lex.Digit = (temp8 & (~ temp56));
     242    stream temp57 = (temp16 & (~ temp49));
     243    stream temp58 = (temp57 & (~ basis_bits.bit_4));
     244    stream temp59 = (~ temp10);
     245    stream temp60 = ((basis_bits.bit_5 & temp59) | ((~ basis_bits.bit_5) & temp13));
     246    stream temp61 = (temp58 & temp60);
     247    stream temp62 = (lex.Digit | temp61);
     248    stream temp63 = (temp16 & temp2);
     249    stream temp64 = (temp63 & (~ basis_bits.bit_4));
     250    stream temp65 = (temp64 & temp60);
     251    lex.Hex = (temp62 | temp65);
     252    stream lex_error = (x00_x1F & (~ lex.WS));
     253    pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
     254    u8.unibyte = (~ basis_bits.bit_0);
     255    u8.suffix = pablo.Mask(1,0);
     256    stream u8_error = pablo.Mask(1,0);
     257    stream u8_FFFE_FFFF = pablo.Mask(1,0);
     258    stream u8anyscope = pablo.Mask(1,0);
     259    if (basis_bits.bit_0) {
     260        u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     261        u8.prefix2 = (u8.prefix & (~ basis_bits.bit_2));
     262        u8.prefix3 = (u8.prefix & temp2);
     263        u8.prefix4 = (u8.prefix & temp7);
     264        u8.suffix = (basis_bits.bit_0 & (~ basis_bits.bit_1));
     265        stream temp66 = (u8.prefix & (~ temp49));
     266        stream temp67 = (temp21 | basis_bits.bit_6);
     267        stream temp68 = (temp66 & (~ temp67));
     268        stream temp69 = (basis_bits.bit_5 & temp13);
     269        stream temp70 = (basis_bits.bit_4 | temp69);
     270        stream temp71 = (u8.prefix4 & temp70);
     271        u8.badprefix = (temp68 | temp71);
     272        u8_error = u8.badprefix;
     273        u8.scope22 = pablo.Advance(u8.prefix2);
     274        u8anyscope = u8.scope22;
     275        if ((u8.prefix3 | u8.prefix4)) {
     276            stream xE0 = (u8.prefix3 & (~ temp36));
     277            stream xED = (u8.prefix3 & temp20);
     278            stream xF0 = (u8.prefix4 & (~ temp36));
     279            stream temp72 = (temp4 & (~ temp13));
     280            stream xF4 = (u8.prefix4 & temp72);
     281            u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
     282            u8.x80_x9F = (u8.suffix & (~ basis_bits.bit_2));
     283            u8.x90_xBF = (u8.suffix & temp49);
     284            u8.x80_x8F = (u8.suffix & (~ temp49));
     285            stream xEF = (u8.prefix3 & temp23);
     286            stream temp73 = (u8.suffix & temp7);
     287            u8.xBF = (temp73 & temp23);
     288            u8.xBE = (temp73 & temp15);
     289            u8.scope32 = pablo.Advance(u8.prefix3);
     290            u8.scope33 = pablo.Advance(u8.scope32);
     291            u8.scope42 = pablo.Advance(u8.prefix4);
     292            u8.scope43 = pablo.Advance(u8.scope42);
     293            u8.scope44 = pablo.Advance(u8.scope43);
     294            stream E0_F0_scope = pablo.Advance((xE0 | xF0));
     295            stream ED_F4_scope = pablo.Advance((xED | xF4));
     296            u8.xE0_scope = (u8.scope32 & E0_F0_scope);
     297            u8.xED_scope = (u8.scope32 & ED_F4_scope);
     298            u8.xF0_scope = (u8.scope42 & E0_F0_scope);
     299            u8.xF4_scope = (u8.scope42 & ED_F4_scope);
     300            u8.xEF_scope = pablo.Advance(xEF);
     301            stream u8lastscope = ((u8.scope22 | u8.scope33) | u8.scope44);
     302            u8anyscope = (((u8lastscope | u8.scope32) | u8.scope42) | u8.scope43);
     303            stream u8error1 = (u8.xE0_scope & u8.x80_x9F);
     304            stream u8error2 = (u8.xED_scope & u8.xA0_xBF);
     305            stream u8error3 = (u8.xF0_scope & u8.x80_x8F);
     306            stream u8error4 = (u8.xF4_scope & u8.x90_xBF);
     307            u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
     308            stream EF_BF_pending = pablo.Advance((u8.xEF_scope & u8.xBF));
     309            u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
     310        }
     311        stream u8mismatch = (u8anyscope ^ u8.suffix);
     312        pablo.assert_0(((u8_error | u8mismatch) | u8_FFFE_FFFF), "UTF-8 error found");
     313    }
     314}
     315
     316function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
     317    ctCDPI_Callouts.Ct_starts = pablo.Mask(1,0);
     318    ctCDPI_Callouts.Ct_ends = pablo.Mask(1,0);
     319    ctCDPI_Callouts.CD_starts = pablo.Mask(1,0);
     320    ctCDPI_Callouts.CD_ends = pablo.Mask(1,0);
     321    ctCDPI_Callouts.PI_starts = pablo.Mask(1,0);
     322    ctCDPI_Callouts.PI_name_starts = pablo.Mask(1,0);
     323    ctCDPI_Callouts.PI_name_ends = pablo.Mask(1,0);
     324    ctCDPI_Callouts.PI_ends = pablo.Mask(1,0);
     325    stream CtCDPI_starts = pablo.Mask(1,0);
     326    stream CtCDPI_ends = pablo.Mask(1,0);
     327    stream ctCDPI_mask = pablo.Mask(1,0);
     328    stream v = (lex.LAngle | lex.Hyphen);
     329    stream w = (lex.Hyphen | lex.QMark);
     330    stream v1 = pablo.Advance(v, 1);
     331    stream w1 = pablo.Advance(w, 1);
     332    stream LAngle_scope = (v1 & (~ w1));
     333    stream PI_opener = (LAngle_scope & lex.QMark);
     334    stream CtCD_opener = (LAngle_scope & lex.Exclam);
     335    stream CtCDPI_opener = (PI_opener | CtCD_opener);
     336    stream CD_closer = pablo.Mask(1,0);
     337    stream DoubleHyphen = ((v1 & w1) & lex.Hyphen);
     338    if (lex.RBracket) {
     339        stream DoubleRBracket = (pablo.Advance(lex.RBracket) & lex.RBracket);
     340        CD_closer = (pablo.Advance(DoubleRBracket) & lex.RAngle);
     341    }
     342    stream PI_closer = ((w1 & (~ v1)) & lex.RAngle);
     343    stream CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     344    while (CtCDPI_Cursor) {
     345        CtCDPI_starts |= CtCDPI_Cursor;
     346        stream PI_Cursor = (CtCDPI_Cursor & PI_opener);
     347        stream CD_Ct_Cursor = pablo.Advance((CtCDPI_Cursor & (~ PI_Cursor)));
     348        stream CD_Cursor = (CD_Ct_Cursor & lex.LBracket);
     349        stream Ct_Cursor = (CD_Ct_Cursor & lex.Hyphen);
     350        if (PI_Cursor) {
     351            ctCDPI_Callouts.PI_starts |= PI_Cursor;
     352            PI_Cursor = pablo.Advance(PI_Cursor);
     353            ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
     354            stream PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
     355            stream PI_error = (PI_Cursor & PI_name_end);
     356            stream PI_noWS = (PI_name_end & (~ lex.WS));
     357            PI_error |= ((PI_noWS & (~ lex.QMark)) | (pablo.Advance(PI_noWS) & (~ PI_closer)));
     358            pablo.assert_0(PI_error, "Error in PI syntax");
     359            ctCDPI_Callouts.PI_name_ends |= PI_name_end;
     360            PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
     361            ctCDPI_Callouts.PI_ends |= PI_Cursor;
     362            CtCDPI_ends |= PI_Cursor;
     363        }
     364        if (CD_Cursor) {
     365            ctCDPI_Callouts.CD_starts |= CD_Cursor;
     366            CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
     367            ctCDPI_Callouts.CD_ends |= CD_Cursor;
     368            CtCDPI_ends |= CD_Cursor;
     369        }
     370        if (Ct_Cursor) {
     371            ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
     372            Ct_Cursor = pablo.Advance(Ct_Cursor);
     373            stream Ct_error = (Ct_Cursor & (~ lex.Hyphen));
     374            Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
     375            Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
     376            pablo.assert_0((Ct_error | (Ct_Cursor & (~ lex.RAngle))), "Error in comment syntax");
     377            ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
     378            CtCDPI_ends |= Ct_Cursor;
     379        }
     380        CtCDPI_Cursor = ((PI_Cursor | CD_Cursor) | Ct_Cursor);
     381        ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
     382        pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
     383        CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener);
     384    }
     385    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);
     386    marker.LAngle_scope = (LAngle_scope & (~ ctCDPI_mask));
     387    marker.Ref_opener = (lex.RefStart & (~ ctCDPI_mask));
     388    marker.CD_closer = (CD_closer & (~ ctCDPI_mask));
     389}
     390
     391function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
     392    stream EqExpected = pablo.Mask(1,0);
     393    stream AttListEnd = pablo.Mask(1,0);
     394    stream DQuoteDelim = (lex.DQuote | lex.LAngle);
     395    stream SQuoteDelim = (lex.SQuote | lex.LAngle);
     396    stream AttListDelim = (lex.Slash | lex.RAngle);
     397    tag_Callouts.ElemName_starts = (marker.LAngle_scope & (~ lex.Slash));
     398    tag_Callouts.EndTag_marks = (marker.LAngle_scope & lex.Slash);
     399    tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
     400    stream ParseError = (tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends);
     401    tag_Callouts.AttName_starts = pablo.Mask(1,0);
     402    tag_Callouts.AttName_ends = pablo.Mask(1,0);
     403    tag_Callouts.AttVal_starts = pablo.Mask(1,0);
     404    tag_Callouts.AttVal_ends = pablo.Mask(1,0);
     405    if ((tag_Callouts.ElemName_ends & lex.WS)) {
     406        stream AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
     407        AttListEnd = (AfterWS & AttListDelim);
     408        stream AttNameStart = (AfterWS & (~ AttListDelim));
     409        while (AttNameStart) {
     410            ParseError |= (AttNameStart & (~ lex.NameScan));
     411            tag_Callouts.AttName_starts |= AttNameStart;
     412            stream AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
     413            tag_Callouts.AttName_ends |= AttNameFollow;
     414            if ((AttNameFollow & lex.WS)) {
     415                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
     416            }
     417            else {
     418                EqExpected = AttNameFollow;
     419            }
     420            ParseError |= (EqExpected & (~ lex.Equals));
     421            stream AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
     422            tag_Callouts.AttVal_starts |= AttValPos;
     423            stream DQuoteAttVal = (AttValPos & lex.DQuote);
     424            stream SQuoteAttVal = (AttValPos & lex.SQuote);
     425            stream DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
     426            stream SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
     427            stream AttValEnd = (DQuoteAttEnd | SQuoteAttEnd);
     428            ParseError |= ((AttValPos | AttValEnd) & (~ (lex.DQuote | lex.SQuote)));
     429            stream AttValFollow = pablo.Advance(AttValEnd);
     430            tag_Callouts.AttVal_ends |= AttValFollow;
     431            if ((AttValFollow & lex.WS)) {
     432                AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
     433                AttListEnd |= (AfterWS & AttListDelim);
     434                AttNameStart = (AfterWS & (~ AttListDelim));
     435            }
     436            else {
     437                AttListEnd |= (AttValFollow & AttListDelim);
     438                AttNameStart = (AttValFollow & (~ AttListDelim));
     439            }
     440            ParseError |= (AttValFollow & AttNameStart);
     441        }
     442    }
     443    else {
     444        AttListEnd = (tag_Callouts.ElemName_ends & AttListDelim);
     445        ParseError |= (tag_Callouts.ElemName_ends & (~ AttListDelim));
     446    }
     447    stream STagEnds = (AttListEnd & lex.RAngle);
     448    tag_Callouts.EmptyTag_marks = pablo.Advance((AttListEnd & lex.Slash));
     449    ParseError |= (tag_Callouts.EmptyTag_marks & (~ lex.RAngle));
     450    stream EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
     451    if ((EndTagEnds & lex.WS)) {
     452        EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
     453    }
     454    ParseError |= (EndTagEnds & (~ lex.RAngle));
     455    pablo.assert_0(ParseError, "Tag parsing error found");
     456    tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
     457}
     458
     459function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
     460    ref_Callouts.GenRef_starts = pablo.Mask(1,0);
     461    ref_Callouts.GenRef_ends = pablo.Mask(1,0);
     462    ref_Callouts.DecRef_starts = pablo.Mask(1,0);
     463    ref_Callouts.DecRef_ends = pablo.Mask(1,0);
     464    ref_Callouts.HexRef_starts = pablo.Mask(1,0);
     465    ref_Callouts.HexRef_ends = pablo.Mask(1,0);
     466    stream ref_error = pablo.Mask(1,0);
     467    if (marker.Ref_opener) {
     468        stream Ref_scope = pablo.Advance(marker.Ref_opener);
     469        stream NumRef2 = (Ref_scope & lex.Hash);
     470        ref_Callouts.GenRef_starts = (Ref_scope & (~ lex.Hash));
     471        stream NumRef3 = pablo.Advance(NumRef2);
     472        stream HexRef3 = (NumRef3 & lex.x);
     473        ref_Callouts.DecRef_starts = (NumRef3 & (~ lex.x));
     474        ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
     475        ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan);
     476        ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
     477        ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
     478        stream ref_error1 = (ref_Callouts.DecRef_starts & (~ lex.Digit));
     479        stream ref_error2 = (ref_Callouts.HexRef_starts & (~ lex.Hex));
     480        stream ref_ends = ((ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends) | ref_Callouts.HexRef_ends);
     481        stream ref_error3 = (ref_ends & (~ lex.Semicolon));
     482        pablo.assert_0(((ref_error1 | ref_error2) | ref_error3), "Reference error found");
     483    }
     484}
     485
     486function void Validate_xml_names(struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Lex lex, struct U8 u8, struct Check_streams check_streams) {
     487    stream PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
     488    stream GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
     489    stream ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
     490    stream AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
     491    stream qname_stream = (ElemNames | AttNames);
     492    stream ncname_stream = (PI_names | GenRefs);
     493    stream name_stream = (qname_stream | ncname_stream);
     494    stream name_start = (name_stream & (~ pablo.Advance(name_stream)));
     495    stream name_cursor = (name_stream & (~ pablo.Advance(name_stream)));
     496    stream void_prefix_err = (name_cursor & lex.Colon);
     497    stream namespace_sep = (pablo.ScanThru(name_cursor, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
     498    stream local_part_start = pablo.Advance(namespace_sep);
     499    stream local_part_err = (local_part_start & (~ lex.NameScan));
     500    stream colon2_err = (pablo.ScanThru(local_part_start, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
     501    stream ncname_err = (ncname_stream & lex.Colon);
     502    pablo.assert_0((((void_prefix_err | local_part_err) | colon2_err) | ncname_err), "name syntax error");
     503    check_streams.non_ascii_name_starts = (name_start & (~ lex.ASCII_name_start));
     504    check_streams.non_ascii_names = (((name_stream & (~ name_start)) & (~ lex.ASCII_name_char)) & (~ u8.suffix));
     505}
     506
     507function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
     508    pablo.assert_0((marker.CD_closer & (~ tag_Callouts.AttVal_spans)), "Error: ]]> in text");
     509    check_streams.tag_marks = (((tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts) | tag_Callouts.EndTag_marks) | tag_Callouts.AttName_starts);
     510    check_streams.name_follows = (tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends);
     511    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
     512}
     513function void While() {
     514                       
     515        stream<1> cursor = 1;
     516       
     517        while (cursor) {
     518          cursor = pablo.Advance(cursor);
     519        }
     520}
     521function void Function() {     
     522        stream<1> cursor1;
     523       
     524        while (cursor1) {
     525                stream<1> cursor2;
     526                while(cursor2) {
     527                        cursor = pablo.Advance(cursor);
     528                        // cursor = cursor &~ terminator;
     529                }
     530        }
     531}
     532function void While() {
     533       
     534        stream<1> cursor;
     535       
     536        while (cursor) {
     537                cursor = pablo.Advance(cursor);
     538                cursor = cursor &~ terminator;
     539        }
     540}
     541function void Function(struct TagCallouts tagCallouts, struct Lex lex) {       
     542
     543        stream<1> starts_accum = 0;
     544        stream<1> ends_accum = 0;       
     545        stream<1> cursor = pablo.ScanToFirst(lex.opener);
     546       
     547        while (cursor) {
     548                starts_accum |= cursor;
     549                cursor = pablo.ScanTo(cursor, lex.marker &~ cursor);
     550                ends_accum |= cursor;
     551                cursor = pablo.ScanTo(cursor, (lex.marker | lex.terminator) &~ cursor);
     552                cursor = cursor & lex.marker;
     553        }
     554};
     555function void Function() {     
     556       
     557        stream cursor;
     558       
     559        if(cursor & a) {
     560
     561        } else {
     562
     563        }
     564       
     565}
     566function void Function() {     
     567       
     568        stream cursor;
     569       
     570        if(cursor & a) {
     571                if(cursor & b) {
     572               
     573                } else {
     574               
     575                }
     576
     577        } else {
     578
     579        }
     580       
     581}
     582function void Function() {     
     583       
     584        stream cursor;
     585       
     586        if(cursor & a) {
     587                if(cursor & b) {
     588               
     589                }
     590        }
     591       
     592}
     593function void Function() {             
     594        stream cursor;
     595        if(cursor) {
     596
     597        }
     598}
     599function void Assignments() {
     600        stream<1> s;
     601        s = 0;
     602};function void Assignments() {
     603        stream<1> s;
     604        stream<1> a;
     605        stream<1> b;
     606        stream<1> c;
     607        //s |= 0;
     608        //s = a | b | c;
     609        s |= a;
     610        s |= a | b;
     611        s |= a | b | c;
     612        s |= a | b | c | d;
     613        // s = s | a | b | c;
     614};function void StreamStructs() {
     615
     616        // records
     617        temp4 = temp1.temp2;
     618        temp4 = temp1.temp2.temp3;
     619       
     620        temp1.temp2 = temp4;
     621        temp1.temp2.temp3 = temp4;
     622               
     623};function void AssignmentExpressions() {       
     624        temp4 = temp;
     625        temp4 &= temp1 | temp2;
     626        temp4 |= temp1 ^ temp2;
     627        temp4 ^= temp1 & temp2;
     628};function void BasicExpressions() {
     629
     630        temp4 = temp;
     631        temp4 = temp1 | temp2;
     632        temp4 = temp1 ^ temp2;
     633        temp4 = temp1 & temp2;
     634        temp4 = temp1 ^ temp2 | temp3;
     635        temp4 = temp1 | temp2 ^ temp3;
     636        temp4 = temp1 & temp2 | temp3;
     637        temp4 = temp1 | temp2 & temp3;
     638        temp4 = temp1 & (temp2 | temp3);
     639        temp4 = (temp1 | temp2) & temp3;
     640//      temp4 = ~temp;
     641       
     642};
     643
     644function struct A FunctionExpressions() {
     645         stream<1> a = b.Advance();
     646};
     647function void localDecl() {
     648
     649        struct BasisBits A;
     650
     651} function void localDecl() {
     652
     653        struct BasisBits A;
     654        struct BasisBits A;
     655        struct BasisBits A;
     656       
     657
     658};function void localDecl() {
     659        stream<1> A;
     660        stream B;
     661}function void Assignments() {
     662        stream a;
     663        stream<1> s = a;
     664}
  • proto/pabloj/branches/refactor-experimental/output/cpplang/pablo_definitions.hpp

    r3134 r3166  
    2929BitBlock EOF_mask = simd<1>::constant<1>();
    3030
     31
    3132// XMLWF application headers and definitions
    3233/*
     
    5758// namespace pablo
    5859// {
    59 struct Basis_bits
     60struct Test
    6061{
    61         BitBlock bit_0;
    62         BitBlock bit_1;
    63         BitBlock bit_2;
    64         BitBlock bit_3;
    65         BitBlock bit_4;
    66         BitBlock bit_5;
    67         BitBlock bit_6;
    68         BitBlock bit_7;
    69 };
    70  
    71 struct U8
    72 {
    73         BitBlock unibyte;
    74         BitBlock prefix;
    75         BitBlock prefix2;
    76         BitBlock prefix3;
    77         BitBlock prefix4;
    78         BitBlock suffix;
    79         BitBlock badprefix;
    80         BitBlock xE0;
    81         BitBlock xED;
    82         BitBlock xF0;
    83         BitBlock xF4;
    84         BitBlock xA0_xBF;
    85         BitBlock x80_x9F;
    86         BitBlock x90_xBF;
    87         BitBlock x80_x8F;
    88         BitBlock xEF;
    89         BitBlock xBF;
    90         BitBlock xBE;
    91         BitBlock scope22;
    92         BitBlock scope32;
    93         BitBlock scope33;
    94         BitBlock scope42;
    95         BitBlock scope43;
    96         BitBlock scope44;
    97         BitBlock xE0_scope;
    98         BitBlock xED_scope;
    99         BitBlock xF0_scope;
    100         BitBlock xF4_scope;
    101         BitBlock xEF_scope;
    102 };
    103  
    104 struct Lex
    105 {
    106         BitBlock CR;
    107         BitBlock LF;
    108         BitBlock HT;
    109         BitBlock SP;
    110         BitBlock CRLF;
    111         BitBlock RefStart;
    112         BitBlock Semicolon;
    113         BitBlock Colon;
    114         BitBlock LAngle;
    115         BitBlock RAngle;
    116         BitBlock LBracket;
    117         BitBlock RBracket;
    118         BitBlock Exclam;
    119         BitBlock QMark;
    120         BitBlock Hyphen;
    121         BitBlock Equals;
    122         BitBlock SQuote;
    123         BitBlock DQuote;
    124         BitBlock Slash;
    125         BitBlock Hash;
    126         BitBlock x;
    127         BitBlock ASCII_name_start;
    128         BitBlock ASCII_name_char;
    129         BitBlock NameScan;
    130         BitBlock Digit;
    131         BitBlock Hex;
    132         BitBlock WS;
    133 };
    134  
    135 struct Marker
    136 {
    137         BitBlock LAngle_scope;
    138         BitBlock Ref_opener;
    139         BitBlock CD_closer;
    140 };
    141  
    142 struct CtCDPI_Callouts
    143 {
    144         BitBlock Ct_starts;
    145         BitBlock Ct_ends;
    146         BitBlock CD_starts;
    147         BitBlock CD_ends;
    148         BitBlock PI_starts;
    149         BitBlock PI_name_starts;
    150         BitBlock PI_name_ends;
    151         BitBlock PI_ends;
    152 };
    153  
    154 struct Ref_Callouts
    155 {
    156         BitBlock GenRef_starts;
    157         BitBlock GenRef_ends;
    158         BitBlock DecRef_starts;
    159         BitBlock DecRef_ends;
    160         BitBlock HexRef_starts;
    161         BitBlock HexRef_ends;
    162 };
    163  
    164 struct Tag_Callouts
    165 {
    166         BitBlock ElemName_starts;
    167         BitBlock ElemName_ends;
    168         BitBlock AttName_starts;
    169         BitBlock AttName_ends;
    170         BitBlock AttVal_starts;
    171         BitBlock AttVal_ends;
    172         BitBlock AttVal_spans;
    173         BitBlock EmptyTag_marks;
    174         BitBlock EndTag_marks;
    175 };
    176  
    177 struct Check_streams
    178 {
    179         BitBlock misc_mask;
    180         BitBlock non_ascii_name_starts;
    181         BitBlock non_ascii_names;
    182         BitBlock tag_marks;
    183         BitBlock name_follows;
    184         BitBlock att_refs;
    185 };
    186  
    187 struct Classify_bytes_Validate_utf8
    188 {
    189         Classify_bytes_Validate_utf8()
     62        Test()
    19063        {
    19164               
    19265        }
    19366         
    194         IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8)
     67        IDISA_INLINE void do_block()
    19568        {
    196                 BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
    197                 BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
    198                 BitBlock temp3 = simd_andc(temp2, temp1);
    199                 BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
    200                 BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
    201                 BitBlock temp6 = simd_and(temp4, temp5);
    202                 lex.RefStart = simd_and(temp3, temp6);
    203                 BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
    204                 BitBlock temp8 = simd_andc(temp7, temp1);
    205                 BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
    206                 BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
    207                 BitBlock temp11 = simd_and(temp9, temp10);
    208                 lex.Semicolon = simd_and(temp8, temp11);
    209                 BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
    210                 BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
    211                 BitBlock temp14 = simd_andc(temp12, temp13);
    212                 lex.LAngle = simd_and(temp8, temp14);
    213                 BitBlock temp15 = simd_and(temp12, temp5);
    214                 lex.RAngle = simd_and(temp8, temp15);
    215                 BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
    216                 BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
    217                 BitBlock temp18 = simd_and(temp16, temp17);
    218                 lex.LBracket = simd_and(temp18, temp11);
    219                 BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
    220                 BitBlock temp20 = simd_and(temp12, temp19);
    221                 lex.RBracket = simd_and(temp18, temp20);
    222                 BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
    223                 BitBlock temp22 = simd_andc(temp19, temp21);
    224                 lex.Exclam = simd_and(temp3, temp22);
    225                 BitBlock temp23 = simd_and(temp12, temp10);
    226                 lex.QMark = simd_and(temp8, temp23);
    227                 lex.Hyphen = simd_and(temp3, temp20);
    228                 lex.Equals = simd_and(temp8, temp20);
    229                 BitBlock temp24 = simd_and(temp4, temp10);
    230                 lex.SQuote = simd_and(temp3, temp24);
    231                 BitBlock temp25 = simd_andc(temp5, temp21);
    232                 lex.DQuote = simd_and(temp3, temp25);
    233                 lex.Slash = simd_and(temp3, temp23);
    234                 BitBlock temp26 = simd_andc(temp10, temp21);
    235                 lex.Hash = simd_and(temp3, temp26);
    236                 BitBlock temp27 = simd_and(temp16, temp7);
    237                 BitBlock temp28 = simd_andc(temp9, temp13);
    238                 lex.x = simd_and(temp27, temp28);
    239                 BitBlock temp29 = simd_and(temp9, temp5);
    240                 lex.Colon = simd_and(temp8, temp29);
    241                 BitBlock temp30 = simd_and(temp18, temp23);
    242                 BitBlock temp31 = simd_or(temp30, lex.Colon);
    243                 BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
    244                 BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
    245                 BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
    246                 BitBlock temp35 = simd_not(temp34);
    247                 BitBlock temp36 = simd_or(temp21, temp13);
    248                 BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
    249                 BitBlock temp38 = simd_and(temp32, temp37);
    250                 BitBlock temp39 = simd_or(temp31, temp38);
    251                 BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
    252                 BitBlock temp41 = simd_and(temp40, temp37);
    253                 lex.ASCII_name_start = simd_or(temp39, temp41);
    254                 BitBlock temp42 = simd_or(temp30, lex.Hyphen);
    255                 BitBlock temp43 = simd_and(temp3, temp15);
    256                 BitBlock temp44 = simd_or(temp42, temp43);
    257                 BitBlock temp45 = simd_andc(temp8, temp34);
    258                 BitBlock temp46 = simd_or(temp44, temp45);
    259                 BitBlock temp47 = simd_or(temp46, temp38);
    260                 lex.ASCII_name_char = simd_or(temp47, temp41);
    261                 lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
    262                 BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
    263                 BitBlock x00_x1F = simd_not(temp48);
    264                 BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
    265                 BitBlock temp50 = simd_or(temp1, temp49);
    266                 lex.CR = simd_andc(temp20, temp50);
    267                 lex.LF = simd_andc(temp29, temp50);
    268                 BitBlock temp51 = simd_and(temp9, temp19);
    269                 lex.HT = simd_andc(temp51, temp50);
    270                 lex.SP = simd_andc(temp3, temp36);
    271                 BitBlock temp52 = simd_or(temp20, temp29);
    272                 BitBlock temp53 = simd_or(temp52, temp51);
    273                 BitBlock temp54 = simd_andc(temp53, temp50);
    274                 lex.WS = simd_or(temp54, lex.SP);
    275                 BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
    276                 BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
    277                 lex.Digit = simd_andc(temp8, temp56);
    278                 BitBlock temp57 = simd_andc(temp16, temp49);
    279                 BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
    280                 BitBlock temp59 = simd_not(temp10);
    281                 BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
    282                 BitBlock temp61 = simd_and(temp58, temp60);
    283                 BitBlock temp62 = simd_or(lex.Digit, temp61);
    284                 BitBlock temp63 = simd_and(temp16, temp2);
    285                 BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
    286                 BitBlock temp65 = simd_and(temp64, temp60);
    287                 lex.Hex = simd_or(temp62, temp65);
    288                 BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
    289                 if (bitblock::any(lex_error))
    290                 {
    291                         assert_0_error("Error: illegal character", lex_error);
    292                 }
    293                 u8.unibyte = simd_not(basis_bits.bit_0);
    294                 u8.suffix = simd<1>::constant<0>();
    295                 BitBlock u8_error = simd<1>::constant<0>();
    296                 BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
    297                 BitBlock u8anyscope = simd<1>::constant<0>();
    298                 if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
    299                 {
    300                         u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
    301                         u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
    302                         u8.prefix3 = simd_and(u8.prefix, temp2);
    303                         u8.prefix4 = simd_and(u8.prefix, temp7);
    304                         u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
    305                         BitBlock temp66 = simd_andc(u8.prefix, temp49);
    306                         BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
    307                         BitBlock temp68 = simd_andc(temp66, temp67);
    308                         BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
    309                         BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
    310                         BitBlock temp71 = simd_and(u8.prefix4, temp70);
    311                         u8.badprefix = simd_or(temp68, temp71);
    312                         u8_error = u8.badprefix;
    313                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
    314                         u8anyscope = u8.scope22;
    315                         if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
    316                         {
    317                                 BitBlock xE0 = simd_andc(u8.prefix3, temp36);
    318                                 BitBlock xED = simd_and(u8.prefix3, temp20);
    319                                 BitBlock xF0 = simd_andc(u8.prefix4, temp36);
    320                                 BitBlock temp72 = simd_andc(temp4, temp13);
    321                                 BitBlock xF4 = simd_and(u8.prefix4, temp72);
    322                                 u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
    323                                 u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
    324                                 u8.x90_xBF = simd_and(u8.suffix, temp49);
    325                                 u8.x80_x8F = simd_andc(u8.suffix, temp49);
    326                                 BitBlock xEF = simd_and(u8.prefix3, temp23);
    327                                 BitBlock temp73 = simd_and(u8.suffix, temp7);
    328                                 u8.xBF = simd_and(temp73, temp23);
    329                                 u8.xBE = simd_and(temp73, temp15);
    330                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
    331                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
    332                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
    333                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
    334                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
    335                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
    336                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
    337                                 u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    338                                 u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    339                                 u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    340                                 u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    341                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
    342                                 BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    343                                 u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    344                                 BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
    345                                 BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
    346                                 BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
    347                                 BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    348                                 u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    349                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
    350                                 u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    351                         }
    352                         else
    353                         {
    354                                 carry_set_0.CarryDequeueEnqueue(1, 9);
    355                         }
    356                         BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
    357                         if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF)))
    358                         {
    359                                 assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
    360                         }
    361                 }
    362                 else
    363                 {
    364                         carry_set_0.CarryDequeueEnqueue(0, 10);
    365                 }
    366                 carry_set_0.CarryAdjust(10);
     69                a.b();
    36770        }
    36871       
    369         void do_final_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8, BitBlock & EOF_mask)
     72        void do_final_block(BitBlock & EOF_mask)
    37073        {
    371                 BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
    372                 BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
    373                 BitBlock temp3 = simd_andc(temp2, temp1);
    374                 BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
    375                 BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
    376                 BitBlock temp6 = simd_and(temp4, temp5);
    377                 lex.RefStart = simd_and(temp3, temp6);
    378                 BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
    379                 BitBlock temp8 = simd_andc(temp7, temp1);
    380                 BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
    381                 BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
    382                 BitBlock temp11 = simd_and(temp9, temp10);
    383                 lex.Semicolon = simd_and(temp8, temp11);
    384                 BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
    385                 BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
    386                 BitBlock temp14 = simd_andc(temp12, temp13);
    387                 lex.LAngle = simd_and(temp8, temp14);
    388                 BitBlock temp15 = simd_and(temp12, temp5);
    389                 lex.RAngle = simd_and(temp8, temp15);
    390                 BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
    391                 BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
    392                 BitBlock temp18 = simd_and(temp16, temp17);
    393                 lex.LBracket = simd_and(temp18, temp11);
    394                 BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
    395                 BitBlock temp20 = simd_and(temp12, temp19);
    396                 lex.RBracket = simd_and(temp18, temp20);
    397                 BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
    398                 BitBlock temp22 = simd_andc(temp19, temp21);
    399                 lex.Exclam = simd_and(temp3, temp22);
    400                 BitBlock temp23 = simd_and(temp12, temp10);
    401                 lex.QMark = simd_and(temp8, temp23);
    402                 lex.Hyphen = simd_and(temp3, temp20);
    403                 lex.Equals = simd_and(temp8, temp20);
    404                 BitBlock temp24 = simd_and(temp4, temp10);
    405                 lex.SQuote = simd_and(temp3, temp24);
    406                 BitBlock temp25 = simd_andc(temp5, temp21);
    407                 lex.DQuote = simd_and(temp3, temp25);
    408                 lex.Slash = simd_and(temp3, temp23);
    409                 BitBlock temp26 = simd_andc(temp10, temp21);
    410                 lex.Hash = simd_and(temp3, temp26);
    411                 BitBlock temp27 = simd_and(temp16, temp7);
    412                 BitBlock temp28 = simd_andc(temp9, temp13);
    413                 lex.x = simd_and(temp27, temp28);
    414                 BitBlock temp29 = simd_and(temp9, temp5);
    415                 lex.Colon = simd_and(temp8, temp29);
    416                 BitBlock temp30 = simd_and(temp18, temp23);
    417                 BitBlock temp31 = simd_or(temp30, lex.Colon);
    418                 BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
    419                 BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
    420                 BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
    421                 BitBlock temp35 = simd_not(temp34);
    422                 BitBlock temp36 = simd_or(temp21, temp13);
    423                 BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
    424                 BitBlock temp38 = simd_and(temp32, temp37);
    425                 BitBlock temp39 = simd_or(temp31, temp38);
    426                 BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
    427                 BitBlock temp41 = simd_and(temp40, temp37);
    428                 lex.ASCII_name_start = simd_or(temp39, temp41);
    429                 BitBlock temp42 = simd_or(temp30, lex.Hyphen);
    430                 BitBlock temp43 = simd_and(temp3, temp15);
    431                 BitBlock temp44 = simd_or(temp42, temp43);
    432                 BitBlock temp45 = simd_andc(temp8, temp34);
    433                 BitBlock temp46 = simd_or(temp44, temp45);
    434                 BitBlock temp47 = simd_or(temp46, temp38);
    435                 lex.ASCII_name_char = simd_or(temp47, temp41);
    436                 lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
    437                 BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
    438                 BitBlock x00_x1F = simd_not(temp48);
    439                 BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
    440                 BitBlock temp50 = simd_or(temp1, temp49);
    441                 lex.CR = simd_andc(temp20, temp50);
    442                 lex.LF = simd_andc(temp29, temp50);
    443                 BitBlock temp51 = simd_and(temp9, temp19);
    444                 lex.HT = simd_andc(temp51, temp50);
    445                 lex.SP = simd_andc(temp3, temp36);
    446                 BitBlock temp52 = simd_or(temp20, temp29);
    447                 BitBlock temp53 = simd_or(temp52, temp51);
    448                 BitBlock temp54 = simd_andc(temp53, temp50);
    449                 lex.WS = simd_or(temp54, lex.SP);
    450                 BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
    451                 BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
    452                 lex.Digit = simd_andc(temp8, temp56);
    453                 BitBlock temp57 = simd_andc(temp16, temp49);
    454                 BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
    455                 BitBlock temp59 = simd_not(temp10);
    456                 BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
    457                 BitBlock temp61 = simd_and(temp58, temp60);
    458                 BitBlock temp62 = simd_or(lex.Digit, temp61);
    459                 BitBlock temp63 = simd_and(temp16, temp2);
    460                 BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
    461                 BitBlock temp65 = simd_and(temp64, temp60);
    462                 lex.Hex = simd_or(temp62, temp65);
    463                 BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
    464                 if (bitblock::any(simd_and(lex_error, EOF_mask)))
    465                 {
    466                         assert_0_error("Error: illegal character", simd_and(lex_error, EOF_mask));
    467                 }
    468                 u8.unibyte = simd_not(basis_bits.bit_0);
    469                 u8.suffix = simd<1>::constant<0>();
    470                 BitBlock u8_error = simd<1>::constant<0>();
    471                 BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
    472                 BitBlock u8anyscope = simd<1>::constant<0>();
    473                 if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
    474                 {
    475                         u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
    476                         u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
    477                         u8.prefix3 = simd_and(u8.prefix, temp2);
    478                         u8.prefix4 = simd_and(u8.prefix, temp7);
    479                         u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
    480                         BitBlock temp66 = simd_andc(u8.prefix, temp49);
    481                         BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
    482                         BitBlock temp68 = simd_andc(temp66, temp67);
    483                         BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
    484                         BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
    485                         BitBlock temp71 = simd_and(u8.prefix4, temp70);
    486                         u8.badprefix = simd_or(temp68, temp71);
    487                         u8_error = u8.badprefix;
    488                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
    489                         u8anyscope = u8.scope22;
    490                         if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
    491                         {
    492                                 BitBlock xE0 = simd_andc(u8.prefix3, temp36);
    493                                 BitBlock xED = simd_and(u8.prefix3, temp20);
    494                                 BitBlock xF0 = simd_andc(u8.prefix4, temp36);
    495                                 BitBlock temp72 = simd_andc(temp4, temp13);
    496                                 BitBlock xF4 = simd_and(u8.prefix4, temp72);
    497                                 u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
    498                                 u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
    499                                 u8.x90_xBF = simd_and(u8.suffix, temp49);
    500                                 u8.x80_x8F = simd_andc(u8.suffix, temp49);
    501                                 BitBlock xEF = simd_and(u8.prefix3, temp23);
    502                                 BitBlock temp73 = simd_and(u8.suffix, temp7);
    503                                 u8.xBF = simd_and(temp73, temp23);
    504                                 u8.xBE = simd_and(temp73, temp15);
    505                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
    506                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
    507                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
    508                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
    509                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
    510                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
    511                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
    512                                 u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    513                                 u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    514                                 u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    515                                 u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    516                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
    517                                 BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    518                                 u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    519                                 BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
    520                                 BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
    521                                 BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
    522                                 BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    523                                 u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    524                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
    525                                 u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    526                         }
    527                         else
    528                         {
    529                                 carry_set_0.CarryDequeueEnqueue(1, 9);
    530                         }
    531                         BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
    532                         if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF)))
    533                         {
    534                                 assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
    535                         }
    536                 }
    537                 else
    538                 {
    539                         carry_set_0.CarryDequeueEnqueue(0, 10);
    540                 }
    541         }
    542        
    543         CarryDeclare(carry_set_0, 10, 0);
    544 };
    545  
    546 struct Parse_CtCDPI
    547 {
    548         Parse_CtCDPI()
    549         {
    550                 carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)), 2);
    551         }
    552          
    553         IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams)
    554         {
    555                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    556                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    557                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    558                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    559                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    560                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    561                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    562                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    563                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
    564                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
    565                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
    566                 BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
    567                 BitBlock w = simd_or(lex.Hyphen, lex.QMark);
    568                 BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
    569                 BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    570                 BitBlock LAngle_scope = simd_andc(v1, w1);
    571                 BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
    572                 BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
    573                 BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
    574                 BitBlock CD_closer = simd<1>::constant<0>();
    575                 BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    576                 if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    577                 {
    578                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
    579                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    580                 }
    581                 else
    582                 {
    583                         carry_set_0.CarryDequeueEnqueue(0, 2);
    584                 }
    585                 BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    586                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    587                 if (bitblock::any(simd_or(CtCDPI_Cursor, carry_set_0.CarryRange(3, 13))))
    588                 {
    589                         CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    590                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    591                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    592                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    593                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    594                         if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    595                         {
    596                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    597                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    598                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    599                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    600                                 BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    601                                 BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    602                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    603                                 if (bitblock::any(PI_error))
    604                                 {
    605                                         assert_0_error("Error in PI syntax", PI_error);
    606                                 }
    607                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    608                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carry_set_0.GetCarry(7), 7);
    609                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    610                                 CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    611                         }
    612                         else
    613                         {
    614                                 carry_set_0.CarryDequeueEnqueue(4, 4);
    615                         }
    616                         if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    617                         {
    618                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    619                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carry_set_0.GetCarry(8), 8);
    620                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    621                                 CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    622                         }
    623                         else
    624                         {
    625                                 carry_set_0.CarryDequeueEnqueue(8, 1);
    626                         }
    627                         if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    628                         {
    629                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    630                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    631                                 BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    632                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
    633                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    634                                 if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    635                                 {
    636                                         assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    637                                 }
    638                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    639                                 CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    640                         }
    641                         else
    642                         {
    643                                 carry_set_0.CarryDequeueEnqueue(9, 5);
    644                         }
    645                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    646                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    647                         if (bitblock::any(simd<1>::constant<0>()))
    648                         {
    649                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    650                         }
    651                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    652                         while (bitblock::any(CtCDPI_Cursor))
    653                         {
    654                                 CarryDeclare(carry_set_1, 13, 0);
    655                                 CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    656                                 BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    657                                 BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    658                                 BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    659                                 BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    660                                 if (bitblock::any(PI_Cursor))
    661                                 {
    662                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    663                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    664                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    665                                         BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    666                                         BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    667                                         BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    668                                         PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    669                                         if (bitblock::any(PI_error))
    670                                         {
    671                                                 assert_0_error("Error in PI syntax", PI_error);
    672                                         }
    673                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    674                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 4);
    675                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    676                                         CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    677                                 }
    678                                 if (bitblock::any(CD_Cursor))
    679                                 {
    680                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    681                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 5);
    682                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    683                                         CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    684                                 }
    685                                 if (bitblock::any(Ct_Cursor))
    686                                 {
    687                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    688                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    689                                         BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    690                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
    691                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    692                                         if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    693                                         {
    694                                                 assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    695                                         }
    696                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    697                                         CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    698                                 }
    699                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    700                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    701                                 if (bitblock::any(simd<1>::constant<0>()))
    702                                 {
    703                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    704                                 }
    705                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 12);
    706                                 carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
    707                         }
    708                 }
    709                 else
    710                 {
    711                         carry_set_0.CarryDequeueEnqueue(3, 13);
    712                 }
    713                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    714                 marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    715                 marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
    716                 marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
    717                 carry_set_0.CarryAdjust(17);
    718         }
    719        
    720         void do_final_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
    721         {
    722                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    723                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    724                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    725                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    726                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    727                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    728                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    729                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    730                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
    731                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
    732                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
    733                 BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
    734                 BitBlock w = simd_or(lex.Hyphen, lex.QMark);
    735                 BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
    736                 BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    737                 BitBlock LAngle_scope = simd_andc(v1, w1);
    738                 BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
    739                 BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
    740                 BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
    741                 BitBlock CD_closer = simd<1>::constant<0>();
    742                 BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    743                 if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    744                 {
    745                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
    746                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    747                 }
    748                 else
    749                 {
    750                         carry_set_0.CarryDequeueEnqueue(0, 2);
    751                 }
    752                 BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    753                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    754                 if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor, EOF_mask), carry_set_0.CarryRange(3, 13))))
    755                 {
    756                         CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    757                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    758                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    759                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    760                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    761                         if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    762                         {
    763                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    764                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    765                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    766                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    767                                 BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    768                                 BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    769                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    770                                 if (bitblock::any(PI_error))
    771                                 {
    772                                         assert_0_error("Error in PI syntax", PI_error);
    773                                 }
    774                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    775                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_set_0.GetCarry(7), 7);
    776                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    777                                 CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    778                         }
    779                         else
    780                         {
    781                                 carry_set_0.CarryDequeueEnqueue(4, 4);
    782                         }
    783                         if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    784                         {
    785                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    786                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_set_0.GetCarry(8), 8);
    787                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    788                                 CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    789                         }
    790                         else
    791                         {
    792                                 carry_set_0.CarryDequeueEnqueue(8, 1);
    793                         }
    794                         if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    795                         {
    796                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    797                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    798                                 BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    799                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
    800                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    801                                 if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    802                                 {
    803                                         assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    804                                 }
    805                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    806                                 CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    807                         }
    808                         else
    809                         {
    810                                 carry_set_0.CarryDequeueEnqueue(9, 5);
    811                         }
    812                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    813                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    814                         if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    815                         {
    816                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    817                         }
    818                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    819                         while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)))
    820                         {
    821                                 CarryDeclare(carry_set_1, 13, 0);
    822                                 CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    823                                 BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    824                                 BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    825                                 BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    826                                 BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    827                                 if (bitblock::any(PI_Cursor))
    828                                 {
    829                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    830                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    831                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    832                                         BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    833                                         BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    834                                         BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    835                                         PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    836                                         if (bitblock::any(PI_error))
    837                                         {
    838                                                 assert_0_error("Error in PI syntax", PI_error);
    839                                         }
    840                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    841                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 4);
    842                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    843                                         CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    844                                 }
    845                                 if (bitblock::any(CD_Cursor))
    846                                 {
    847                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    848                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 5);
    849                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    850                                         CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    851                                 }
    852                                 if (bitblock::any(Ct_Cursor))
    853                                 {
    854                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    855                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    856                                         BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    857                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
    858                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    859                                         if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    860                                         {
    861                                                 assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    862                                         }
    863                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    864                                         CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    865                                 }
    866                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    867                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    868                                 if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    869                                 {
    870                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    871                                 }
    872                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 12);
    873                                 carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
    874                         }
    875                 }
    876                 else
    877                 {
    878                         carry_set_0.CarryDequeueEnqueue(3, 13);
    879                 }
    880                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    881                 marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    882                 marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
    883                 marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
    884         }
    885        
    886         CarryDeclare(carry_set_0, 17, 2);
    887 };
    888  
    889 struct Parse_tags
    890 {
    891         Parse_tags()
    892         {
    893                
    894         }
    895          
    896         IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts)
    897         {
    898                 BitBlock EqExpected = simd<1>::constant<0>();
    899                 BitBlock AttListEnd = simd<1>::constant<0>();
    900                 BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
    901                 BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
    902                 BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
    903                 tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    904                 tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    905                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    906                 BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    907                 tag_Callouts.AttName_starts = simd<1>::constant<0>();
    908                 tag_Callouts.AttName_ends = simd<1>::constant<0>();
    909                 tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    910                 tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    911                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    912                 {
    913                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    914                         AttListEnd = simd_and(AfterWS, AttListDelim);
    915                         BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
    916                         if (bitblock::any(simd_or(AttNameStart, carry_set_0.CarryRange(2, 7))))
    917                         {
    918                                 ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    919                                 tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    920                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    921                                 tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    922                                 if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    923                                 {
    924                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    925                                 }
    926                                 else
    927                                 {
    928                                         EqExpected = AttNameFollow;
    929                                         carry_set_0.CarryDequeueEnqueue(3, 1);
    930                                 }
    931                                 ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    932                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    933                                 tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    934                                 BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    935                                 BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    936                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carry_set_0.GetCarry(5), 5);
    937                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carry_set_0.GetCarry(6), 6);
    938                                 BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    939                                 ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    940                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    941                                 tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    942                                 if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    943                                 {
    944                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    945                                         AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    946                                         AttNameStart = simd_andc(AfterWS, AttListDelim);
    947                                 }
    948                                 else
    949                                 {
    950                                         AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    951                                         AttNameStart = simd_andc(AttValFollow, AttListDelim);
    952                                         carry_set_0.CarryDequeueEnqueue(8, 1);
    953                                 }
    954                                 ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    955                                 while (bitblock::any(AttNameStart))
    956                                 {
    957                                         CarryDeclare(carry_set_1, 7, 0);
    958                                         ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    959                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    960                                         BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    961                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    962                                         if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    963                                         {
    964                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    965                                         }
    966                                         else
    967                                         {
    968                                                 EqExpected = AttNameFollow;
    969                                         }
    970                                         ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    971                                         BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    972                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    973                                         BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    974                                         BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    975                                         BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), 3);
    976                                         BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), 4);
    977                                         BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    978                                         ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    979                                         BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    980                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    981                                         if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    982                                         {
    983                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    984                                                 AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    985                                                 AttNameStart = simd_andc(AfterWS, AttListDelim);
    986                                         }
    987                                         else
    988                                         {
    989                                                 AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    990                                                 AttNameStart = simd_andc(AttValFollow, AttListDelim);
    991                                         }
    992                                         ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    993                                         carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
    994                                 }
    995                         }
    996                         else
    997                         {
    998                                 carry_set_0.CarryDequeueEnqueue(2, 7);
    999                         }
    1000                 }
    1001                 else
    1002                 {
    1003                         AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
    1004                         ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
    1005                         carry_set_0.CarryDequeueEnqueue(1, 8);
    1006                 }
    1007                 BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1008                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    1009                 ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1010                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    1011                 if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    1012                 {
    1013                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    1014                 }
    1015                 else
    1016                 {
    1017                         carry_set_0.CarryDequeueEnqueue(11, 1);
    1018                 }
    1019                 ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
    1020                 if (bitblock::any(ParseError))
    1021                 {
    1022                         assert_0_error("Tag parsing error found", ParseError);
    1023                 }
    1024                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    1025                 carry_set_0.CarryAdjust(13);
    1026         }
    1027        
    1028         void do_final_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts, BitBlock & EOF_mask)
    1029         {
    1030                 BitBlock EqExpected = simd<1>::constant<0>();
    1031                 BitBlock AttListEnd = simd<1>::constant<0>();
    1032                 BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
    1033                 BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
    1034                 BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
    1035                 tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    1036                 tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    1037                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    1038                 BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    1039                 tag_Callouts.AttName_starts = simd<1>::constant<0>();
    1040                 tag_Callouts.AttName_ends = simd<1>::constant<0>();
    1041                 tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    1042                 tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1043                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    1044                 {
    1045                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    1046                         AttListEnd = simd_and(AfterWS, AttListDelim);
    1047                         BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
    1048                         if (bitblock::any(simd_or(simd_and(AttNameStart, EOF_mask), carry_set_0.CarryRange(2, 7))))
    1049                         {
    1050                                 ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1051                                 tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1052                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    1053                                 tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1054                                 if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    1055                                 {
    1056                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    1057                                 }
    1058                                 else
    1059                                 {
    1060                                         EqExpected = AttNameFollow;
    1061                                         carry_set_0.CarryDequeueEnqueue(3, 1);
    1062                                 }
    1063                                 ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1064                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    1065                                 tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1066                                 BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1067                                 BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1068                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_set_0.GetCarry(5), 5);
    1069                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_set_0.GetCarry(6), 6);
    1070                                 BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1071                                 ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1072                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    1073                                 tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1074                                 if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    1075                                 {
    1076                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    1077                                         AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1078                                         AttNameStart = simd_andc(AfterWS, AttListDelim);
    1079                                 }
    1080                                 else
    1081                                 {
    1082                                         AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    1083                                         AttNameStart = simd_andc(AttValFollow, AttListDelim);
    1084                                         carry_set_0.CarryDequeueEnqueue(8, 1);
    1085                                 }
    1086                                 ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    1087                                 while (bitblock::any(simd_and(AttNameStart, EOF_mask)))
    1088                                 {
    1089                                         CarryDeclare(carry_set_1, 7, 0);
    1090                                         ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1091                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1092                                         BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    1093                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1094                                         if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    1095                                         {
    1096                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    1097                                         }
    1098                                         else
    1099                                         {
    1100                                                 EqExpected = AttNameFollow;
    1101                                         }
    1102                                         ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1103                                         BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    1104                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1105                                         BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1106                                         BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1107                                         BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), 3);
    1108                                         BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), 4);
    1109                                         BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1110                                         ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1111                                         BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    1112                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1113                                         if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    1114                                         {
    1115                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    1116                                                 AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1117                                                 AttNameStart = simd_andc(AfterWS, AttListDelim);
    1118                                         }
    1119                                         else
    1120                                         {
    1121                                                 AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    1122                                                 AttNameStart = simd_andc(AttValFollow, AttListDelim);
    1123                                         }
    1124                                         ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    1125                                         carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
    1126                                 }
    1127                         }
    1128                         else
    1129                         {
    1130                                 carry_set_0.CarryDequeueEnqueue(2, 7);
    1131                         }
    1132                 }
    1133                 else
    1134                 {
    1135                         AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
    1136                         ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
    1137                         carry_set_0.CarryDequeueEnqueue(1, 8);
    1138                 }
    1139                 BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1140                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    1141                 ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1142                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    1143                 if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    1144                 {
    1145                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    1146                 }
    1147                 else
    1148                 {
    1149                         carry_set_0.CarryDequeueEnqueue(11, 1);
    1150                 }
    1151                 ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
    1152                 if (bitblock::any(ParseError))
    1153                 {
    1154                         assert_0_error("Tag parsing error found", ParseError);
    1155                 }
    1156                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    1157         }
    1158        
    1159         CarryDeclare(carry_set_0, 13, 0);
    1160 };
    1161  
    1162 struct Parse_refs
    1163 {
    1164         Parse_refs()
    1165         {
    1166                
    1167         }
    1168          
    1169         IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts)
    1170         {
    1171                 ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    1172                 ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    1173                 ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    1174                 ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    1175                 ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    1176                 ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    1177                 BitBlock ref_error = simd<1>::constant<0>();
    1178                 if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    1179                 {
    1180                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
    1181                         BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    1182                         ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1183                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
    1184                         BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    1185                         ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1186                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
    1187                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
    1188                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
    1189                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
    1190                         BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    1191                         BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
    1192                         BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    1193                         BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
    1194                         if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3)))
    1195                         {
    1196                                 assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
    1197                         }
    1198                 }
    1199                 else
    1200                 {
    1201                         carry_set_0.CarryDequeueEnqueue(0, 6);
    1202                 }
    1203                 carry_set_0.CarryAdjust(6);
    1204         }
    1205        
    1206         void do_final_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts, BitBlock & EOF_mask)
    1207         {
    1208                 ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    1209                 ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    1210                 ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    1211                 ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    1212                 ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    1213                 ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    1214                 BitBlock ref_error = simd<1>::constant<0>();
    1215                 if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    1216                 {
    1217                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
    1218                         BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    1219                         ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1220                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
    1221                         BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    1222                         ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1223                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
    1224                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
    1225                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
    1226                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
    1227                         BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    1228                         BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
    1229                         BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    1230                         BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
    1231                         if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3)))
    1232                         {
    1233                                 assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
    1234                         }
    1235                 }
    1236                 else
    1237                 {
    1238                         carry_set_0.CarryDequeueEnqueue(0, 6);
    1239                 }
    1240         }
    1241        
    1242         CarryDeclare(carry_set_0, 6, 0);
    1243 };
    1244  
    1245 struct Validate_xml_names
    1246 {
    1247         Validate_xml_names()
    1248         {
    1249                
    1250         }
    1251          
    1252         IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Lex & lex, struct U8 & u8, struct Check_streams & check_streams)
    1253         {
    1254                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
    1255                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
    1256                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
    1257                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
    1258                 BitBlock qname_stream = simd_or(ElemNames, AttNames);
    1259                 BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    1260                 BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1261                 BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
    1262                 BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
    1263                 BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1264                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
    1265                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
    1266                 BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1267                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
    1268                 BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    1269                 if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
    1270                 {
    1271                         assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
    1272                 }
    1273                 check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
    1274                 check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    1275                 carry_set_0.CarryAdjust(9);
    1276         }
    1277        
    1278         void do_final_block(struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Lex & lex, struct U8 & u8, struct Check_streams & check_streams, BitBlock & EOF_mask)
    1279         {
    1280                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
    1281                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
    1282                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
    1283                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
    1284                 BitBlock qname_stream = simd_or(ElemNames, AttNames);
    1285                 BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    1286                 BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1287                 BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
    1288                 BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
    1289                 BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1290                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
    1291                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
    1292                 BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1293                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
    1294                 BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    1295                 if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
    1296                 {
    1297                         assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
    1298                 }
    1299                 check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
    1300                 check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    1301         }
    1302        
    1303         CarryDeclare(carry_set_0, 9, 0);
    1304 };
    1305  
    1306 struct Do_check_streams
    1307 {
    1308         Do_check_streams()
    1309         {
    1310                
    1311         }
    1312          
    1313         IDISA_INLINE void do_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams)
    1314         {
    1315                 if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans)))
    1316                 {
    1317                         assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
    1318                 }
    1319                 check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
    1320                 check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
    1321                 check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
    1322         }
    1323        
    1324         void do_final_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
    1325         {
    1326                 if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans)))
    1327                 {
    1328                         assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
    1329                 }
    1330                 check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
    1331                 check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
    1332                 check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
     74                a.b();
    133375        }
    133476       
  • proto/pabloj/branches/refactor-experimental/src/application/config/ConfigurationFactory.java

    r3134 r3166  
    3434       
    3535        if (configuration.targetLang.equals(Configuration.CLANG)) { // C language
    36                 System.out.println("I'm using clang");
    3736                configuration.templateFileName = cli.getOptionValue("t", "pablo_definitions.template");
    3837                configuration.templateDirectory = FileUtil.ensureEndsWith(cli.getOptionValue("T", Configuration.TEMPLATES_DIRECTORY + Configuration.CLANG), File.separator);
     
    4241               
    4342        } else { // C++ language - default
    44                 System.out.println("I'm using cpplang");
    4543                configuration.templateFileName = cli.getOptionValue("t", "pablo_definitions.template");
    4644                configuration.templateDirectory = FileUtil.ensureEndsWith(cli.getOptionValue("T", Configuration.TEMPLATES_DIRECTORY + Configuration.CPPLANG), File.separator);
  • proto/pabloj/branches/refactor-experimental/src/pabloB/ast/ASTNode.java

    r3004 r3166  
    1111
    1212import pabloB.tokens.Token;
    13 
    14 
    15 
    16 public class ASTNode  {
     13import pabloB.inputHandler.Locator;
     14import pabloB.inputHandler.TextLocation;
     15
     16
     17
     18public class ASTNode implements Locator  {
    1719        public static final ASTNode NO_PARENT = null;
    1820        public static final int NO_TAG = -1;
     
    8486                return simplifiable;
    8587        }
     88        public TextLocation getLocation() {
     89                return getToken().getLocation();
     90        }       
    8691
    8792
     
    133138                replaceChild(index, replacement);
    134139        }
    135         private void replaceChild(int index, ASTNode replacement) {
     140        public void replaceChild(int index, ASTNode replacement) {
    136141                ASTNode oldChild = children.remove(index);
    137142                oldChild.setParent(null);
  • proto/pabloj/branches/refactor-experimental/src/pabloB/ast/ASTVisitor.java

    r3010 r3166  
    145145                        return defaultVisit(node);
    146146                }
    147                 public T defaultVisitLeave(ASTNode node) {
     147                public T defaultVisitLeave(ASTNode node, List<T> childResults) {
    148148                        return defaultVisit(node);
    149149                }
     
    154154                }
    155155                public T visitLeave(ASTNode node, List<T> childResults) {
    156                         defaultVisitLeave(node);
     156                        defaultVisitLeave(node, childResults);
    157157                        throw new RuntimeException("Node class unimplemented in DefaultVisitor: " + node.getClass());
    158158                }
     
    162162                }
    163163                public T visitLeave(AssignNode node, List<T> childResults) {
    164                         return defaultVisitLeave(node);
     164                        return defaultVisitLeave(node, childResults);
    165165                }
    166166
     
    169169                }
    170170                public T visitLeave(AssignOperatorNode node, List<T> childResults) {
    171                         return defaultVisitLeave(node);
     171                        return defaultVisitLeave(node, childResults);
    172172                }
    173173
     
    176176                }
    177177                public T visitLeave(BitBlockTypeNode node, List<T> childResults) {
    178                         return defaultVisitLeave(node);
     178                        return defaultVisitLeave(node, childResults);
    179179                }
    180180
     
    183183                }
    184184                public T visitLeave(BitFieldTypeNode node, List<T> childResults) {
    185                         return defaultVisitLeave(node);
     185                        return defaultVisitLeave(node, childResults);
    186186                }
    187187
     
    190190                }
    191191                public T visitLeave(BlockStmtNode node, List<T> childResults) {
    192                         return defaultVisitLeave(node);
     192                        return defaultVisitLeave(node, childResults);
    193193                }
    194194
     
    197197                }
    198198                public T visitLeave(CompoundIdentifierNode node, List<T> childResults) {
    199                         return defaultVisitLeave(node);
     199                        return defaultVisitLeave(node, childResults);
    200200                }
    201201
     
    204204                }
    205205                public T visitLeave(EpsilonNode node, List<T> childResults) {
    206                         return defaultVisitLeave(node);
     206                        return defaultVisitLeave(node, childResults);
    207207                }
    208208
     
    211211                }
    212212                public T visitLeave(ErrorNode node, List<T> childResults) {
    213                         return defaultVisitLeave(node);
     213                        return defaultVisitLeave(node, childResults);
    214214                }
    215215
     
    218218                }
    219219                public T visitLeave(FieldWidthNode node, List<T> childResults) {
    220                         return defaultVisitLeave(node);
     220                        return defaultVisitLeave(node, childResults);
    221221                }
    222222
     
    225225                }
    226226                public T visitLeave(FuncCallArgListNode node, List<T> childResults) {
    227                         return defaultVisitLeave(node);
     227                        return defaultVisitLeave(node, childResults);
    228228                }
    229229
     
    232232                }
    233233                public T visitLeave(FuncCallNode node, List<T> childResults) {
    234                         return defaultVisitLeave(node);
     234                        return defaultVisitLeave(node, childResults);
    235235                }
    236236
     
    239239                }
    240240                public T visitLeave(FuncCallOrAssignStmtNode node, List<T> childResults) {
    241                         return defaultVisitLeave(node);
     241                        return defaultVisitLeave(node, childResults);
    242242                }
    243243
     
    246246                }
    247247                public T visitLeave(FuncDefNode node, List<T> childResults) {
    248                         return defaultVisitLeave(node);
     248                        return defaultVisitLeave(node, childResults);
    249249                }
    250250
     
    253253                }
    254254                public T visitLeave(IdentifierNode node, List<T> childResults) {
    255                         return defaultVisitLeave(node);
     255                        return defaultVisitLeave(node, childResults);
    256256                }
    257257
     
    260260                }
    261261                public T visitLeave(IdisaFuncCallArgListNode node, List<T> childResults) {
    262                         return defaultVisitLeave(node);
     262                        return defaultVisitLeave(node, childResults);
    263263                }
    264264
     
    267267                }
    268268                public T visitLeave(IdisaFuncCallNode node, List<T> childResults) {
    269                         return defaultVisitLeave(node);
     269                        return defaultVisitLeave(node, childResults);
    270270                }
    271271
     
    274274                }
    275275                public T visitLeave(IfStmtNode node, List<T> childResults) {
    276                         return defaultVisitLeave(node);
     276                        return defaultVisitLeave(node, childResults);
    277277                }
    278278
     
    281281                }
    282282                public T visitLeave(InitBlockNode node, List<T> childResults) {
    283                         return defaultVisitLeave(node);
     283                        return defaultVisitLeave(node, childResults);
    284284                }
    285285
     
    288288                }
    289289                public T visitLeave(InitDefNode node, List<T> childResults) {
    290                         return defaultVisitLeave(node);
     290                        return defaultVisitLeave(node, childResults);
    291291                }
    292292
     
    295295                }
    296296                public T visitLeave(IntegerConstantNode node, List<T> childResults) {
    297                         return defaultVisitLeave(node);
     297                        return defaultVisitLeave(node, childResults);
    298298                }
    299299
     
    302302                }
    303303                public T visitLeave(KernelDefNode node, List<T> childResults) {
    304                         return defaultVisitLeave(node);
     304                        return defaultVisitLeave(node, childResults);
    305305                }
    306306
     
    309309                }
    310310                public T visitLeave(LocalVarDeclNode node, List<T> childResults) {
    311                         return defaultVisitLeave(node);
     311                        return defaultVisitLeave(node, childResults);
    312312                }
    313313
     
    316316                }
    317317                public T visitLeave(ParameterListNode node, List<T> childResults) {
    318                         return defaultVisitLeave(node);
     318                        return defaultVisitLeave(node, childResults);
    319319                }
    320320
     
    323323                }
    324324                public T visitLeave(ParameterNode node, List<T> childResults) {
    325                         return defaultVisitLeave(node);
     325                        return defaultVisitLeave(node, childResults);
    326326                }
    327327
     
    330330                }
    331331                public T visitLeave(ProgramNode node, List<T> childResults) {
    332                         return defaultVisitLeave(node);
     332                        return defaultVisitLeave(node, childResults);
    333333                }
    334334
     
    337337                }
    338338                public T visitLeave(ReturnStmtNode node, List<T> childResults) {
    339                         return defaultVisitLeave(node);
     339                        return defaultVisitLeave(node, childResults);
    340340                }
    341341
     
    344344                }
    345345                public T visitLeave(StateIdentifierNode node, List<T> childResults) {
    346                         return defaultVisitLeave(node);
     346                        return defaultVisitLeave(node, childResults);
    347347                }
    348348
     
    351351                }
    352352                public T visitLeave(StateInitListNode node, List<T> childResults) {
    353                         return defaultVisitLeave(node);
     353                        return defaultVisitLeave(node, childResults);
    354354                }
    355355
     
    358358                }
    359359                public T visitLeave(StateInitStmtNode node, List<T> childResults) {
    360                         return defaultVisitLeave(node);
     360                        return defaultVisitLeave(node, childResults);
    361361                }
    362362
     
    365365                }
    366366                public T visitLeave(StateSizeNode node, List<T> childResults) {
    367                         return defaultVisitLeave(node);
     367                        return defaultVisitLeave(node, childResults);
    368368                }
    369369
     
    372372                }
    373373                public T visitLeave(StateValueNode node, List<T> childResults) {
    374                         return defaultVisitLeave(node);
     374                        return defaultVisitLeave(node, childResults);
    375375                }
    376376
     
    379379                }
    380380                public T visitLeave(StreamConstantNode node, List<T> childResults) {
    381                         return defaultVisitLeave(node);
     381                        return defaultVisitLeave(node, childResults);
    382382                }
    383383
     
    386386                }
    387387                public T visitLeave(StreamTypeNode node, List<T> childResults) {
    388                         return defaultVisitLeave(node);
     388                        return defaultVisitLeave(node, childResults);
    389389                }
    390390
     
    393393                }
    394394                public T visitLeave(StringConstantNode node, List<T> childResults) {
    395                         return defaultVisitLeave(node);
     395                        return defaultVisitLeave(node, childResults);
    396396                }
    397397
     
    400400                }
    401401                public T visitLeave(StructMemberNode node, List<T> childResults) {
    402                         return defaultVisitLeave(node);
     402                        return defaultVisitLeave(node, childResults);
    403403                }
    404404
     
    407407                }
    408408                public T visitLeave(StructTypeBodyNode node, List<T> childResults) {
    409                         return defaultVisitLeave(node);
     409                        return defaultVisitLeave(node, childResults);
    410410                }
    411411
     
    414414                }
    415415                public T visitLeave(StructTypeNode node, List<T> childResults) {
    416                         return defaultVisitLeave(node);
     416                        return defaultVisitLeave(node, childResults);
    417417                }
    418418
     
    421421                }
    422422                public T visitLeave(TypeDeclNode node, List<T> childResults) {
    423                         return defaultVisitLeave(node);
     423                        return defaultVisitLeave(node, childResults);
    424424                }
    425425
     
    428428                }
    429429                public T visitLeave(VoidTypeNode node, List<T> childResults) {
    430                         return defaultVisitLeave(node);
     430                        return defaultVisitLeave(node, childResults);
    431431                }
    432432
     
    435435                }
    436436                public T visitLeave(WhileStmtNode node, List<T> childResults) {
    437                         return defaultVisitLeave(node);
     437                        return defaultVisitLeave(node, childResults);
    438438                }
    439439
  • proto/pabloj/branches/refactor-experimental/src/pabloB/inputHandler/BookmarkCharStream.java

    r2834 r3166  
    88package pabloB.inputHandler;
    99
    10 import java.util.Stack;
     10import java.util.ArrayDeque;
     11import java.util.Deque;
    1112
    1213public class BookmarkCharStream extends PushbackCharStream {
     
    1819
    1920       
    20         private Stack<Object> bookmarkedText;
     21        private Deque<Object> bookmarkedText;
    2122        private boolean isBookmarking;
    2223       
    2324        public BookmarkCharStream(InputHandler handler) {
    2425                super(handler);
    25                 this.bookmarkedText = new Stack<Object>();
     26                this.bookmarkedText = new ArrayDeque<Object>();
    2627                isBookmarking = false;
    2728        }
     
    7172        }
    7273
    73         // it would probably be faster to check the bottom of stack against
    74         // bookmark first...
     74
    7575        public void release(Bookmark bookmark) {
    76                 Object object;
    77                 do {
    78                         object = bookmarkedText.pop();
    79                 } while (object != bookmark);
    80                
    81                 if(bookmarkedText.isEmpty()) {
     76                if(bookmark == bookmarkedText.peekLast()) {
     77                        bookmarkedText.clear();
    8278                        isBookmarking = false;
     79                }
     80                else {
     81                        bookmarkedText.removeFirstOccurrence(bookmark);
    8382                }
    8483        }
  • proto/pabloj/branches/refactor-experimental/src/pabloB/inputHandler/TextLocation.java

    r2834 r3166  
    99
    1010// value object for specifying the location of a lexeme or other piece of text
    11 public class TextLocation {
     11public class TextLocation implements Locator {
    1212        private String filename;
    1313        private int lineNumber;
     
    4343        }
    4444       
     45        @Override
     46        public TextLocation getLocation() {
     47                return this;
     48        }
    4549       
    4650       
  • proto/pabloj/branches/refactor-experimental/src/pabloB/lexicalAnalyzer/tokenRecognizers/CharacterTokenRecognizer.java

    r2834 r3166  
    1515
    1616public class CharacterTokenRecognizer extends TokenRecognizerImp {
     17
    1718        public CharacterTokenRecognizer(BookmarkCharStream input, LexicalType lexicalType) {
    1819                super(input, lexicalType);
     
    2021
    2122        protected Result tryToReadToken() {
     23               
    2224                LocatedChar firstChar = input.next();
    2325                TextLocation location = firstChar.getLocation();
     
    2931                return Result.FOUND;
    3032        }
     33       
    3134}
    3235
  • proto/pabloj/branches/refactor-experimental/src/pabloB/lexicalAnalyzer/tokenRecognizers/IdentifierTokenRecognizer.java

    r2834 r3166  
    6666        }
    6767        public static boolean isIdentifierStart(LocatedChar lc) {
    68                 return Character.isJavaIdentifierStart(lc.getCharacter());
     68                return isIdentifierStart(lc.getCharacter());
    6969        }
    7070        public static boolean isIdentifierStart(char c) {
    71                 return Character.isJavaIdentifierStart(c);
     71                return Character.isJavaIdentifierStart(c) && (c != '$');
    7272        }
    7373}
  • proto/pabloj/branches/refactor-experimental/src/pabloB/lexicalAnalyzer/tokenRecognizers/TokenRecognizerImp.java

    r2834 r3166  
    99import pabloB.lexicalAnalyzer.LexicalType;
    1010import pabloB.lexicalAnalyzer.TokenRecognizer;
     11import pabloB.logging.ScatterLogger;
    1112import pabloB.tokens.Token;
    1213import pabloB.inputHandler.LocatedChar;
     
    115116                return result;
    116117        }
     118
    117119        private boolean sloppyInputStartsWith(String lexeme) {
    118120                for(int i=0; i<lexeme.length(); i++) {
     
    123125                return true;
    124126        }
     127       
     128       
     129        protected void lexicalError(String msg) {
     130                logError("lexical error: " + msg);
     131        }
     132
     133        static void logError(String message) {
     134                ScatterLogger log = ScatterLogger.getLogger("compiler.semanticAnalyzer");
     135                log.severe(message);
     136        }
    125137}
  • proto/pabloj/branches/refactor-experimental/src/pabloB/parser/Parser.java

    r3010 r3166  
    2121
    2222
     23
    2324@SuppressWarnings("unused")
    2425public class Parser {
     
    6364                                }
    6465                        }
     66                        else {
     67                                return syntaxErrorNode("[BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, KERNEL¹, STREAM¹, STRUCT¹, VOID¹]");
     68                        }
    6569                }
    6670                if(allowCompression) {
     
    575579                        }
    576580                }
     581                else {
     582                        return syntaxErrorNode("[IDENTIFIER¹, IF¹, INTEGER_CONST¹, LROUND¹, RETURN¹, SQ_STRING¹, STRING¹, VAR¹, WHILE¹]");
     583                }
    577584                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
    578585                        expect(Lextant.TERMINATOR);
     
    624631                        result = promoteLastChild(result);
    625632                        allowCompression = false;
     633                }
     634                else {
     635                        return syntaxErrorNode("[ASSIGN¹, LANGLE¹, LROUND¹]");
    626636                }
    627637                expect(Lextant.TERMINATOR);
     
    10071017                                        allowCompression = false;
    10081018                                }
    1009                         }
     1019                                else {
     1020                                        return syntaxErrorNode("[LANGLE¹, LROUND¹]");
     1021                                }
     1022                        }
     1023                }
     1024                else {
     1025                        return syntaxErrorNode("[IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
    10101026                }
    10111027                if(allowCompression) {
     
    10381054                        }
    10391055                }
     1056                else {
     1057                        return syntaxErrorNode("[INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
     1058                }
    10401059                if(allowCompression) {
    10411060                        return compressIfPossible(result);
     
    10601079                        ASTNode temp_1 = result;
    10611080                        IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
    1062                         IntConstantToken temp_6 = (IntConstantToken)previouslyRead;
     1081                        IntValuedToken temp_6 = (IntValuedToken)previouslyRead;
    10631082                        int temp_5 = temp_6.getValue();
    10641083                        temp_3.setValue( temp_5 );
     
    10911110                        readToken();
    10921111                }
     1112                else {
     1113                        return syntaxErrorNode("[SQ_STRING¹, STRING¹]");
     1114                }
    10931115                if(allowCompression) {
    10941116                        return result;
     
    11951217                                allChildren.add(child);
    11961218                        }
     1219                }
     1220                else {
     1221                        return syntaxErrorNode("[BITBLOCK¹, BITFIELD¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    11971222                }
    11981223                if(allowCompression) {
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/CharacterToken.java

    r2834 r3166  
    99
    1010import pabloB.lexicalAnalyzer.LexicalType;
    11 import pabloB.inputHandler.TextLocation;
     11import pabloB.inputHandler.Locator;
    1212
    13 public class CharacterToken extends TokenImp {
    14         protected CharacterToken(LexicalType type, TextLocation location, String lexeme) {
     13public class CharacterToken extends TokenImp implements IntValuedToken {
     14        private char value;
     15
     16        protected CharacterToken(LexicalType type, Locator location, String lexeme, char value) {
    1517                super(type, location, lexeme.intern());
     18                this.value = value;
    1619        }
    1720       
    18         public static CharacterToken make(LexicalType type, TextLocation location, String lexeme) {
    19                 CharacterToken result = new CharacterToken(type, location, lexeme);
     21        public static CharacterToken make(LexicalType type, Locator location, String lexeme) {
     22                CharacterToken result = new CharacterToken(type, location, lexeme, lexeme.charAt(0));
    2023                return result;
    2124        }
    22 
     25        public static CharacterToken make(LexicalType type, Locator location, String lexeme, char value) {
     26                CharacterToken result = new CharacterToken(type, location, lexeme, value);
     27                return result;
     28        }
     29       
     30        public char getChar() {
     31                return value;
     32        }
     33        public int getValue() {
     34                return (int)(value);
     35        }
    2336
    2437        @Override
    2538        protected String rawString() {
    26                 return "character, " + getLexeme();
     39                return "character, " + getChar();
    2740        }
    2841}
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/CommentToken.java

    r2834 r3166  
    99
    1010import pabloB.lexicalAnalyzer.LexicalType;
    11 import pabloB.inputHandler.TextLocation;
     11import pabloB.inputHandler.Locator;
    1212
    1313public class CommentToken extends TokenImp {
    1414       
    15         protected CommentToken(LexicalType type, TextLocation location, String lexeme) {
     15        protected CommentToken(LexicalType type, Locator location, String lexeme) {
    1616                super(type, location, lexeme);
    1717        }
    1818       
    19         public static CommentToken make(LexicalType type, TextLocation location, String lexeme) {
     19        public static CommentToken make(LexicalType type, Locator location, String lexeme) {
    2020                CommentToken result = new CommentToken(type, location, lexeme);
    2121                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/FloatConstantToken.java

    r2834 r3166  
    99
    1010import pabloB.lexicalAnalyzer.LexicalType;
    11 import pabloB.inputHandler.TextLocation;
     11import pabloB.inputHandler.Locator;
    1212
    1313public class FloatConstantToken extends TokenImp {
    1414        protected double value;
    1515       
    16         protected FloatConstantToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected FloatConstantToken(LexicalType type, Locator location, String lexeme) {
    1717                super(type, location, lexeme);
    1818        }
     
    2424        }
    2525       
    26         public static FloatConstantToken make(LexicalType type, TextLocation location, String lexeme) {
     26        public static FloatConstantToken make(LexicalType type, Locator location, String lexeme) {
    2727                FloatConstantToken result = new FloatConstantToken(type, location, lexeme);
    2828                result.setValue(Double.parseDouble(lexeme));
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/IdentifierToken.java

    r2834 r3166  
    99
    1010import pabloB.lexicalAnalyzer.LexicalType;
    11 import pabloB.inputHandler.TextLocation;
     11import pabloB.inputHandler.Locator;
    1212
    1313public class IdentifierToken extends TokenImp {
    14         protected IdentifierToken(LexicalType type, TextLocation location, String lexeme) {
     14        protected IdentifierToken(LexicalType type, Locator location, String lexeme) {
    1515                super(type, location, lexeme.intern());
    1616        }
    1717       
    18         public static IdentifierToken make(LexicalType type, TextLocation location, String lexeme) {
     18        public static IdentifierToken make(LexicalType type, Locator location, String lexeme) {
    1919                IdentifierToken result = new IdentifierToken(type, location, lexeme);
    2020                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/IntConstantToken.java

    r2834 r3166  
    99
    1010import pabloB.lexicalAnalyzer.LexicalType;
    11 import pabloB.inputHandler.TextLocation;
     11import pabloB.inputHandler.Locator;
    1212
    13 public class IntConstantToken extends TokenImp {
     13public class IntConstantToken extends TokenImp implements IntValuedToken {
    1414        protected int value;
    1515       
    16         protected IntConstantToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected IntConstantToken(LexicalType type, Locator location, String lexeme) {
    1717                super(type, location, lexeme);
    1818        }
     
    2424        }
    2525       
    26         public static IntConstantToken make(LexicalType type, TextLocation location, String lexeme) {
     26        public static IntConstantToken make(LexicalType type, Locator location, String lexeme) {
    2727                IntConstantToken result = new IntConstantToken(type, location, lexeme);
    2828                result.setValue(Integer.parseInt(lexeme));
     
    3535        }
    3636       
    37         public static Token makeArtifical(LexicalType type, TextLocation location, int value) {
     37        public static Token makeArtifical(LexicalType type, Locator location, int value) {
    3838                IntConstantToken result = new IntConstantToken(type, location, ""+value);
    3939                result.setValue(value);
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/LextantToken.java

    r2834 r3166  
    1010import pabloB.lexicalAnalyzer.LexicalType;
    1111import pabloB.lexicalAnalyzer.Lextant;
    12 import pabloB.inputHandler.TextLocation;
     12import pabloB.inputHandler.Locator;
    1313
    1414public final class LextantToken extends TokenImp {
     
    1616        private Lextant lextant;
    1717       
    18         private LextantToken(TextLocation location, String lexeme, Lextant lextant) {
     18        private LextantToken(Locator location, String lexeme, Lextant lextant) {
    1919                super(LexicalType.LEXTANT, location, lexeme);
    2020                this.lextant = lextant;
     
    3535        }
    3636       
    37         public static LextantToken make(TextLocation location, String lexeme, Lextant lextant) {
     37        public static LextantToken make(Locator location, String lexeme, Lextant lextant) {
    3838                return new LextantToken(location, lexeme, lextant);
    3939        }
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/NullToken.java

    r2834 r3166  
    1010import pabloB.lexicalAnalyzer.LexicalType;
    1111import pabloB.inputHandler.TextLocation;
     12import pabloB.inputHandler.Locator;
    1213
    1314public class NullToken extends TokenImp {
    1415
    15         protected NullToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected NullToken(LexicalType type, Locator location, String lexeme) {
    1617                super(type, location, lexeme);
    1718        }
     
    2223        }
    2324       
    24         public static NullToken make(LexicalType type, TextLocation location) {
     25        public static NullToken make(LexicalType type, Locator location) {
    2526                NullToken result = new NullToken(type, location, "");
    2627                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/StringConstantToken.java

    r2834 r3166  
    99
    1010import pabloB.lexicalAnalyzer.LexicalType;
    11 import pabloB.inputHandler.TextLocation;
     11import pabloB.inputHandler.Locator;
    1212
    1313public class StringConstantToken extends TokenImp {
    1414        protected String value;
    1515       
    16         protected StringConstantToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected StringConstantToken(LexicalType type, Locator location, String lexeme) {
    1717                super(type, location, lexeme);
    1818        }
     
    2424        }
    2525       
    26         public static StringConstantToken make(LexicalType type, TextLocation location, String lexeme) {
     26        public static StringConstantToken make(LexicalType type, Locator location, String lexeme) {
    2727                StringConstantToken result = new StringConstantToken(type, location, "\"" + lexeme + "\"");
    2828                result.setValue(lexeme);
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/Token.java

    r2834 r3166  
    1111import pabloB.lexicalAnalyzer.Lextant;
    1212import pabloB.inputHandler.TextLocation;
     13import pabloB.inputHandler.Locator;
    1314
    14 public interface Token {
     15public interface Token extends Locator {
    1516        public String getLexeme();
    1617        public String getPrintableLexeme();
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/TokenImp.java

    r2834 r3166  
    1111import pabloB.lexicalAnalyzer.Lextant;
    1212import pabloB.inputHandler.TextLocation;
     13import pabloB.inputHandler.Locator;
    1314
    1415public abstract class TokenImp implements Token {
     
    1718        private LexicalType lexicalType;
    1819
    19         protected TokenImp(LexicalType lexicalType, TextLocation location, String lexeme) {
     20        protected TokenImp(LexicalType lexicalType, Locator location, String lexeme) {
    2021                super();
    2122                this.lexicalType = lexicalType;
    22                 this.location = location;
     23                this.location = location.getLocation();
    2324                this.lexeme = lexeme;
    2425        }
  • proto/pabloj/branches/refactor-experimental/src/pabloB/tokens/WhitespaceToken.java

    r2834 r3166  
    99
    1010import pabloB.lexicalAnalyzer.LexicalType;
    11 import pabloB.inputHandler.TextLocation;
     11import pabloB.inputHandler.Locator;
    1212
    1313public class WhitespaceToken extends TokenImp {
    1414       
    15         protected WhitespaceToken(LexicalType type, TextLocation location, String lexeme) {
     15        protected WhitespaceToken(LexicalType type, Locator location, String lexeme) {
    1616                super(type, location, lexeme);
    1717        }
    1818       
    19         public static WhitespaceToken make(LexicalType type, TextLocation location, String lexeme) {
     19        public static WhitespaceToken make(LexicalType type, Locator location, String lexeme) {
    2020                WhitespaceToken result = new WhitespaceToken(type, location, lexeme);
    2121                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/ASTNode.java

    r3115 r3166  
    1414import pabloS.inputHandler.TextLocation;
    1515
     16import toolchain.pabloS.lang.type.Type;
    1617
    1718
     
    2728        boolean simplifiable;
    2829       
     30        private Type type = null;
    2931       
    3032       
     
    4648                this.simplifiable = node.simplifiable;
    4749               
     50                this.type = node.type;
    4851
    4952        }
     
    9093        }       
    9194
     95        public Type getType() {
     96                return type;
     97        }
     98        public void setType(Type _value_) {
     99                type = _value_;
     100        }
     101       
    92102
    93103
     
    213223        public String attributeString() {
    214224                String result = "";
     225                result += "type = " + type + ", ";
    215226
    216227                if(result.isEmpty()) return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/ASTTransformer.java

    r2984 r3166  
    1414        public ASTNode visit(AssignNode node);
    1515
    16         public ASTNode visit(AssignOperatorNode node);
    17 
    1816        public ASTNode visit(BinaryOperatorNode node);
    1917
     
    2523
    2624        public ASTNode visit(ErrorNode node);
    27 
    28         public ASTNode visit(FieldWidthNode node);
    2925
    3026        public ASTNode visit(FuncCallArgListNode node);
     
    4238        public ASTNode visit(IntegerConstantNode node);
    4339
    44         public ASTNode visit(LocalVarAssignOperatorNode node);
    45 
    4640        public ASTNode visit(LocalVarDeclNode node);
    4741
     
    4943
    5044        public ASTNode visit(ParameterNode node);
     45
     46        public ASTNode visit(PrimitiveTypeNode node);
    5147
    5248        public ASTNode visit(ProgramNode node);
     
    5854        public ASTNode visit(StringConstantNode node);
    5955
     56        public ASTNode visit(StructDeclNode node);
     57
    6058        public ASTNode visit(StructMemberNode node);
    6159
     
    6462        public ASTNode visit(StructTypeNode node);
    6563
    66         public ASTNode visit(TypeDeclNode node);
    67 
    6864        public ASTNode visit(UnaryOperatorNode node);
    69 
    70         public ASTNode visit(VoidTypeNode node);
    7165
    7266        public ASTNode visit(WhileStmtNode node);
     
    8478       
    8579                public ASTNode visit(AssignNode node) {
    86                         return defaultVisit(node);
    87                 }
    88 
    89                 public ASTNode visit(AssignOperatorNode node) {
    9080                        return defaultVisit(node);
    9181                }
     
    10898
    10999                public ASTNode visit(ErrorNode node) {
    110                         return defaultVisit(node);
    111                 }
    112 
    113                 public ASTNode visit(FieldWidthNode node) {
    114100                        return defaultVisit(node);
    115101                }
     
    143129                }
    144130
    145                 public ASTNode visit(LocalVarAssignOperatorNode node) {
    146                         return defaultVisit(node);
    147                 }
    148 
    149131                public ASTNode visit(LocalVarDeclNode node) {
    150132                        return defaultVisit(node);
     
    156138
    157139                public ASTNode visit(ParameterNode node) {
     140                        return defaultVisit(node);
     141                }
     142
     143                public ASTNode visit(PrimitiveTypeNode node) {
    158144                        return defaultVisit(node);
    159145                }
     
    175161                }
    176162
     163                public ASTNode visit(StructDeclNode node) {
     164                        return defaultVisit(node);
     165                }
     166
    177167                public ASTNode visit(StructMemberNode node) {
    178168                        return defaultVisit(node);
     
    187177                }
    188178
    189                 public ASTNode visit(TypeDeclNode node) {
    190                         return defaultVisit(node);
    191                 }
    192 
    193179                public ASTNode visit(UnaryOperatorNode node) {
    194                         return defaultVisit(node);
    195                 }
    196 
    197                 public ASTNode visit(VoidTypeNode node) {
    198180                        return defaultVisit(node);
    199181                }
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/ASTVisitor.java

    r3133 r3166  
    1717        public T visitLeave(AssignNode node, List<T> childResults);
    1818
    19         public void visitEnter(AssignOperatorNode node);
    20         public T visitLeave(AssignOperatorNode node, List<T> childResults);
    21 
    2219        public void visitEnter(BinaryOperatorNode node);
    2320        public T visitLeave(BinaryOperatorNode node, List<T> childResults);
     
    3532        public T visitLeave(ErrorNode node, List<T> childResults);
    3633
    37         public void visitEnter(FieldWidthNode node);
    38         public T visitLeave(FieldWidthNode node, List<T> childResults);
    39 
    4034        public void visitEnter(FuncCallArgListNode node);
    4135        public T visitLeave(FuncCallArgListNode node, List<T> childResults);
     
    5953        public T visitLeave(IntegerConstantNode node, List<T> childResults);
    6054
    61         public void visitEnter(LocalVarAssignOperatorNode node);
    62         public T visitLeave(LocalVarAssignOperatorNode node, List<T> childResults);
    63 
    6455        public void visitEnter(LocalVarDeclNode node);
    6556        public T visitLeave(LocalVarDeclNode node, List<T> childResults);
     
    7162        public T visitLeave(ParameterNode node, List<T> childResults);
    7263
     64        public void visitEnter(PrimitiveTypeNode node);
     65        public T visitLeave(PrimitiveTypeNode node, List<T> childResults);
     66
    7367        public void visitEnter(ProgramNode node);
    7468        public T visitLeave(ProgramNode node, List<T> childResults);
     
    8377        public T visitLeave(StringConstantNode node, List<T> childResults);
    8478
     79        public void visitEnter(StructDeclNode node);
     80        public T visitLeave(StructDeclNode node, List<T> childResults);
     81
    8582        public void visitEnter(StructMemberNode node);
    8683        public T visitLeave(StructMemberNode node, List<T> childResults);
     
    9289        public T visitLeave(StructTypeNode node, List<T> childResults);
    9390
    94         public void visitEnter(TypeDeclNode node);
    95         public T visitLeave(TypeDeclNode node, List<T> childResults);
    96 
    9791        public void visitEnter(UnaryOperatorNode node);
    9892        public T visitLeave(UnaryOperatorNode node, List<T> childResults);
    99 
    100         public void visitEnter(VoidTypeNode node);
    101         public T visitLeave(VoidTypeNode node, List<T> childResults);
    10293
    10394        public void visitEnter(WhileStmtNode node);
     
    135126                }
    136127
    137                 public void visitEnter(AssignOperatorNode node) {
    138                         defaultVisitEnter(node);
    139                 }
    140                 public T visitLeave(AssignOperatorNode node, List<T> childResults) {
    141                         return defaultVisitLeave(node, childResults);
    142                 }
    143 
    144128                public void visitEnter(BinaryOperatorNode node) {
    145129                        defaultVisitEnter(node);
     
    177161                }
    178162
    179                 public void visitEnter(FieldWidthNode node) {
    180                         defaultVisitEnter(node);
    181                 }
    182                 public T visitLeave(FieldWidthNode node, List<T> childResults) {
    183                         return defaultVisitLeave(node, childResults);
    184                 }
    185 
    186163                public void visitEnter(FuncCallArgListNode node) {
    187164                        defaultVisitEnter(node);
     
    233210                }
    234211
    235                 public void visitEnter(LocalVarAssignOperatorNode node) {
    236                         defaultVisitEnter(node);
    237                 }
    238                 public T visitLeave(LocalVarAssignOperatorNode node, List<T> childResults) {
    239                         return defaultVisitLeave(node, childResults);
    240                 }
    241 
    242212                public void visitEnter(LocalVarDeclNode node) {
    243213                        defaultVisitEnter(node);
     
    261231                }
    262232
     233                public void visitEnter(PrimitiveTypeNode node) {
     234                        defaultVisitEnter(node);
     235                }
     236                public T visitLeave(PrimitiveTypeNode node, List<T> childResults) {
     237                        return defaultVisitLeave(node, childResults);
     238                }
     239
    263240                public void visitEnter(ProgramNode node) {
    264241                        defaultVisitEnter(node);
     
    289266                }
    290267
     268                public void visitEnter(StructDeclNode node) {
     269                        defaultVisitEnter(node);
     270                }
     271                public T visitLeave(StructDeclNode node, List<T> childResults) {
     272                        return defaultVisitLeave(node, childResults);
     273                }
     274
    291275                public void visitEnter(StructMemberNode node) {
    292276                        defaultVisitEnter(node);
     
    310294                }
    311295
    312                 public void visitEnter(TypeDeclNode node) {
    313                         defaultVisitEnter(node);
    314                 }
    315                 public T visitLeave(TypeDeclNode node, List<T> childResults) {
    316                         return defaultVisitLeave(node, childResults);
    317                 }
    318 
    319296                public void visitEnter(UnaryOperatorNode node) {
    320297                        defaultVisitEnter(node);
    321298                }
    322299                public T visitLeave(UnaryOperatorNode node, List<T> childResults) {
    323                         return defaultVisitLeave(node, childResults);
    324                 }
    325 
    326                 public void visitEnter(VoidTypeNode node) {
    327                         defaultVisitEnter(node);
    328                 }
    329                 public T visitLeave(VoidTypeNode node, List<T> childResults) {
    330300                        return defaultVisitLeave(node, childResults);
    331301                }
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/SimpleVisitor.java

    r2984 r3166  
    1515        public void visit(AssignNode node);
    1616
    17         public void visit(AssignOperatorNode node);
    18 
    1917        public void visit(BinaryOperatorNode node);
    2018
     
    2624
    2725        public void visit(ErrorNode node);
    28 
    29         public void visit(FieldWidthNode node);
    3026
    3127        public void visit(FuncCallArgListNode node);
     
    4339        public void visit(IntegerConstantNode node);
    4440
    45         public void visit(LocalVarAssignOperatorNode node);
    46 
    4741        public void visit(LocalVarDeclNode node);
    4842
     
    5044
    5145        public void visit(ParameterNode node);
     46
     47        public void visit(PrimitiveTypeNode node);
    5248
    5349        public void visit(ProgramNode node);
     
    5955        public void visit(StringConstantNode node);
    6056
     57        public void visit(StructDeclNode node);
     58
    6159        public void visit(StructMemberNode node);
    6260
     
    6563        public void visit(StructTypeNode node);
    6664
    67         public void visit(TypeDeclNode node);
    68 
    6965        public void visit(UnaryOperatorNode node);
    70 
    71         public void visit(VoidTypeNode node);
    7266
    7367        public void visit(WhileStmtNode node);
     
    8579       
    8680                public void visit(AssignNode node) {
    87                         defaultVisit(node);
    88                 }
    89 
    90                 public void visit(AssignOperatorNode node) {
    9181                        defaultVisit(node);
    9282                }
     
    10999
    110100                public void visit(ErrorNode node) {
    111                         defaultVisit(node);
    112                 }
    113 
    114                 public void visit(FieldWidthNode node) {
    115101                        defaultVisit(node);
    116102                }
     
    144130                }
    145131
    146                 public void visit(LocalVarAssignOperatorNode node) {
    147                         defaultVisit(node);
    148                 }
    149 
    150132                public void visit(LocalVarDeclNode node) {
    151133                        defaultVisit(node);
     
    157139
    158140                public void visit(ParameterNode node) {
     141                        defaultVisit(node);
     142                }
     143
     144                public void visit(PrimitiveTypeNode node) {
    159145                        defaultVisit(node);
    160146                }
     
    176162                }
    177163
     164                public void visit(StructDeclNode node) {
     165                        defaultVisit(node);
     166                }
     167
    178168                public void visit(StructMemberNode node) {
    179169                        defaultVisit(node);
     
    188178                }
    189179
    190                 public void visit(TypeDeclNode node) {
    191                         defaultVisit(node);
    192                 }
    193 
    194180                public void visit(UnaryOperatorNode node) {
    195                         defaultVisit(node);
    196                 }
    197 
    198                 public void visit(VoidTypeNode node) {
    199181                        defaultVisit(node);
    200182                }
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/StreamTypeNode.java

    r3004 r3166  
    1313
    1414public class StreamTypeNode extends ASTNode  {
     15        private int fieldWidth = 1;
    1516
    1617
     
    2021        public StreamTypeNode(StreamTypeNode node) {
    2122                super(node);
     23                this.fieldWidth = node.fieldWidth;
    2224
    2325        }
     
    3840        // attribute accessors
    3941
     42        public int getFieldWidth() {
     43                return fieldWidth;
     44        }
     45        public void setFieldWidth(int _value_) {
     46                fieldWidth = _value_;
     47        }
     48       
    4049
    4150       
     
    4958                        result += ", ";
    5059                }
     60                result += "fieldWidth = " + fieldWidth + ", ";
    5161
    5262                if(result.isEmpty()) return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/VoidVisitor.java

    r2984 r3166  
    1515        public void visitLeave(AssignNode node);
    1616
    17         public void visitEnter(AssignOperatorNode node);
    18         public void visitLeave(AssignOperatorNode node);
    19 
    2017        public void visitEnter(BinaryOperatorNode node);
    2118        public void visitLeave(BinaryOperatorNode node);
     
    3330        public void visitLeave(ErrorNode node);
    3431
    35         public void visitEnter(FieldWidthNode node);
    36         public void visitLeave(FieldWidthNode node);
    37 
    3832        public void visitEnter(FuncCallArgListNode node);
    3933        public void visitLeave(FuncCallArgListNode node);
     
    5751        public void visitLeave(IntegerConstantNode node);
    5852
    59         public void visitEnter(LocalVarAssignOperatorNode node);
    60         public void visitLeave(LocalVarAssignOperatorNode node);
    61 
    6253        public void visitEnter(LocalVarDeclNode node);
    6354        public void visitLeave(LocalVarDeclNode node);
     
    6960        public void visitLeave(ParameterNode node);
    7061
     62        public void visitEnter(PrimitiveTypeNode node);
     63        public void visitLeave(PrimitiveTypeNode node);
     64
    7165        public void visitEnter(ProgramNode node);
    7266        public void visitLeave(ProgramNode node);
     
    8175        public void visitLeave(StringConstantNode node);
    8276
     77        public void visitEnter(StructDeclNode node);
     78        public void visitLeave(StructDeclNode node);
     79
    8380        public void visitEnter(StructMemberNode node);
    8481        public void visitLeave(StructMemberNode node);
     
    9087        public void visitLeave(StructTypeNode node);
    9188
    92         public void visitEnter(TypeDeclNode node);
    93         public void visitLeave(TypeDeclNode node);
    94 
    9589        public void visitEnter(UnaryOperatorNode node);
    9690        public void visitLeave(UnaryOperatorNode node);
    97 
    98         public void visitEnter(VoidTypeNode node);
    99         public void visitLeave(VoidTypeNode node);
    10091
    10192        public void visitEnter(WhileStmtNode node);
     
    132123                }
    133124
    134                 public void visitEnter(AssignOperatorNode node) {
    135                         defaultVisitEnter(node);
    136                 }
    137                 public void visitLeave(AssignOperatorNode node) {
    138                         defaultVisitLeave(node);
    139                 }
    140 
    141125                public void visitEnter(BinaryOperatorNode node) {
    142126                        defaultVisitEnter(node);
     
    174158                }
    175159
    176                 public void visitEnter(FieldWidthNode node) {
    177                         defaultVisitEnter(node);
    178                 }
    179                 public void visitLeave(FieldWidthNode node) {
    180                         defaultVisitLeave(node);
    181                 }
    182 
    183160                public void visitEnter(FuncCallArgListNode node) {
    184161                        defaultVisitEnter(node);
     
    230207                }
    231208
    232                 public void visitEnter(LocalVarAssignOperatorNode node) {
    233                         defaultVisitEnter(node);
    234                 }
    235                 public void visitLeave(LocalVarAssignOperatorNode node) {
    236                         defaultVisitLeave(node);
    237                 }
    238 
    239209                public void visitEnter(LocalVarDeclNode node) {
    240210                        defaultVisitEnter(node);
     
    258228                }
    259229
     230                public void visitEnter(PrimitiveTypeNode node) {
     231                        defaultVisitEnter(node);
     232                }
     233                public void visitLeave(PrimitiveTypeNode node) {
     234                        defaultVisitLeave(node);
     235                }
     236
    260237                public void visitEnter(ProgramNode node) {
    261238                        defaultVisitEnter(node);
     
    286263                }
    287264
     265                public void visitEnter(StructDeclNode node) {
     266                        defaultVisitEnter(node);
     267                }
     268                public void visitLeave(StructDeclNode node) {
     269                        defaultVisitLeave(node);
     270                }
     271
    288272                public void visitEnter(StructMemberNode node) {
    289273                        defaultVisitEnter(node);
     
    307291                }
    308292
    309                 public void visitEnter(TypeDeclNode node) {
    310                         defaultVisitEnter(node);
    311                 }
    312                 public void visitLeave(TypeDeclNode node) {
    313                         defaultVisitLeave(node);
    314                 }
    315 
    316293                public void visitEnter(UnaryOperatorNode node) {
    317294                        defaultVisitEnter(node);
    318295                }
    319296                public void visitLeave(UnaryOperatorNode node) {
    320                         defaultVisitLeave(node);
    321                 }
    322 
    323                 public void visitEnter(VoidTypeNode node) {
    324                         defaultVisitEnter(node);
    325                 }
    326                 public void visitLeave(VoidTypeNode node) {
    327297                        defaultVisitLeave(node);
    328298                }
  • proto/pabloj/branches/refactor-experimental/src/pabloS/lexicalAnalyzer/Lextant.java

    r2981 r3166  
    2020        TERMINATOR(";", "main"),
    2121        DOT(".", "main"),
     22        MULTIPLY("*", "main"),
    2223        LROUND("(", "main"),
    2324        OR("|", "main"),
     25        ADD("+", "main"),
     26        ADD_ASSIGN("+=", "main"),
    2427        AND_ASSIGN("&=", "main"),
    2528        NOT("~", "main"),
     29        MULTIPLY_ASSIGN("*=", "main"),
    2630        LANGLE("<", "main"),
    2731        VOID("void", "main"),
     32        SUBTRACT("-", "main"),
    2833        ASSIGN("=", "main"),
    2934        XOR("^", "main"),
     
    3136        STRUCT("struct", "main"),
    3237        OR_ASSIGN("|=", "main"),
     38        INT("int", "main"),
    3339        IF("if", "main"),
    3440        WHILE("while", "main"),
    3541        RETURN("return", "main"),
     42        DIVIDE_ASSIGN("/=", "main"),
    3643        ELSE("else", "main"),
    3744        FUNCTION("function", "main"),
     
    3946        AND("&", "main"),
    4047        RROUND(")", "main"),
     48        DIVIDE("/", "main"),
    4149        RCURLY("}", "main"),
    4250        RANGLE(">", "main"),
    43         VAR("var", "main"),
     51        SUBTRACT_ASSIGN("-=", "main"),
    4452        COMMA(",", "main"),
    4553        STREAM("stream", "main"),
  • proto/pabloj/branches/refactor-experimental/src/pabloS/parser/Parser.java

    r3134 r3166  
    2020import pabloS.lexicalAnalyzer.Lextant;
    2121
     22import toolchain.pabloS.lang.type.Type;
     23import toolchain.pabloS.lang.type.PrimitiveType;
     24import toolchain.pabloS.lang.type.StreamType;
     25
    2226
    2327@SuppressWarnings("unused")
     
    4852                result.setProductionTag(1);
    4953                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    50                 while( nowReading.isLextant(Lextant.FUNCTION, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    51                         if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     54                while( nowReading.isLextant(Lextant.FUNCTION, Lextant.STRUCT) ) {
     55                        if( nowReading.isLextant(Lextant.STRUCT) ) {
    5256                                {
    53                                         ASTNode child = parseTypeDecl();
     57                                        ASTNode child = parseStructDecl();
    5458                                        result.appendChild(child);
    5559                                        allChildren.add(child);
     
    6468                        }
    6569                        else {
    66                                 return syntaxErrorNode("[FUNCTION¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    67                         }
    68                 }
    69                 if(allowCompression) {
    70                         return result;
    71                 }
    72                 return result;
    73         }
    74          
    75         public ASTNode parseTypeDecl() {
    76                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    77                         return syntaxErrorNode("typeDecl² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    78                 }
    79        
    80                 boolean allowCompression = true;
    81                 ASTNode result = new TypeDeclNode(nowReading);
     70                                return syntaxErrorNode("[FUNCTION¹, STRUCT¹]");
     71                        }
     72                }
     73                if(allowCompression) {
     74                        return result;
     75                }
     76                return result;
     77        }
     78         
     79        public ASTNode parseStructDecl() {
     80                if( !(nowReading.isLextant(Lextant.STRUCT)) ) {
     81                        return syntaxErrorNode("structDecl² [STRUCT¹]");
     82                }
     83       
     84                boolean allowCompression = true;
     85                ASTNode result = new StructDeclNode(nowReading);
    8286                result.setProductionTag(2);
    8387                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    84                 {
    85                         ASTNode child = parseType();
    86                         result.appendChild(child);
    87                         allChildren.add(child);
    88                 }
    89                 expect(Lextant.TERMINATOR);
    90                 if(allowCompression) {
    91                         return result;
     88                expect(Lextant.STRUCT);
     89                {
     90                        ASTNode child = parseStructName();
     91                        result.appendChild(child);
     92                        allChildren.add(child);
     93                }
     94                {
     95                        ASTNode child = parseStructTypeBody();
     96                        result.appendChild(child);
     97                        allChildren.add(child);
     98                }
     99                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
     100                        expect(Lextant.TERMINATOR);
     101                }
     102                if(allowCompression) {
     103                        return result;
     104                }
     105                return result;
     106        }
     107         
     108        public ASTNode parseStructTypeBody() {
     109                if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
     110                        return syntaxErrorNode("structTypeBody² [LCURLY¹]");
     111                }
     112       
     113                boolean allowCompression = true;
     114                ASTNode result = new StructTypeBodyNode(nowReading);
     115                result.setProductionTag(3);
     116                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     117                expect(Lextant.LCURLY);
     118                do {
     119                        {
     120                                ASTNode child = parseStructMember();
     121                                result.appendChild(child);
     122                                allChildren.add(child);
     123                        }
     124                        expect(Lextant.TERMINATOR);
     125                } while( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT) );
     126                expect(Lextant.RCURLY);
     127                if(allowCompression) {
     128                        return result;
     129                }
     130                return result;
     131        }
     132         
     133        public ASTNode parseStructMember() {
     134                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT)) ) {
     135                        return syntaxErrorNode("structMember² [STREAM¹, STRUCT¹]");
     136                }
     137       
     138                boolean allowCompression = true;
     139                ASTNode result = new StructMemberNode(nowReading);
     140                result.setProductionTag(4);
     141                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     142                {
     143                        ASTNode child = parseStructMemberType();
     144                        result.appendChild(child);
     145                        allChildren.add(child);
     146                }
     147                {
     148                        ASTNode child = parseStructMemberName();
     149                        result.appendChild(child);
     150                        allChildren.add(child);
     151                }
     152                if(allowCompression) {
     153                        return result;
     154                }
     155                return result;
     156        }
     157         
     158        public ASTNode parseStructMemberType() {
     159                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT)) ) {
     160                        return syntaxErrorNode("structMemberType² [STREAM¹, STRUCT¹]");
     161                }
     162       
     163                boolean allowCompression = true;
     164                ASTNode result = new ASTNode(nowReading);
     165                result.setProductionTag(5);
     166                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     167                if( nowReading.isLextant(Lextant.STRUCT) ) {
     168                        {
     169                                ASTNode child = parseStructType();
     170                                result.appendChild(child);
     171                                allChildren.add(child);
     172