Changeset 2624


Ignore:
Timestamp:
Nov 8, 2012, 7:15:21 PM (6 years ago)
Author:
ksherdy
Message:

More test updates.

Location:
proto/pablo/input
Files:
14 edited
3 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/scatter/pablo.scatter

    r2622 r2624  
    2929       
    3030        IF,
    31 //      ELSE,
     31        ELSE,
    3232        WHILE,
    3333        RETURN,
     
    115115       
    116116        functionInvocationRest                          -> LROUND^ functionInvocationArgumentList RROUND ;
    117        
    118 //      functionInvocationRest                          -> LROUND^ (expression (COMMA expression)*)? RROUND ;
    119117
    120118        functionInvocationArgumentList          -> (expression (COMMA expression)*)? ; 
     
    124122        assignmentRest                                          -> assignmentOperator^! expression ;                           
    125123                                       
    126         ifStatement                                                     -> IF LROUND expression RROUND blockStatement ; // (ELSE blockStatement)?                       
     124        ifStatement                                                     -> IF LROUND expression RROUND blockStatement (ELSE blockStatement)? ;                 
    127125                                                       
    128126        whileStatement                                          -> WHILE LROUND expression RROUND blockStatement ;
  • proto/pablo/input/test/pablo/all/all.pablo

    r2377 r2624  
     1
     2
     3
    14struct BasisBits {
    25        stream<1> b1;
     
    58        stream<1> b4;
    69};
     10
    711struct BasisBits {
    812        stream b1;
     
    1014        stream b3;
    1115        stream b4;
    12 };
     16};
     17
     18function void Foo() {
     19
     20}
    1321function void AssignmentExpressions() {
    1422        temp4 = temp;
     
    1624        temp4 |= temp1 ^ temp2;
    1725        temp4 ^= temp1 & temp2;
    18         temp4 ~= temp1 ^ temp2 | temp3;
     26//      temp4 ~= temp1 ^ temp2 | temp3;
    1927};function void BasicExpressions() {
    2028
     
    2937        temp4 = temp1 & (temp2 | temp3);
    3038        temp4 = (temp1 | temp2) & temp3;
    31         temp4 = ~temp;
     39//      temp4 = ~temp;
    3240       
    3341};
    3442
     43
     44
     45
    3546function void Assignments() {
    36         var stream s;
     47//      var stream s;
    3748        s = 0;
    3849        s &= 0;
    3950        s |= 0;
    40         s ~= 0;
     51//      s ~= 0;
    4152        s ^= 0;
    42 };function struct A FunctionExpressions() {
    43          a.b.Advance();
    4453};
     54
     55function struct A FunctionExpressions() {
     56         var stream<1> a = b.Advance();
     57};
     58
    4559function void RecordExpressions() {
    4660
     
    5266        temp1.temp2.temp3 = temp4;
    5367               
    54 };function void Function() {
    55 var stream cursor = pablo.ScanToFirst(lex.opener);
    56 }function void localDecl() {
     68};function void localDecl() {
    5769        var stream A;
    58         var stream A=0;
    59         var stream a=0,b=0,c=0;
    60 }function void localDecl() {
     70//      var stream A=0;
     71//      var stream a=0,b=0,c=0; // TODO - add test cases for variable decls list
     72}
     73
     74function void localDecl() {
    6175
    6276var struct BasisBits {
     
    6579stream<1> b3;
    6680stream<1> b4;
    67 } A,B,C;
     81} A;
    6882
    69 };function void Assignments() {
     83};
     84
     85
     86function void Assignments() {
    7087        var stream s = 4;
    7188        var stream s &= 4;
    7289        var stream s |= 4;
    73         var stream s ~= 4;
     90//      var stream s ~= 4;
    7491        var stream s ^= 4;
    75 };function void localDecl() {
     92};
     93
     94
     95function void localDecl() {
    7696
    7797        var struct BasisBits {
     
    80100        stream b3;
    81101        stream b4;
    82         } A,B ;
     102        } A;
    83103
    84 } function void Function() {   
     104}
     105
     106
     107function void Function() {     
    85108       
    86109        if(cursor & a) {
     
    91114       
    92115};
     116
     117
    93118function void Function() {     
    94119       
     
    105130       
    106131};
     132
     133
    107134function void Function() {             
    108135        if(cursor) {
     
    119146       
    120147};
    121 /*
    122         Block comment.
    123 */
    124 
    125 // EOL terminated comment.
    126 
    127 // Another EOL terminated comment.
    128 
    129148function struct Lex ClassifyBytes(struct BasisBit basis) {};
    130149function stream Function(stream a, stream b, stream c) {};
    131 function void Lex() {};
     150struct B
     151{
     152        stream a;
     153        stream a;
     154        stream a;
     155        stream a;
     156};
     157
     158function struct B Foo() { }
    132159struct Lex {
    133160        stream LAngle;
     
    144171stream b3;
    145172stream b4;
    146 } BasisBitsAlias;# Demo - Hand ported Python pablo code (parses)
    147 #
    148 # Removed '-' operators.
    149 # Added statement terminators as needed ';'
     173} BasisBitsAlias;
    150174
    151 struct Basis_bits{     
    152         stream bit_0;
    153         stream bit_1;
    154         stream bit_2;
    155         stream bit_3;
    156         stream bit_4;
    157         stream bit_5;
    158         stream bit_6;
    159         stream bit_7;
    160 };
    161 
    162 struct u8 {
    163   stream unibyte;
    164   stream prefix;
    165   stream prefix2;
    166   stream prefix3;
    167   stream prefix4;
    168   stream suffix;
    169   stream badprefix;
    170   stream xE0;
    171   stream xED;
    172   stream xF0;
    173   stream xF4;
    174   stream xA0_xBF;
    175   stream x80_x9F;
    176   stream x90_xBF;
    177   stream x80_x8F;
    178   stream xEF;
    179   stream xBF;
    180   stream xBE;
    181   stream scope22;
    182   stream scope32;
    183   stream scope33;
    184   stream scope42;
    185   stream scope43;
    186   stream scope44;
    187   stream xE0_scope;
    188   stream xED_scope;
    189   stream xF0_scope;
    190   stream xF4_scope;
    191   stream xEF_scope;
    192 };
    193 
    194 struct Lex {
    195         stream CR;
    196         stream LF;
    197         stream HT;
    198         stream SP;
    199         stream CRLF;
    200         stream RefStart;
    201         stream Semicolon; 
    202         stream Colon;
    203         stream LAngle;
    204         stream RAngle;
    205         stream LBracket;
    206         stream RBracket;
    207         stream Exclam;
    208         stream QMark;
    209         stream Hyphen;
    210         stream Equals;
    211         stream SQuote;
    212         stream DQuote;
    213         stream Slash;
    214         stream Hash;
    215         stream x;
    216         stream ASCII_name_start;
    217         stream ASCII_name_char;
    218         stream NameScan;
    219         stream Digit;
    220         stream Hex;
    221         stream WS;
    222 };
    223 
    224 struct Marker {
    225         stream LAngle_scope;
    226         stream Ref_opener;
    227         stream CD_closer;
    228 };
    229 
    230 struct CtCDPI_Callouts{
    231         stream Ct_starts;
    232         stream Ct_ends;
    233         stream CD_starts;
    234         stream CD_ends;
    235         stream PI_starts;
    236         stream PI_name_starts;
    237         stream PI_name_ends;
    238         stream PI_ends;
    239 };
    240 
    241 struct Ref_Callouts{
    242         stream GenRef_starts;
    243         stream GenRef_ends;
    244         stream DecRef_starts;
    245         stream DecRef_ends;
    246         stream HexRef_starts;
    247         stream HexRef_ends;
    248 };
    249 
    250 struct Tag_Callouts{
    251         stream ElemName_starts;
    252         stream ElemName_ends;
    253         stream AttName_starts;
    254         stream AttName_ends;
    255         stream AttVal_starts;
    256         stream AttVal_ends;
    257         stream AttVal_spans;
    258         stream EmptyTag_marks;
    259         stream EndTag_marks;
    260 };
    261        
    262 struct Check_streams{
    263         stream misc_mask;
    264         stream non_ascii_name_starts;
    265         stream non_ascii_names;
    266         stream tag_marks;
    267         stream name_follows;
    268         stream att_refs;
    269 };
    270 
    271 function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) { 
    272         temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    273         temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
    274         temp3 = (temp2 &~ temp1);
    275         temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
    276         temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
    277         temp6 = (temp4 & temp5);
    278         lex.RefStart = (temp3 & temp6);
    279         temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
    280         temp8 = (temp7 &~ temp1);
    281         temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
    282         temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
    283         temp11 = (temp9 & temp10);
    284         lex.Semicolon = (temp8 & temp11);
    285         temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
    286         temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
    287         temp14 = (temp12 &~ temp13);
    288         lex.LAngle = (temp8 & temp14);
    289         temp15 = (temp12 & temp5);
    290         lex.RAngle = (temp8 & temp15);
    291         temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
    292         temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
    293         temp18 = (temp16 & temp17);
    294         lex.LBracket = (temp18 & temp11);
    295         temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
    296         temp20 = (temp12 & temp19);
    297         lex.RBracket = (temp18 & temp20);
    298         temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
    299         temp22 = (temp19 &~ temp21);
    300         lex.Exclam = (temp3 & temp22);
    301         temp23 = (temp12 & temp10);
    302         lex.QMark = (temp8 & temp23);
    303         lex.Hyphen = (temp3 & temp20);
    304         lex.Equals = (temp8 & temp20);
    305         temp24 = (temp4 & temp10);
    306         lex.SQuote = (temp3 & temp24);
    307         temp25 = (temp5 &~ temp21);
    308         lex.DQuote = (temp3 & temp25);
    309         lex.Slash = (temp3 & temp23);
    310         temp26 = (temp10 &~ temp21);
    311         lex.Hash = (temp3 & temp26);
    312         temp27 = (temp16 & temp7);
    313         temp28 = (temp9 &~ temp13);
    314         lex.x = (temp27 & temp28);
    315         temp29 = (temp9 & temp5);
    316         lex.Colon = (temp8 & temp29);
    317         temp30 = (temp18 & temp23);
    318         temp31 = (temp30 | lex.Colon);
    319         temp32 = (temp16 &~ basis_bits.bit_2);
    320         temp33 = (basis_bits.bit_5 | temp10);
    321         temp34 = (basis_bits.bit_4 & temp33);
    322         temp35 = (~temp34);
    323         temp36 = (temp21 | temp13);
    324         temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
    325         temp38 = (temp32 & temp37);
    326         temp39 = (temp31 | temp38);
    327         temp40 = (temp16 & basis_bits.bit_2);
    328         temp41 = (temp40 & temp37);
    329         lex.ASCII_name_start = (temp39 | temp41);
    330         temp42 = (temp30 | lex.Hyphen);
    331         temp43 = (temp3 & temp15);
    332         temp44 = (temp42 | temp43);
    333         temp45 = (temp8 &~ temp34);
    334         temp46 = (temp44 | temp45);
    335         temp47 = (temp46 | temp38);
    336         lex.ASCII_name_char = (temp47 | temp41);
    337         lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
    338         temp48 = (temp1 | basis_bits.bit_2);
    339         x00_x1F = (~temp48);
    340         temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
    341         temp50 = (temp1 | temp49);
    342         lex.CR = (temp20 &~ temp50);
    343         lex.LF = (temp29 &~ temp50);
    344         temp51 = (temp9 & temp19);
    345         lex.HT = (temp51 &~ temp50);
    346         lex.SP = (temp3 &~ temp36);
    347         temp52 = (temp20 | temp29);
    348         temp53 = (temp52 | temp51);
    349         temp54 = (temp53 &~ temp50);
    350         lex.WS = (temp54 | lex.SP);
    351         temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
    352         temp56 = (basis_bits.bit_4 & temp55);
    353         lex.Digit = (temp8 &~ temp56);
    354         temp57 = (temp16 &~ temp49);
    355         temp58 = (temp57 &~ basis_bits.bit_4);
    356         temp59 = (~temp10);
    357         temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
    358         temp61 = (temp58 & temp60);
    359         temp62 = (lex.Digit | temp61);
    360         temp63 = (temp16 & temp2);
    361         temp64 = (temp63 &~ basis_bits.bit_4);
    362         temp65 = (temp64 & temp60);
    363         lex.Hex = (temp62 | temp65);
    364         lex_error = x00_x1F &~ lex.WS;
    365         pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    366                
    367        
    368         ### Validate_utf8(basis_bits, u8):
    369         u8.unibyte = (~basis_bits.bit_0);
    370         u8.suffix = 0;
    371         u8_error = 0;
    372         u8_FFFE_FFFF = 0;
    373         u8anyscope = 0; #local
    374         if (basis_bits.bit_0) {
    375                 u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
    376                 u8.prefix2 = (u8.prefix &~ basis_bits.bit_2);
    377                 u8.prefix3 = (u8.prefix & temp2);
    378                 u8.prefix4 = (u8.prefix & temp7);
    379                 u8.suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
    380                 temp66 = (u8.prefix &~ temp49);
    381                 temp67 = (temp21 | basis_bits.bit_6);
    382                 temp68 = (temp66 &~ temp67);
    383                 temp69 = (basis_bits.bit_5 & temp13);
    384                 temp70 = (basis_bits.bit_4 | temp69);
    385                 temp71 = (u8.prefix4 & temp70);
    386                 u8.badprefix = (temp68 | temp71);
    387                 u8_error = u8.badprefix;
    388                 u8.scope22 = pablo.Advance(u8.prefix2);
    389                 u8anyscope = u8.scope22;
    390                 if (u8.prefix3 | u8.prefix4) {
    391                         xE0 = (u8.prefix3 &~ temp36);
    392                         xED = (u8.prefix3 & temp20);
    393                         xF0 = (u8.prefix4 &~ temp36);
    394                         temp72 = (temp4 &~ temp13);
    395                         xF4 = (u8.prefix4 & temp72);
    396                         u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
    397                         u8.x80_x9F = (u8.suffix &~ basis_bits.bit_2);
    398                         u8.x90_xBF = (u8.suffix & temp49);
    399                         u8.x80_x8F = (u8.suffix &~ temp49);
    400                         xEF = (u8.prefix3 & temp23);
    401                         temp73 = (u8.suffix & temp7);
    402                         u8.xBF = (temp73 & temp23);
    403                         u8.xBE = (temp73 & temp15);
    404 #
    405 
    406 #                       scope3_32 = pablo.Advance32(u8.prefix3)
    407 #                       scope4_32 = pablo.Advance32(u8.prefix4)
    408 #                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
    409 #                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
    410 #                       u8.scope42 = interpose32(u8.prefix4, scope4_32, 1)
    411 #                       u8.scope43 = interpose32(u8.prefix4, scope4_32, 2)
    412 #                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
    413 #
    414                         u8.scope32 = pablo.Advance(u8.prefix3);
    415                         u8.scope33 = pablo.Advance(u8.scope32);
    416                         u8.scope42 = pablo.Advance(u8.prefix4);
    417                         u8.scope43 = pablo.Advance(u8.scope42);
    418                         u8.scope44 = pablo.Advance(u8.scope43);
    419 #
    420 #                       u8.xE0_scope = pablo.Advance(xE0);
    421 #                       u8.xED_scope = pablo.Advance(xED);
    422 #                       u8.xF0_scope = pablo.Advance(xF0);
    423 #                       u8.xF4_scope = pablo.Advance(xF4);
    424                         E0_F0_scope = pablo.Advance(xE0 | xF0);
    425                         ED_F4_scope = pablo.Advance(xED | xF4);
    426                         u8.xE0_scope = u8.scope32 & E0_F0_scope;
    427                         u8.xED_scope = u8.scope32 & ED_F4_scope;
    428                         u8.xF0_scope = u8.scope42 & E0_F0_scope;
    429                         u8.xF4_scope = u8.scope42 & ED_F4_scope;
    430                         u8.xEF_scope = pablo.Advance(xEF);
    431 
    432                         u8lastscope = u8.scope22 | u8.scope33 | u8.scope44;
    433                         u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43;
    434                
    435                         u8error1 = u8.xE0_scope & u8.x80_x9F;
    436                         u8error2 = u8.xED_scope & u8.xA0_xBF;
    437                         u8error3 = u8.xF0_scope & u8.x80_x8F;
    438                         u8error4 = u8.xF4_scope & u8.x90_xBF;
    439        
    440                         u8_error |= u8error1 | u8error2 | u8error3 | u8error4;
    441 
    442                         EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF);
    443 
    444                         u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
    445                 }               
    446                 u8mismatch = u8anyscope ^ u8.suffix;
    447                 pablo.assert_0(u8_error | u8mismatch | u8_FFFE_FFFF, "UTF-8 error found");
    448         }
    449 };
    450 
    451 function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    452         ctCDPI_Callouts.Ct_starts = 0;
    453         ctCDPI_Callouts.Ct_ends = 0;
    454         ctCDPI_Callouts.CD_starts = 0;
    455         ctCDPI_Callouts.CD_ends = 0;
    456         ctCDPI_Callouts.PI_starts = 0;
    457         ctCDPI_Callouts.PI_name_starts = 0;
    458         ctCDPI_Callouts.PI_name_ends = 0;
    459         ctCDPI_Callouts.PI_ends = 0;
    460         CtCDPI_starts = 0;
    461         CtCDPI_ends = 0;
    462         ctCDPI_mask = 0;
    463 
    464         v = lex.LAngle | lex.Hyphen;
    465         w = lex.Hyphen | lex.QMark;
    466         v1 = pablo.Advance(v,1);
    467         w1 = pablo.Advance(w,1);
    468        
    469         LAngle_scope = v1 &~ w1;  #pablo.Advance(lex.LAngle);
    470         PI_opener = LAngle_scope & lex.QMark;
    471         CtCD_opener= LAngle_scope & lex.Exclam;
    472         CtCDPI_opener = PI_opener | CtCD_opener;
    473 
    474         #DoubleHyphen = 0;
    475         CD_closer = 0;
    476         #PI_closer = 0;
    477        
    478         #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
    479         DoubleHyphen = v1 & w1 & lex.Hyphen;
    480         if (lex.RBracket) {
    481                 DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket;
    482                 CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle;
    483         }
    484         #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
    485         PI_closer = w1 & ~v1 & lex.RAngle;
    486 
    487         #
    488         # Initiate the scan
    489         CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
    490         while (CtCDPI_Cursor) {
    491                 CtCDPI_starts |= CtCDPI_Cursor;
    492                 PI_Cursor = CtCDPI_Cursor & PI_opener;
    493                 CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor);
    494                 CD_Cursor = CD_Ct_Cursor & lex.LBracket;
    495                 Ct_Cursor = CD_Ct_Cursor & lex.Hyphen ;
    496                 # PI processing
    497                 if (PI_Cursor) {
    498                         ctCDPI_Callouts.PI_starts |= PI_Cursor;
    499                         PI_Cursor = pablo.Advance(PI_Cursor);
    500                         ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
    501                         PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
    502                         PI_error = PI_Cursor & PI_name_end;
    503                         PI_noWS = PI_name_end & ~ lex.WS;
    504                         PI_error |= PI_noWS &~ lex.QMark | pablo.Advance(PI_noWS) &~ PI_closer;
    505                         pablo.assert_0(PI_error, "Error in PI syntax");
    506                         ctCDPI_Callouts.PI_name_ends |= PI_name_end;
    507                         PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
    508                         ctCDPI_Callouts.PI_ends |= PI_Cursor;
    509                         CtCDPI_ends |= PI_Cursor;
    510                 }
    511                 # CDATA section processing
    512                 if (CD_Cursor) {
    513                         ctCDPI_Callouts.CD_starts |= CD_Cursor;
    514                         CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
    515                         ctCDPI_Callouts.CD_ends |= CD_Cursor;
    516                         CtCDPI_ends |= CD_Cursor;
    517                 }
    518                 # Comment processing
    519                 if (Ct_Cursor) {
    520                         ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
    521                         Ct_Cursor = pablo.Advance(Ct_Cursor); 
    522                         Ct_error = Ct_Cursor & ~ lex.Hyphen;
    523                         # Advance twice past <!--, so that we don't treat <!---
    524                         # as being a terminated comment.
    525                         Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
    526                         Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
    527                         pablo.assert_0(Ct_error | Ct_Cursor & ~ lex.RAngle, "Error in comment syntax");
    528                         ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
    529                         CtCDPI_ends |= Ct_Cursor;
    530                 }
    531                 # Common processing
    532                 CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor;
    533                 ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
    534 # '-' Not Supported.           
    535 #               ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends;
    536                 # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    537                 pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
    538                 CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)      ;
    539         }
    540 # '-' Not Supported.           
    541 #       check_streams.misc_mask = (lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends)  -(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
    542 #  Following is slow
    543         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;
    544 
    545 
    546         # Identify the remaining significant markers for XML processing.
    547         marker.LAngle_scope = LAngle_scope &~ ctCDPI_mask;
    548         marker.Ref_opener = lex.RefStart &~ ctCDPI_mask;
    549         marker.CD_closer = CD_closer &~ ctCDPI_mask;
    550 };
    551 
    552 function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    553        
    554         # Delimiters for scans.
    555         DQuoteDelim = lex.DQuote | lex.LAngle;
    556         SQuoteDelim = lex.SQuote | lex.LAngle;
    557         AttListDelim = lex.Slash | lex.RAngle;
    558        
    559         # Start the parallel parsing by inspecting the character
    560         # after the opening "<" of a tag.
    561         tag_Callouts.ElemName_starts = marker.LAngle_scope & ~lex.Slash;
    562         tag_Callouts.EndTag_marks = marker.LAngle_scope & lex.Slash;
    563        
    564         # Start Tag/Empty Element Tag Parsing
    565 
    566         # Advance all cursors by scanning through the tag name.
    567         tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    568         # Must have at least one name character for a legal start tag.
    569         # Mark any occurrences of null names as errors.
    570         ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends;
    571        
    572         # Initialize the accumulators for attribute name and value positions.
    573         tag_Callouts.AttName_starts = 0; 
    574         tag_Callouts.AttName_ends = 0;
    575         tag_Callouts.AttVal_starts = 0;
    576         tag_Callouts.AttVal_ends = 0;
    577 
    578         # After the element name, there may or may not be an attlist.
    579         if (tag_Callouts.ElemName_ends & lex.WS) {
    580                 AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    581                 AttListEnd = AfterWS & AttListDelim;
    582                 AttNameStart = AfterWS & ~AttListDelim;
    583                 #
    584                 # The following loop iterates through attributes within a start tag.
    585                 # Because all start tags are processed in parallel, the number of
    586                 # iterations is the maximum number of attributes found in any one
    587                 # start tag, plus one.
    588                 while (AttNameStart) {
    589                         ParseError |= AttNameStart &~ lex.NameScan;
    590                         tag_Callouts.AttName_starts |= AttNameStart;
    591                         AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
    592                         tag_Callouts.AttName_ends |= AttNameFollow;
    593                         # Scan through WS to the expected '=' delimiter.
    594                         # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    595                         # But use if test to optimize.
    596                         if (AttNameFollow & lex.WS) {
    597                                 EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
    598                         } else { EqExpected = AttNameFollow;
    599                         ParseError |= EqExpected &~ lex.Equals;
    600                         AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
    601 #                       AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
    602                         tag_Callouts.AttVal_starts |= AttValPos;
    603                         DQuoteAttVal = AttValPos & lex.DQuote;
    604                         SQuoteAttVal = AttValPos & lex.SQuote;
    605 #                       DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    606 #                       SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
    607                         DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
    608                         SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
    609                         AttValEnd = DQuoteAttEnd | SQuoteAttEnd;
    610                         ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote);
    611                         AttValFollow = pablo.Advance(AttValEnd);
    612                         tag_Callouts.AttVal_ends |= AttValFollow;
    613                         #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    614                         }
    615                         if (AttValFollow & lex.WS) {
    616                                 AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
    617                                 AttListEnd |= AfterWS & AttListDelim;
    618                                 AttNameStart = AfterWS & ~AttListDelim;
    619                         } else {
    620                                 AttListEnd |= AttValFollow & AttListDelim;     
    621                                 AttNameStart = 0;
    622                                 ParseError |= AttValFollow & ~AttListDelim;
    623                         }
    624                 }
    625         } else {
    626                 # No WS character after ElemName; must be at the end
    627                 AttListEnd = tag_Callouts.ElemName_ends & AttListDelim;
    628                 ParseError |= tag_Callouts.ElemName_ends & ~AttListDelim;
    629         }
    630        
    631         STagEnds = AttListEnd & lex.RAngle;
    632         # Mark any "/" characters found as the ends of empty element tags.
    633         tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash);
    634        
    635         ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle;
    636 
    637         # End Tag Parsing
    638 
    639         EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
    640         if (EndTagEnds & lex.WS) {
    641                 EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
    642         }
    643         ParseError |= EndTagEnds & ~lex.RAngle;
    644         pablo.assert_0(ParseError, "Tag parsing error found");
    645                
    646                
    647         # Attribute value spans
    648 #       tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
    649         tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
    650 };
    651 
    652 function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    653         ref_Callouts.GenRef_starts = 0;
    654         ref_Callouts.GenRef_ends = 0;
    655         ref_Callouts.DecRef_starts = 0;
    656         ref_Callouts.DecRef_ends = 0;
    657         ref_Callouts.HexRef_starts = 0;
    658         ref_Callouts.HexRef_ends = 0;
    659         ref_error = 0;
    660 
    661         # All remaining "&" must be reference start characters; parse them.
    662         if (marker.Ref_opener) {
    663                 Ref_scope = pablo.Advance(marker.Ref_opener);
    664                 NumRef2 = Ref_scope & lex.Hash;
    665                 ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash;
    666                 NumRef3 = pablo.Advance(NumRef2);
    667                 HexRef3 = NumRef3 & lex.x;
    668                 ref_Callouts.DecRef_starts = NumRef3 &~ lex.x;
    669                 ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
    670                 ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan);
    671                 ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
    672                 ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
    673                 # Error checks
    674                 # At least one digit required for DecRef, one hex digit for HexRef.
    675                 ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit;
    676                 ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex;
    677                 # Semicolon terminator required (also covers unterminated at EOF).
    678                 ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends;
    679                 ref_error3 = ref_ends &~ lex.Semicolon;
    680                 pablo.assert_0(ref_error1 | ref_error2 | ref_error3, "Reference error found");
    681         }               
    682 };
    683 
    684 function 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) {
    685 #       PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
    686 #       GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
    687 #       ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
    688 #       AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
    689         PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    690         GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
    691         ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    692         AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
    693         qname_stream =  ElemNames | AttNames;
    694         ncname_stream = PI_names | GenRefs;
    695         name_stream = qname_stream | ncname_stream;
    696         name_start = name_stream &~ pablo.Advance(name_stream);
    697         name_cursor = name_stream & ~pablo.Advance(name_stream);
    698         void_prefix_err = name_cursor & lex.Colon;
    699         namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon;
    700         local_part_start = pablo.Advance(namespace_sep);
    701         local_part_err = local_part_start &~ lex.NameScan;
    702         colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon;
    703         ncname_err = ncname_stream & lex.Colon;
    704         pablo.assert_0(void_prefix_err | local_part_err | colon2_err | ncname_err, "name syntax error");
    705                
    706                        
    707         check_streams.non_ascii_name_starts = name_start &~lex.ASCII_name_start;
    708         check_streams.non_ascii_names = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix;
    709    
    710 };   
    711    
    712 function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
    713         pablo.assert_0(marker.CD_closer & ~tag_Callouts.AttVal_spans, "Error: ]]> in text");
    714         check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts;
    715         check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends;
    716         check_streams.att_refs = tag_Callouts.AttVal_spans & marker.Ref_opener;
    717 };
    718 
    719 struct BasisBits {
    720         stream<1> b1;
    721         stream<1> b2;
    722         stream<1> b3;
    723         stream<1> b4;
    724 };
    725 struct BasisBits {
    726         stream b1;
    727         stream b2;
    728         stream b3;
    729         stream b4;
    730 };
    731 function void AssignmentExpressions() {
    732         temp4 = temp;
    733         temp4 &= temp1 | temp2;
    734         temp4 |= temp1 ^ temp2;
    735         temp4 ^= temp1 & temp2;
    736         temp4 ~= temp1 ^ temp2 | temp3;
    737 };function void BasicExpressions() {
    738 
    739         temp4 = temp;
    740         temp4 = temp1 | temp2;
    741         temp4 = temp1 ^ temp2;
    742         temp4 = temp1 & temp2;
    743         temp4 = temp1 ^ temp2 | temp3;
    744         temp4 = temp1 | temp2 ^ temp3;
    745         temp4 = temp1 & temp2 | temp3;
    746         temp4 = temp1 | temp2 & temp3;
    747         temp4 = temp1 & (temp2 | temp3);
    748         temp4 = (temp1 | temp2) & temp3;
    749         temp4 = ~temp;
    750        
    751 };
    752 
    753 function void Assignments() {
    754         var stream s;
    755         s = 0;
    756         s &= 0;
    757         s |= 0;
    758         s ~= 0;
    759         s ^= 0;
    760 };function struct A FunctionExpressions() {
    761          a.b.Advance();
    762 };
    763 function void RecordExpressions() {
    764 
    765         // records
    766         temp4 = temp1.temp2;
    767         temp4 = temp1.temp2.temp3;
    768        
    769         temp1.temp2 = temp4;
    770         temp1.temp2.temp3 = temp4;
    771                
    772 };function void Function() {
    773 var stream cursor = pablo.ScanToFirst(lex.opener);
    774 }function void localDecl() {
    775         var stream A;
    776         var stream A=0;
    777         var stream a=0,b=0,c=0;
    778 }function void localDecl() {
    779 
    780 var struct BasisBits {
    781 stream<1> b1;
    782 stream<1> b2;
    783 stream<1> b3;
    784 stream<1> b4;
    785 } A,B,C;
    786 
    787 };function void Assignments() {
    788         var stream s = 4;
    789         var stream s &= 4;
    790         var stream s |= 4;
    791         var stream s ~= 4;
    792         var stream s ^= 4;
    793 };function void localDecl() {
    794 
    795         var struct BasisBits {
    796         stream b1;
    797         stream b2;
    798         stream b3;
    799         stream b4;
    800         } A,B ;
    801 
    802 } function void Function() {   
    803        
    804         if(cursor & a) {
    805                 if(cursor & b) {
    806                
    807                 }
    808         }
    809        
    810 };
    811 function void Function() {     
    812        
    813         if(cursor & a) {
    814                 if(cursor & b) {
    815                
    816                 } else {
    817                
    818                 }
    819 
    820         } else {
    821 
    822         }
    823        
    824 };
    825 function void Function() {             
    826         if(cursor) {
    827 
    828         }
    829 };
    830 function void Function() {     
    831        
    832         if(cursor & a) {
    833 
    834         } else {
    835 
    836         }
    837        
    838 };
    839 /*
    840         Block comment.
    841 */
    842 
    843 // EOL terminated comment.
    844 
    845 // Another EOL terminated comment.
    846 
    847 function struct Lex ClassifyBytes(struct BasisBit basis) {};
    848 function stream Function(stream a, stream b, stream c) {};
    849 function void Lex() {};
    850 struct Lex {
    851         stream LAngle;
    852         stream RAngle;
    853 };
    854 
    855 typedef struct Lex Lex;
    856 
    857 typedef Lex Lex;typedef stream s;
    858 
    859 typedef stream<1> s1;typedef struct BasisBits {
    860 stream b1;
    861 stream b2;
    862 stream b3;
    863 stream b4;
    864 } BasisBitsAlias;# Demo - Hand ported Python pablo code (parses)
    865 #
    866 # Removed '-' operators.
    867 # Added statement terminators as needed ';'
    868 
    869 struct Basis_bits{     
    870         stream bit_0;
    871         stream bit_1;
    872         stream bit_2;
    873         stream bit_3;
    874         stream bit_4;
    875         stream bit_5;
    876         stream bit_6;
    877         stream bit_7;
    878 };
    879 
    880 struct u8 {
    881   stream unibyte;
    882   stream prefix;
    883   stream prefix2;
    884   stream prefix3;
    885   stream prefix4;
    886   stream suffix;
    887   stream badprefix;
    888   stream xE0;
    889   stream xED;
    890   stream xF0;
    891   stream xF4;
    892   stream xA0_xBF;
    893   stream x80_x9F;
    894   stream x90_xBF;
    895   stream x80_x8F;
    896   stream xEF;
    897   stream xBF;
    898   stream xBE;
    899   stream scope22;
    900   stream scope32;
    901   stream scope33;
    902   stream scope42;
    903   stream scope43;
    904   stream scope44;
    905   stream xE0_scope;
    906   stream xED_scope;
    907   stream xF0_scope;
    908   stream xF4_scope;
    909   stream xEF_scope;
    910 };
    911 
    912 struct Lex {
    913         stream CR;
    914         stream LF;
    915         stream HT;
    916         stream SP;
    917         stream CRLF;
    918         stream RefStart;
    919         stream Semicolon; 
    920         stream Colon;
    921         stream LAngle;
    922         stream RAngle;
    923         stream LBracket;
    924         stream RBracket;
    925         stream Exclam;
    926         stream QMark;
    927         stream Hyphen;
    928         stream Equals;
    929         stream SQuote;
    930         stream DQuote;
    931         stream Slash;
    932         stream Hash;
    933         stream x;
    934         stream ASCII_name_start;
    935         stream ASCII_name_char;
    936         stream NameScan;
    937         stream Digit;
    938         stream Hex;
    939         stream WS;
    940 };
    941 
    942 struct Marker {
    943         stream LAngle_scope;
    944         stream Ref_opener;
    945         stream CD_closer;
    946 };
    947 
    948 struct CtCDPI_Callouts{
    949         stream Ct_starts;
    950         stream Ct_ends;
    951         stream CD_starts;
    952         stream CD_ends;
    953         stream PI_starts;
    954         stream PI_name_starts;
    955         stream PI_name_ends;
    956         stream PI_ends;
    957 };
    958 
    959 struct Ref_Callouts{
    960         stream GenRef_starts;
    961         stream GenRef_ends;
    962         stream DecRef_starts;
    963         stream DecRef_ends;
    964         stream HexRef_starts;
    965         stream HexRef_ends;
    966 };
    967 
    968 struct Tag_Callouts{
    969         stream ElemName_starts;
    970         stream ElemName_ends;
    971         stream AttName_starts;
    972         stream AttName_ends;
    973         stream AttVal_starts;
    974         stream AttVal_ends;
    975         stream AttVal_spans;
    976         stream EmptyTag_marks;
    977         stream EndTag_marks;
    978 };
    979        
    980 struct Check_streams{
    981         stream misc_mask;
    982         stream non_ascii_name_starts;
    983         stream non_ascii_names;
    984         stream tag_marks;
    985         stream name_follows;
    986         stream att_refs;
    987 };
    988 
    989 function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) { 
    990         temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    991         temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
    992         temp3 = (temp2 &~ temp1);
    993         temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
    994         temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
    995         temp6 = (temp4 & temp5);
    996         lex.RefStart = (temp3 & temp6);
    997         temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
    998         temp8 = (temp7 &~ temp1);
    999         temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
    1000         temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
    1001         temp11 = (temp9 & temp10);
    1002         lex.Semicolon = (temp8 & temp11);
    1003         temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
    1004         temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
    1005         temp14 = (temp12 &~ temp13);
    1006         lex.LAngle = (temp8 & temp14);
    1007         temp15 = (temp12 & temp5);
    1008         lex.RAngle = (temp8 & temp15);
    1009         temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
    1010         temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
    1011         temp18 = (temp16 & temp17);
    1012         lex.LBracket = (temp18 & temp11);
    1013         temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
    1014         temp20 = (temp12 & temp19);
    1015         lex.RBracket = (temp18 & temp20);
    1016         temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
    1017         temp22 = (temp19 &~ temp21);
    1018         lex.Exclam = (temp3 & temp22);
    1019         temp23 = (temp12 & temp10);
    1020         lex.QMark = (temp8 & temp23);
    1021         lex.Hyphen = (temp3 & temp20);
    1022         lex.Equals = (temp8 & temp20);
    1023         temp24 = (temp4 & temp10);
    1024         lex.SQuote = (temp3 & temp24);
    1025         temp25 = (temp5 &~ temp21);
    1026         lex.DQuote = (temp3 & temp25);
    1027         lex.Slash = (temp3 & temp23);
    1028         temp26 = (temp10 &~ temp21);
    1029         lex.Hash = (temp3 & temp26);
    1030         temp27 = (temp16 & temp7);
    1031         temp28 = (temp9 &~ temp13);
    1032         lex.x = (temp27 & temp28);
    1033         temp29 = (temp9 & temp5);
    1034         lex.Colon = (temp8 & temp29);
    1035         temp30 = (temp18 & temp23);
    1036         temp31 = (temp30 | lex.Colon);
    1037         temp32 = (temp16 &~ basis_bits.bit_2);
    1038         temp33 = (basis_bits.bit_5 | temp10);
    1039         temp34 = (basis_bits.bit_4 & temp33);
    1040         temp35 = (~temp34);
    1041         temp36 = (temp21 | temp13);
    1042         temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
    1043         temp38 = (temp32 & temp37);
    1044         temp39 = (temp31 | temp38);
    1045         temp40 = (temp16 & basis_bits.bit_2);
    1046         temp41 = (temp40 & temp37);
    1047         lex.ASCII_name_start = (temp39 | temp41);
    1048         temp42 = (temp30 | lex.Hyphen);
    1049         temp43 = (temp3 & temp15);
    1050         temp44 = (temp42 | temp43);
    1051         temp45 = (temp8 &~ temp34);
    1052         temp46 = (temp44 | temp45);
    1053         temp47 = (temp46 | temp38);
    1054         lex.ASCII_name_char = (temp47 | temp41);
    1055         lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
    1056         temp48 = (temp1 | basis_bits.bit_2);
    1057         x00_x1F = (~temp48);
    1058         temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
    1059         temp50 = (temp1 | temp49);
    1060         lex.CR = (temp20 &~ temp50);
    1061         lex.LF = (temp29 &~ temp50);
    1062         temp51 = (temp9 & temp19);
    1063         lex.HT = (temp51 &~ temp50);
    1064         lex.SP = (temp3 &~ temp36);
    1065         temp52 = (temp20 | temp29);
    1066         temp53 = (temp52 | temp51);
    1067         temp54 = (temp53 &~ temp50);
    1068         lex.WS = (temp54 | lex.SP);
    1069         temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
    1070         temp56 = (basis_bits.bit_4 & temp55);
    1071         lex.Digit = (temp8 &~ temp56);
    1072         temp57 = (temp16 &~ temp49);
    1073         temp58 = (temp57 &~ basis_bits.bit_4);
    1074         temp59 = (~temp10);
    1075         temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
    1076         temp61 = (temp58 & temp60);
    1077         temp62 = (lex.Digit | temp61);
    1078         temp63 = (temp16 & temp2);
    1079         temp64 = (temp63 &~ basis_bits.bit_4);
    1080         temp65 = (temp64 & temp60);
    1081         lex.Hex = (temp62 | temp65);
    1082         lex_error = x00_x1F &~ lex.WS;
    1083         pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    1084                
    1085        
    1086         ### Validate_utf8(basis_bits, u8):
    1087         u8.unibyte = (~basis_bits.bit_0);
    1088         u8.suffix = 0;
    1089         u8_error = 0;
    1090         u8_FFFE_FFFF = 0;
    1091         u8anyscope = 0; #local
    1092         if (basis_bits.bit_0) {
    1093                 u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
    1094                 u8.prefix2 = (u8.prefix &~ basis_bits.bit_2);
    1095                 u8.prefix3 = (u8.prefix & temp2);
    1096                 u8.prefix4 = (u8.prefix & temp7);
    1097                 u8.suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
    1098                 temp66 = (u8.prefix &~ temp49);
    1099                 temp67 = (temp21 | basis_bits.bit_6);
    1100                 temp68 = (temp66 &~ temp67);
    1101                 temp69 = (basis_bits.bit_5 & temp13);
    1102                 temp70 = (basis_bits.bit_4 | temp69);
    1103                 temp71 = (u8.prefix4 & temp70);
    1104                 u8.badprefix = (temp68 | temp71);
    1105                 u8_error = u8.badprefix;
    1106                 u8.scope22 = pablo.Advance(u8.prefix2);
    1107                 u8anyscope = u8.scope22;
    1108                 if (u8.prefix3 | u8.prefix4) {
    1109                         xE0 = (u8.prefix3 &~ temp36);
    1110                         xED = (u8.prefix3 & temp20);
    1111                         xF0 = (u8.prefix4 &~ temp36);
    1112                         temp72 = (temp4 &~ temp13);
    1113                         xF4 = (u8.prefix4 & temp72);
    1114                         u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
    1115                         u8.x80_x9F = (u8.suffix &~ basis_bits.bit_2);
    1116                         u8.x90_xBF = (u8.suffix & temp49);
    1117                         u8.x80_x8F = (u8.suffix &~ temp49);
    1118                         xEF = (u8.prefix3 & temp23);
    1119                         temp73 = (u8.suffix & temp7);
    1120                         u8.xBF = (temp73 & temp23);
    1121                         u8.xBE = (temp73 & temp15);
    1122 #
    1123 
    1124 #                       scope3_32 = pablo.Advance32(u8.prefix3)
    1125 #                       scope4_32 = pablo.Advance32(u8.prefix4)
    1126 #                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
    1127 #                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
    1128 #                       u8.scope42 = interpose32(u8.prefix4, scope4_32, 1)
    1129 #                       u8.scope43 = interpose32(u8.prefix4, scope4_32, 2)
    1130 #                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
    1131 #
    1132                         u8.scope32 = pablo.Advance(u8.prefix3);
    1133                         u8.scope33 = pablo.Advance(u8.scope32);
    1134                         u8.scope42 = pablo.Advance(u8.prefix4);
    1135                         u8.scope43 = pablo.Advance(u8.scope42);
    1136                         u8.scope44 = pablo.Advance(u8.scope43);
    1137 #
    1138 #                       u8.xE0_scope = pablo.Advance(xE0);
    1139 #                       u8.xED_scope = pablo.Advance(xED);
    1140 #                       u8.xF0_scope = pablo.Advance(xF0);
    1141 #                       u8.xF4_scope = pablo.Advance(xF4);
    1142                         E0_F0_scope = pablo.Advance(xE0 | xF0);
    1143                         ED_F4_scope = pablo.Advance(xED | xF4);
    1144                         u8.xE0_scope = u8.scope32 & E0_F0_scope;
    1145                         u8.xED_scope = u8.scope32 & ED_F4_scope;
    1146                         u8.xF0_scope = u8.scope42 & E0_F0_scope;
    1147                         u8.xF4_scope = u8.scope42 & ED_F4_scope;
    1148                         u8.xEF_scope = pablo.Advance(xEF);
    1149 
    1150                         u8lastscope = u8.scope22 | u8.scope33 | u8.scope44;
    1151                         u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43;
    1152                
    1153                         u8error1 = u8.xE0_scope & u8.x80_x9F;
    1154                         u8error2 = u8.xED_scope & u8.xA0_xBF;
    1155                         u8error3 = u8.xF0_scope & u8.x80_x8F;
    1156                         u8error4 = u8.xF4_scope & u8.x90_xBF;
    1157        
    1158                         u8_error |= u8error1 | u8error2 | u8error3 | u8error4;
    1159 
    1160                         EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF);
    1161 
    1162                         u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
    1163                 }               
    1164                 u8mismatch = u8anyscope ^ u8.suffix;
    1165                 pablo.assert_0(u8_error | u8mismatch | u8_FFFE_FFFF, "UTF-8 error found");
    1166         }
    1167 };
    1168 
    1169 function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    1170         ctCDPI_Callouts.Ct_starts = 0;
    1171         ctCDPI_Callouts.Ct_ends = 0;
    1172         ctCDPI_Callouts.CD_starts = 0;
    1173         ctCDPI_Callouts.CD_ends = 0;
    1174         ctCDPI_Callouts.PI_starts = 0;
    1175         ctCDPI_Callouts.PI_name_starts = 0;
    1176         ctCDPI_Callouts.PI_name_ends = 0;
    1177         ctCDPI_Callouts.PI_ends = 0;
    1178         CtCDPI_starts = 0;
    1179         CtCDPI_ends = 0;
    1180         ctCDPI_mask = 0;
    1181 
    1182         v = lex.LAngle | lex.Hyphen;
    1183         w = lex.Hyphen | lex.QMark;
    1184         v1 = pablo.Advance(v,1);
    1185         w1 = pablo.Advance(w,1);
    1186        
    1187         LAngle_scope = v1 &~ w1;  #pablo.Advance(lex.LAngle);
    1188         PI_opener = LAngle_scope & lex.QMark;
    1189         CtCD_opener= LAngle_scope & lex.Exclam;
    1190         CtCDPI_opener = PI_opener | CtCD_opener;
    1191 
    1192         #DoubleHyphen = 0;
    1193         CD_closer = 0;
    1194         #PI_closer = 0;
    1195        
    1196         #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
    1197         DoubleHyphen = v1 & w1 & lex.Hyphen;
    1198         if (lex.RBracket) {
    1199                 DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket;
    1200                 CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle;
    1201         }
    1202         #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
    1203         PI_closer = w1 & ~v1 & lex.RAngle;
    1204 
    1205         #
    1206         # Initiate the scan
    1207         CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
    1208         while (CtCDPI_Cursor) {
    1209                 CtCDPI_starts |= CtCDPI_Cursor;
    1210                 PI_Cursor = CtCDPI_Cursor & PI_opener;
    1211                 CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor);
    1212                 CD_Cursor = CD_Ct_Cursor & lex.LBracket;
    1213                 Ct_Cursor = CD_Ct_Cursor & lex.Hyphen ;
    1214                 # PI processing
    1215                 if (PI_Cursor) {
    1216                         ctCDPI_Callouts.PI_starts |= PI_Cursor;
    1217                         PI_Cursor = pablo.Advance(PI_Cursor);
    1218                         ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
    1219                         PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
    1220                         PI_error = PI_Cursor & PI_name_end;
    1221                         PI_noWS = PI_name_end & ~ lex.WS;
    1222                         PI_error |= PI_noWS &~ lex.QMark | pablo.Advance(PI_noWS) &~ PI_closer;
    1223                         pablo.assert_0(PI_error, "Error in PI syntax");
    1224                         ctCDPI_Callouts.PI_name_ends |= PI_name_end;
    1225                         PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
    1226                         ctCDPI_Callouts.PI_ends |= PI_Cursor;
    1227                         CtCDPI_ends |= PI_Cursor;
    1228                 }
    1229                 # CDATA section processing
    1230                 if (CD_Cursor) {
    1231                         ctCDPI_Callouts.CD_starts |= CD_Cursor;
    1232                         CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
    1233                         ctCDPI_Callouts.CD_ends |= CD_Cursor;
    1234                         CtCDPI_ends |= CD_Cursor;
    1235                 }
    1236                 # Comment processing
    1237                 if (Ct_Cursor) {
    1238                         ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
    1239                         Ct_Cursor = pablo.Advance(Ct_Cursor); 
    1240                         Ct_error = Ct_Cursor & ~ lex.Hyphen;
    1241                         # Advance twice past <!--, so that we don't treat <!---
    1242                         # as being a terminated comment.
    1243                         Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
    1244                         Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
    1245                         pablo.assert_0(Ct_error | Ct_Cursor & ~ lex.RAngle, "Error in comment syntax");
    1246                         ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
    1247                         CtCDPI_ends |= Ct_Cursor;
    1248                 }
    1249                 # Common processing
    1250                 CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor;
    1251                 ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
    1252 # '-' Not Supported.           
    1253 #               ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends;
    1254                 # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    1255                 pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
    1256                 CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)      ;
    1257         }
    1258 # '-' Not Supported.           
    1259 #       check_streams.misc_mask = (lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends)  -(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
    1260 #  Following is slow
    1261         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;
    1262 
    1263 
    1264         # Identify the remaining significant markers for XML processing.
    1265         marker.LAngle_scope = LAngle_scope &~ ctCDPI_mask;
    1266         marker.Ref_opener = lex.RefStart &~ ctCDPI_mask;
    1267         marker.CD_closer = CD_closer &~ ctCDPI_mask;
    1268 };
    1269 
    1270 function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    1271        
    1272         # Delimiters for scans.
    1273         DQuoteDelim = lex.DQuote | lex.LAngle;
    1274         SQuoteDelim = lex.SQuote | lex.LAngle;
    1275         AttListDelim = lex.Slash | lex.RAngle;
    1276        
    1277         # Start the parallel parsing by inspecting the character
    1278         # after the opening "<" of a tag.
    1279         tag_Callouts.ElemName_starts = marker.LAngle_scope & ~lex.Slash;
    1280         tag_Callouts.EndTag_marks = marker.LAngle_scope & lex.Slash;
    1281        
    1282         # Start Tag/Empty Element Tag Parsing
    1283 
    1284         # Advance all cursors by scanning through the tag name.
    1285         tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    1286         # Must have at least one name character for a legal start tag.
    1287         # Mark any occurrences of null names as errors.
    1288         ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends;
    1289        
    1290         # Initialize the accumulators for attribute name and value positions.
    1291         tag_Callouts.AttName_starts = 0; 
    1292         tag_Callouts.AttName_ends = 0;
    1293         tag_Callouts.AttVal_starts = 0;
    1294         tag_Callouts.AttVal_ends = 0;
    1295 
    1296         # After the element name, there may or may not be an attlist.
    1297         if (tag_Callouts.ElemName_ends & lex.WS) {
    1298                 AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    1299                 AttListEnd = AfterWS & AttListDelim;
    1300                 AttNameStart = AfterWS & ~AttListDelim;
    1301                 #
    1302                 # The following loop iterates through attributes within a start tag.
    1303                 # Because all start tags are processed in parallel, the number of
    1304                 # iterations is the maximum number of attributes found in any one
    1305                 # start tag, plus one.
    1306                 while (AttNameStart) {
    1307                         ParseError |= AttNameStart &~ lex.NameScan;
    1308                         tag_Callouts.AttName_starts |= AttNameStart;
    1309                         AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
    1310                         tag_Callouts.AttName_ends |= AttNameFollow;
    1311                         # Scan through WS to the expected '=' delimiter.
    1312                         # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    1313                         # But use if test to optimize.
    1314                         if (AttNameFollow & lex.WS) {
    1315                                 EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
    1316                         } else { EqExpected = AttNameFollow;
    1317                         ParseError |= EqExpected &~ lex.Equals;
    1318                         AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
    1319 #                       AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
    1320                         tag_Callouts.AttVal_starts |= AttValPos;
    1321                         DQuoteAttVal = AttValPos & lex.DQuote;
    1322                         SQuoteAttVal = AttValPos & lex.SQuote;
    1323 #                       DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    1324 #                       SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
    1325                         DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
    1326                         SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
    1327                         AttValEnd = DQuoteAttEnd | SQuoteAttEnd;
    1328                         ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote);
    1329                         AttValFollow = pablo.Advance(AttValEnd);
    1330                         tag_Callouts.AttVal_ends |= AttValFollow;
    1331                         #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    1332                         }
    1333                         if (AttValFollow & lex.WS) {
    1334                                 AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
    1335                                 AttListEnd |= AfterWS & AttListDelim;
    1336                                 AttNameStart = AfterWS & ~AttListDelim;
    1337                         } else {
    1338                                 AttListEnd |= AttValFollow & AttListDelim;     
    1339                                 AttNameStart = 0;
    1340                                 ParseError |= AttValFollow & ~AttListDelim;
    1341                         }
    1342                 }
    1343         } else {
    1344                 # No WS character after ElemName; must be at the end
    1345                 AttListEnd = tag_Callouts.ElemName_ends & AttListDelim;
    1346                 ParseError |= tag_Callouts.ElemName_ends & ~AttListDelim;
    1347         }
    1348        
    1349         STagEnds = AttListEnd & lex.RAngle;
    1350         # Mark any "/" characters found as the ends of empty element tags.
    1351         tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash);
    1352        
    1353         ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle;
    1354 
    1355         # End Tag Parsing
    1356 
    1357         EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
    1358         if (EndTagEnds & lex.WS) {
    1359                 EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
    1360         }
    1361         ParseError |= EndTagEnds & ~lex.RAngle;
    1362         pablo.assert_0(ParseError, "Tag parsing error found");
    1363                
    1364                
    1365         # Attribute value spans
    1366 #       tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
    1367         tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
    1368 };
    1369 
    1370 function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    1371         ref_Callouts.GenRef_starts = 0;
    1372         ref_Callouts.GenRef_ends = 0;
    1373         ref_Callouts.DecRef_starts = 0;
    1374         ref_Callouts.DecRef_ends = 0;
    1375         ref_Callouts.HexRef_starts = 0;
    1376         ref_Callouts.HexRef_ends = 0;
    1377         ref_error = 0;
    1378 
    1379         # All remaining "&" must be reference start characters; parse them.
    1380         if (marker.Ref_opener) {
    1381                 Ref_scope = pablo.Advance(marker.Ref_opener);
    1382                 NumRef2 = Ref_scope & lex.Hash;
    1383                 ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash;
    1384                 NumRef3 = pablo.Advance(NumRef2);
    1385                 HexRef3 = NumRef3 & lex.x;
    1386                 ref_Callouts.DecRef_starts = NumRef3 &~ lex.x;
    1387                 ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
    1388                 ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan);
    1389                 ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
    1390                 ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
    1391                 # Error checks
    1392                 # At least one digit required for DecRef, one hex digit for HexRef.
    1393                 ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit;
    1394                 ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex;
    1395                 # Semicolon terminator required (also covers unterminated at EOF).
    1396                 ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends;
    1397                 ref_error3 = ref_ends &~ lex.Semicolon;
    1398                 pablo.assert_0(ref_error1 | ref_error2 | ref_error3, "Reference error found");
    1399         }               
    1400 };
    1401 
    1402 function 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) {
    1403 #       PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
    1404 #       GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
    1405 #       ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
    1406 #       AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
    1407         PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    1408         GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
    1409         ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    1410         AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
    1411         qname_stream =  ElemNames | AttNames;
    1412         ncname_stream = PI_names | GenRefs;
    1413         name_stream = qname_stream | ncname_stream;
    1414         name_start = name_stream &~ pablo.Advance(name_stream);
    1415         name_cursor = name_stream & ~pablo.Advance(name_stream);
    1416         void_prefix_err = name_cursor & lex.Colon;
    1417         namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon;
    1418         local_part_start = pablo.Advance(namespace_sep);
    1419         local_part_err = local_part_start &~ lex.NameScan;
    1420         colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon;
    1421         ncname_err = ncname_stream & lex.Colon;
    1422         pablo.assert_0(void_prefix_err | local_part_err | colon2_err | ncname_err, "name syntax error");
    1423                
    1424                        
    1425         check_streams.non_ascii_name_starts = name_start &~lex.ASCII_name_start;
    1426         check_streams.non_ascii_names = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix;
    1427    
    1428 };   
    1429    
    1430 function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
    1431         pablo.assert_0(marker.CD_closer & ~tag_Callouts.AttVal_spans, "Error: ]]> in text");
    1432         check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts;
    1433         check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends;
    1434         check_streams.att_refs = tag_Callouts.AttVal_spans & marker.Ref_opener;
    1435 };
    1436 
  • proto/pablo/input/test/pablo/scratch/test.pablo

    r2623 r2624  
    1 struct BasisBits {
    2         stream<1> b1;
    3         stream<1> b2;
    4         stream<1> b3;
    5         stream<1> b4;
    6 };
    7 struct BasisBits {
    8         stream b1;
    9         stream b2;
    10         stream b3;
    11         stream b4;
    12 };
    13 function void AssignmentExpressions() {
    14         temp4 = temp;
    15         temp4 &= temp1 | temp2;
    16         temp4 |= temp1 ^ temp2;
    17         temp4 ^= temp1 & temp2;
    18 }; function void BasicExpressions() {
    19 
    20         temp4 = temp;
    21         temp4 = temp1 | temp2;
    22         temp4 = temp1 ^ temp2;
    23         temp4 = temp1 & temp2;
    24         temp4 = temp1 ^ temp2 | temp3;
    25         temp4 = temp1 | temp2 ^ temp3;
    26         temp4 = temp1 & temp2 | temp3;
    27         temp4 = temp1 | temp2 & temp3;
    28         temp4 = temp1 & (temp2 | temp3);
    29         temp4 = (temp1 | temp2) & temp3;s
    30 };
    31 
    32 function void Assignments() {
    33         var stream s;
    34         s = 0;
    35         s &= 0;
    36         s |= 0;
    37         s ^= 0;
    38 };function struct A FunctionExpressions() {
    39          a.b.Advance();
    40 };
    41 function void RecordExpressions() {
    42 
    43         // records
    44         temp4 = temp1.temp2;
    45         temp4 = temp1.temp2.temp3;
    46        
    47         temp1.temp2 = temp4;
    48         temp1.temp2.temp3 = temp4;
    49                
    50 };function void Function() {
    51 var stream cursor = pablo.ScanToFirst(lex.opener);
    52 }function void localDecl() {
    53         var stream A;
    54         var stream A=0;
    55         var stream a=0,b=0,c=0;
    56 }function void localDecl() {
    57 
    58 var struct BasisBits {
    59 stream<1> b1;
    60 stream<1> b2;
    61 stream<1> b3;
    62 stream<1> b4;
    63 } A,B,C;
    64 
    65 };function void Assignments() {
    66         var stream s = 4;
    67         var stream s &= 4;
    68         var stream s |= 4;
    69         var stream s ^= 4;
    70 };function void localDecl() {
    71 
    72         var struct BasisBits {
    73         stream b1;
    74         stream b2;
    75         stream b3;
    76         stream b4;
    77         } A,B ;
    78 
    79 } function void Function() {   
    80        
    81         if(cursor & a) {
    82                 if(cursor & b) {
    83                
    84                 }
    85         }
    86        
    87 };
    88 function void Function() {     
    89        
    90         if(cursor & a) {
    91                 if(cursor & b) {
    92                
    93                 } else {
    94                
    95                 }
    96 
    97         } else {
    98 
    99         }
    100        
    101 };
    102 function void Function() {             
    103         if(cursor) {
    104 
    105         }
    106 };
    107 function void Function() {     
    108        
    109         if(cursor & a) {
    110 
    111         } else {
    112 
    113         }
    114        
    115 };
    116 /*
    117         Block comment.
    118 */
    119 
    120 // EOL terminated comment.
    121 
    122 // Another EOL terminated comment.
    123 
    124 function struct Lex ClassifyBytes(struct BasisBit basis) {};
    125 function stream Function(stream a, stream b, stream c) {};
    126 function void Lex() {};
    127 struct Lex {
    128         stream LAngle;
    129         stream RAngle;
    130 };
    131 
    132 typedef struct Lex Lex;
    133 
    134 typedef Lex Lex;typedef stream s;
    135 
    136 typedef stream<1> s1;typedef struct BasisBits {
    137 stream b1;
    138 stream b2;
    139 stream b3;
    140 stream b4;
    141 } BasisBitsAlias;# Demo - Hand ported Python pablo code (parses)
    142 #
    143 # Removed '-' operators.
    144 # Added statement terminators as needed ';'
    145 
    146 struct Basis_bits{     
    147         stream bit_0;
    148         stream bit_1;
    149         stream bit_2;
    150         stream bit_3;
    151         stream bit_4;
    152         stream bit_5;
    153         stream bit_6;
    154         stream bit_7;
    155 };
    156 
    157 struct u8 {
    158   stream unibyte;
    159   stream prefix;
    160   stream prefix2;
    161   stream prefix3;
    162   stream prefix4;
    163   stream suffix;
    164   stream badprefix;
    165   stream xE0;
    166   stream xED;
    167   stream xF0;
    168   stream xF4;
    169   stream xA0_xBF;
    170   stream x80_x9F;
    171   stream x90_xBF;
    172   stream x80_x8F;
    173   stream xEF;
    174   stream xBF;
    175   stream xBE;
    176   stream scope22;
    177   stream scope32;
    178   stream scope33;
    179   stream scope42;
    180   stream scope43;
    181   stream scope44;
    182   stream xE0_scope;
    183   stream xED_scope;
    184   stream xF0_scope;
    185   stream xF4_scope;
    186   stream xEF_scope;
    187 };
    188 
    189 struct Lex {
    190         stream CR;
    191         stream LF;
    192         stream HT;
    193         stream SP;
    194         stream CRLF;
    195         stream RefStart;
    196         stream Semicolon; 
    197         stream Colon;
    198         stream LAngle;
    199         stream RAngle;
    200         stream LBracket;
    201         stream RBracket;
    202         stream Exclam;
    203         stream QMark;
    204         stream Hyphen;
    205         stream Equals;
    206         stream SQuote;
    207         stream DQuote;
    208         stream Slash;
    209         stream Hash;
    210         stream x;
    211         stream ASCII_name_start;
    212         stream ASCII_name_char;
    213         stream NameScan;
    214         stream Digit;
    215         stream Hex;
    216         stream WS;
    217 };
    218 
    219 struct Marker {
    220         stream LAngle_scope;
    221         stream Ref_opener;
    222         stream CD_closer;
    223 };
    224 
    225 struct CtCDPI_Callouts{
    226         stream Ct_starts;
    227         stream Ct_ends;
    228         stream CD_starts;
    229         stream CD_ends;
    230         stream PI_starts;
    231         stream PI_name_starts;
    232         stream PI_name_ends;
    233         stream PI_ends;
    234 };
    235 
    236 struct Ref_Callouts{
    237         stream GenRef_starts;
    238         stream GenRef_ends;
    239         stream DecRef_starts;
    240         stream DecRef_ends;
    241         stream HexRef_starts;
    242         stream HexRef_ends;
    243 };
    244 
    245 struct Tag_Callouts{
    246         stream ElemName_starts;
    247         stream ElemName_ends;
    248         stream AttName_starts;
    249         stream AttName_ends;
    250         stream AttVal_starts;
    251         stream AttVal_ends;
    252         stream AttVal_spans;
    253         stream EmptyTag_marks;
    254         stream EndTag_marks;
    255 };
    256        
    257 struct Check_streams{
    258         stream misc_mask;
    259         stream non_ascii_name_starts;
    260         stream non_ascii_names;
    261         stream tag_marks;
    262         stream name_follows;
    263         stream att_refs;
    264 };
    265 
    266 function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) { 
    267         temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    268         temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
    269         temp3 = (temp2 &~ temp1);
    270         temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
    271         temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
    272         temp6 = (temp4 & temp5);
    273         lex.RefStart = (temp3 & temp6);
    274         temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
    275         temp8 = (temp7 &~ temp1);
    276         temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
    277         temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
    278         temp11 = (temp9 & temp10);
    279         lex.Semicolon = (temp8 & temp11);
    280         temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
    281         temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
    282         temp14 = (temp12 &~ temp13);
    283         lex.LAngle = (temp8 & temp14);
    284         temp15 = (temp12 & temp5);
    285         lex.RAngle = (temp8 & temp15);
    286         temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
    287         temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
    288         temp18 = (temp16 & temp17);
    289         lex.LBracket = (temp18 & temp11);
    290         temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
    291         temp20 = (temp12 & temp19);
    292         lex.RBracket = (temp18 & temp20);
    293         temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
    294         temp22 = (temp19 &~ temp21);
    295         lex.Exclam = (temp3 & temp22);
    296         temp23 = (temp12 & temp10);
    297         lex.QMark = (temp8 & temp23);
    298         lex.Hyphen = (temp3 & temp20);
    299         lex.Equals = (temp8 & temp20);
    300         temp24 = (temp4 & temp10);
    301         lex.SQuote = (temp3 & temp24);
    302         temp25 = (temp5 &~ temp21);
    303         lex.DQuote = (temp3 & temp25);
    304         lex.Slash = (temp3 & temp23);
    305         temp26 = (temp10 &~ temp21);
    306         lex.Hash = (temp3 & temp26);
    307         temp27 = (temp16 & temp7);
    308         temp28 = (temp9 &~ temp13);
    309         lex.x = (temp27 & temp28);
    310         temp29 = (temp9 & temp5);
    311         lex.Colon = (temp8 & temp29);
    312         temp30 = (temp18 & temp23);
    313         temp31 = (temp30 | lex.Colon);
    314         temp32 = (temp16 &~ basis_bits.bit_2);
    315         temp33 = (basis_bits.bit_5 | temp10);
    316         temp34 = (basis_bits.bit_4 & temp33);
    317         temp35 = (~temp34);
    318         temp36 = (temp21 | temp13);
    319         temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
    320         temp38 = (temp32 & temp37);
    321         temp39 = (temp31 | temp38);
    322         temp40 = (temp16 & basis_bits.bit_2);
    323         temp41 = (temp40 & temp37);
    324         lex.ASCII_name_start = (temp39 | temp41);
    325         temp42 = (temp30 | lex.Hyphen);
    326         temp43 = (temp3 & temp15);
    327         temp44 = (temp42 | temp43);
    328         temp45 = (temp8 &~ temp34);
    329         temp46 = (temp44 | temp45);
    330         temp47 = (temp46 | temp38);
    331         lex.ASCII_name_char = (temp47 | temp41);
    332         lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
    333         temp48 = (temp1 | basis_bits.bit_2);
    334         x00_x1F = (~temp48);
    335         temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
    336         temp50 = (temp1 | temp49);
    337         lex.CR = (temp20 &~ temp50);
    338         lex.LF = (temp29 &~ temp50);
    339         temp51 = (temp9 & temp19);
    340         lex.HT = (temp51 &~ temp50);
    341         lex.SP = (temp3 &~ temp36);
    342         temp52 = (temp20 | temp29);
    343         temp53 = (temp52 | temp51);
    344         temp54 = (temp53 &~ temp50);
    345         lex.WS = (temp54 | lex.SP);
    346         temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
    347         temp56 = (basis_bits.bit_4 & temp55);
    348         lex.Digit = (temp8 &~ temp56);
    349         temp57 = (temp16 &~ temp49);
    350         temp58 = (temp57 &~ basis_bits.bit_4);
    351         temp59 = (~temp10);
    352         temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
    353         temp61 = (temp58 & temp60);
    354         temp62 = (lex.Digit | temp61);
    355         temp63 = (temp16 & temp2);
    356         temp64 = (temp63 &~ basis_bits.bit_4);
    357         temp65 = (temp64 & temp60);
    358         lex.Hex = (temp62 | temp65);
    359         lex_error = x00_x1F &~ lex.WS;
    360         pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    361                
    362        
    363         ### Validate_utf8(basis_bits, u8):
    364         u8.unibyte = (~basis_bits.bit_0);
    365         u8.suffix = 0;
    366         u8_error = 0;
    367         u8_FFFE_FFFF = 0;
    368         u8anyscope = 0; #local
    369         if (basis_bits.bit_0) {
    370                 u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
    371                 u8.prefix2 = (u8.prefix &~ basis_bits.bit_2);
    372                 u8.prefix3 = (u8.prefix & temp2);
    373                 u8.prefix4 = (u8.prefix & temp7);
    374                 u8.suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
    375                 temp66 = (u8.prefix &~ temp49);
    376                 temp67 = (temp21 | basis_bits.bit_6);
    377                 temp68 = (temp66 &~ temp67);
    378                 temp69 = (basis_bits.bit_5 & temp13);
    379                 temp70 = (basis_bits.bit_4 | temp69);
    380                 temp71 = (u8.prefix4 & temp70);
    381                 u8.badprefix = (temp68 | temp71);
    382                 u8_error = u8.badprefix;
    383                 u8.scope22 = pablo.Advance(u8.prefix2);
    384                 u8anyscope = u8.scope22;
    385                 if (u8.prefix3 | u8.prefix4) {
    386                         xE0 = (u8.prefix3 &~ temp36);
    387                         xED = (u8.prefix3 & temp20);
    388                         xF0 = (u8.prefix4 &~ temp36);
    389                         temp72 = (temp4 &~ temp13);
    390                         xF4 = (u8.prefix4 & temp72);
    391                         u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
    392                         u8.x80_x9F = (u8.suffix &~ basis_bits.bit_2);
    393                         u8.x90_xBF = (u8.suffix & temp49);
    394                         u8.x80_x8F = (u8.suffix &~ temp49);
    395                         xEF = (u8.prefix3 & temp23);
    396                         temp73 = (u8.suffix & temp7);
    397                         u8.xBF = (temp73 & temp23);
    398                         u8.xBE = (temp73 & temp15);
    399 #
    400 
    401 #                       scope3_32 = pablo.Advance32(u8.prefix3)
    402 #                       scope4_32 = pablo.Advance32(u8.prefix4)
    403 #                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
    404 #                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
    405 #                       u8.scope42 = interpose32(u8.prefix4, scope4_32, 1)
    406 #                       u8.scope43 = interpose32(u8.prefix4, scope4_32, 2)
    407 #                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
    408 #
    409                         u8.scope32 = pablo.Advance(u8.prefix3);
    410                         u8.scope33 = pablo.Advance(u8.scope32);
    411                         u8.scope42 = pablo.Advance(u8.prefix4);
    412                         u8.scope43 = pablo.Advance(u8.scope42);
    413                         u8.scope44 = pablo.Advance(u8.scope43);
    414 #
    415 #                       u8.xE0_scope = pablo.Advance(xE0);
    416 #                       u8.xED_scope = pablo.Advance(xED);
    417 #                       u8.xF0_scope = pablo.Advance(xF0);
    418 #                       u8.xF4_scope = pablo.Advance(xF4);
    419                         E0_F0_scope = pablo.Advance(xE0 | xF0);
    420                         ED_F4_scope = pablo.Advance(xED | xF4);
    421                         u8.xE0_scope = u8.scope32 & E0_F0_scope;
    422                         u8.xED_scope = u8.scope32 & ED_F4_scope;
    423                         u8.xF0_scope = u8.scope42 & E0_F0_scope;
    424                         u8.xF4_scope = u8.scope42 & ED_F4_scope;
    425                         u8.xEF_scope = pablo.Advance(xEF);
    426 
    427                         u8lastscope = u8.scope22 | u8.scope33 | u8.scope44;
    428                         u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43;
    429                
    430                         u8error1 = u8.xE0_scope & u8.x80_x9F;
    431                         u8error2 = u8.xED_scope & u8.xA0_xBF;
    432                         u8error3 = u8.xF0_scope & u8.x80_x8F;
    433                         u8error4 = u8.xF4_scope & u8.x90_xBF;
    434        
    435                         u8_error |= u8error1 | u8error2 | u8error3 | u8error4;
    436 
    437                         EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF);
    438 
    439                         u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
    440                 }               
    441                 u8mismatch = u8anyscope ^ u8.suffix;
    442                 pablo.assert_0(u8_error | u8mismatch | u8_FFFE_FFFF, "UTF-8 error found");
    443         }
    444 };
    445 
    446 function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    447         ctCDPI_Callouts.Ct_starts = 0;
    448         ctCDPI_Callouts.Ct_ends = 0;
    449         ctCDPI_Callouts.CD_starts = 0;
    450         ctCDPI_Callouts.CD_ends = 0;
    451         ctCDPI_Callouts.PI_starts = 0;
    452         ctCDPI_Callouts.PI_name_starts = 0;
    453         ctCDPI_Callouts.PI_name_ends = 0;
    454         ctCDPI_Callouts.PI_ends = 0;
    455         CtCDPI_starts = 0;
    456         CtCDPI_ends = 0;
    457         ctCDPI_mask = 0;
    458 
    459         v = lex.LAngle | lex.Hyphen;
    460         w = lex.Hyphen | lex.QMark;
    461         v1 = pablo.Advance(v,1);
    462         w1 = pablo.Advance(w,1);
    463        
    464         LAngle_scope = v1 &~ w1;  #pablo.Advance(lex.LAngle);
    465         PI_opener = LAngle_scope & lex.QMark;
    466         CtCD_opener= LAngle_scope & lex.Exclam;
    467         CtCDPI_opener = PI_opener | CtCD_opener;
    468 
    469         #DoubleHyphen = 0;
    470         CD_closer = 0;
    471         #PI_closer = 0;
    472        
    473         #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
    474         DoubleHyphen = v1 & w1 & lex.Hyphen;
    475         if (lex.RBracket) {
    476                 DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket;
    477                 CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle;
    478         }
    479         #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
    480         PI_closer = w1 & ~v1 & lex.RAngle;
    481 
    482         #
    483         # Initiate the scan
    484         CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
    485         while (CtCDPI_Cursor) {
    486                 CtCDPI_starts |= CtCDPI_Cursor;
    487                 PI_Cursor = CtCDPI_Cursor & PI_opener;
    488                 CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor);
    489                 CD_Cursor = CD_Ct_Cursor & lex.LBracket;
    490                 Ct_Cursor = CD_Ct_Cursor & lex.Hyphen ;
    491                 # PI processing
    492                 if (PI_Cursor) {
    493                         ctCDPI_Callouts.PI_starts |= PI_Cursor;
    494                         PI_Cursor = pablo.Advance(PI_Cursor);
    495                         ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
    496                         PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
    497                         PI_error = PI_Cursor & PI_name_end;
    498                         PI_noWS = PI_name_end & ~ lex.WS;
    499                         PI_error |= PI_noWS &~ lex.QMark | pablo.Advance(PI_noWS) &~ PI_closer;
    500                         pablo.assert_0(PI_error, "Error in PI syntax");
    501                         ctCDPI_Callouts.PI_name_ends |= PI_name_end;
    502                         PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
    503                         ctCDPI_Callouts.PI_ends |= PI_Cursor;
    504                         CtCDPI_ends |= PI_Cursor;
    505                 }
    506                 # CDATA section processing
    507                 if (CD_Cursor) {
    508                         ctCDPI_Callouts.CD_starts |= CD_Cursor;
    509                         CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
    510                         ctCDPI_Callouts.CD_ends |= CD_Cursor;
    511                         CtCDPI_ends |= CD_Cursor;
    512                 }
    513                 # Comment processing
    514                 if (Ct_Cursor) {
    515                         ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
    516                         Ct_Cursor = pablo.Advance(Ct_Cursor); 
    517                         Ct_error = Ct_Cursor & ~ lex.Hyphen;
    518                         # Advance twice past <!--, so that we don't treat <!---
    519                         # as being a terminated comment.
    520                         Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
    521                         Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
    522                         pablo.assert_0(Ct_error | Ct_Cursor & ~ lex.RAngle, "Error in comment syntax");
    523                         ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
    524                         CtCDPI_ends |= Ct_Cursor;
    525                 }
    526                 # Common processing
    527                 CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor;
    528                 ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
    529 # '-' Not Supported.           
    530 #               ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends;
    531                 # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    532                 pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
    533                 CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)      ;
    534         }
    535 # '-' Not Supported.           
    536 #       check_streams.misc_mask = (lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends)  -(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
    537 #  Following is slow
    538         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;
    539 
    540 
    541         # Identify the remaining significant markers for XML processing.
    542         marker.LAngle_scope = LAngle_scope &~ ctCDPI_mask;
    543         marker.Ref_opener = lex.RefStart &~ ctCDPI_mask;
    544         marker.CD_closer = CD_closer &~ ctCDPI_mask;
    545 };
    546 
    547 function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    548        
    549         # Delimiters for scans.
    550         DQuoteDelim = lex.DQuote | lex.LAngle;
    551         SQuoteDelim = lex.SQuote | lex.LAngle;
    552         AttListDelim = lex.Slash | lex.RAngle;
    553        
    554         # Start the parallel parsing by inspecting the character
    555         # after the opening "<" of a tag.
    556         tag_Callouts.ElemName_starts = marker.LAngle_scope & ~lex.Slash;
    557         tag_Callouts.EndTag_marks = marker.LAngle_scope & lex.Slash;
    558        
    559         # Start Tag/Empty Element Tag Parsing
    560 
    561         # Advance all cursors by scanning through the tag name.
    562         tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    563         # Must have at least one name character for a legal start tag.
    564         # Mark any occurrences of null names as errors.
    565         ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends;
    566        
    567         # Initialize the accumulators for attribute name and value positions.
    568         tag_Callouts.AttName_starts = 0; 
    569         tag_Callouts.AttName_ends = 0;
    570         tag_Callouts.AttVal_starts = 0;
    571         tag_Callouts.AttVal_ends = 0;
    572 
    573         # After the element name, there may or may not be an attlist.
    574         if (tag_Callouts.ElemName_ends & lex.WS) {
    575                 AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    576                 AttListEnd = AfterWS & AttListDelim;
    577                 AttNameStart = AfterWS & ~AttListDelim;
    578                 #
    579                 # The following loop iterates through attributes within a start tag.
    580                 # Because all start tags are processed in parallel, the number of
    581                 # iterations is the maximum number of attributes found in any one
    582                 # start tag, plus one.
    583                 while (AttNameStart) {
    584                         ParseError |= AttNameStart &~ lex.NameScan;
    585                         tag_Callouts.AttName_starts |= AttNameStart;
    586                         AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
    587                         tag_Callouts.AttName_ends |= AttNameFollow;
    588                         # Scan through WS to the expected '=' delimiter.
    589                         # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    590                         # But use if test to optimize.
    591                         if (AttNameFollow & lex.WS) {
    592                                 EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
    593                         } else { EqExpected = AttNameFollow;
    594                         ParseError |= EqExpected &~ lex.Equals;
    595                         AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
    596 #                       AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
    597                         tag_Callouts.AttVal_starts |= AttValPos;
    598                         DQuoteAttVal = AttValPos & lex.DQuote;
    599                         SQuoteAttVal = AttValPos & lex.SQuote;
    600 #                       DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    601 #                       SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
    602                         DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
    603                         SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
    604                         AttValEnd = DQuoteAttEnd | SQuoteAttEnd;
    605                         ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote);
    606                         AttValFollow = pablo.Advance(AttValEnd);
    607                         tag_Callouts.AttVal_ends |= AttValFollow;
    608                         #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    609                         }
    610                         if (AttValFollow & lex.WS) {
    611                                 AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
    612                                 AttListEnd |= AfterWS & AttListDelim;
    613                                 AttNameStart = AfterWS & ~AttListDelim;
    614                         } else {
    615                                 AttListEnd |= AttValFollow & AttListDelim;     
    616                                 AttNameStart = 0;
    617                                 ParseError |= AttValFollow & ~AttListDelim;
    618                         }
    619                 }
    620         } else {
    621                 # No WS character after ElemName; must be at the end
    622                 AttListEnd = tag_Callouts.ElemName_ends & AttListDelim;
    623                 ParseError |= tag_Callouts.ElemName_ends & ~AttListDelim;
    624         }
    625        
    626         STagEnds = AttListEnd & lex.RAngle;
    627         # Mark any "/" characters found as the ends of empty element tags.
    628         tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash);
    629        
    630         ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle;
    631 
    632         # End Tag Parsing
    633 
    634         EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
    635         if (EndTagEnds & lex.WS) {
    636                 EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
    637         }
    638         ParseError |= EndTagEnds & ~lex.RAngle;
    639         pablo.assert_0(ParseError, "Tag parsing error found");
    640                
    641                
    642         # Attribute value spans
    643 #       tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
    644         tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
    645 };
    646 
    647 function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    648         ref_Callouts.GenRef_starts = 0;
    649         ref_Callouts.GenRef_ends = 0;
    650         ref_Callouts.DecRef_starts = 0;
    651         ref_Callouts.DecRef_ends = 0;
    652         ref_Callouts.HexRef_starts = 0;
    653         ref_Callouts.HexRef_ends = 0;
    654         ref_error = 0;
    655 
    656         # All remaining "&" must be reference start characters; parse them.
    657         if (marker.Ref_opener) {
    658                 Ref_scope = pablo.Advance(marker.Ref_opener);
    659                 NumRef2 = Ref_scope & lex.Hash;
    660                 ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash;
    661                 NumRef3 = pablo.Advance(NumRef2);
    662                 HexRef3 = NumRef3 & lex.x;
    663                 ref_Callouts.DecRef_starts = NumRef3 &~ lex.x;
    664                 ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
    665                 ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan);
    666                 ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
    667                 ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
    668                 # Error checks
    669                 # At least one digit required for DecRef, one hex digit for HexRef.
    670                 ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit;
    671                 ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex;
    672                 # Semicolon terminator required (also covers unterminated at EOF).
    673                 ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends;
    674                 ref_error3 = ref_ends &~ lex.Semicolon;
    675                 pablo.assert_0(ref_error1 | ref_error2 | ref_error3, "Reference error found");
    676         }               
    677 };
    678 
    679 function 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) {
    680 #       PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
    681 #       GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
    682 #       ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
    683 #       AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
    684         PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    685         GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
    686         ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    687         AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
    688         qname_stream =  ElemNames | AttNames;
    689         ncname_stream = PI_names | GenRefs;
    690         name_stream = qname_stream | ncname_stream;
    691         name_start = name_stream &~ pablo.Advance(name_stream);
    692         name_cursor = name_stream & ~pablo.Advance(name_stream);
    693         void_prefix_err = name_cursor & lex.Colon;
    694         namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon;
    695         local_part_start = pablo.Advance(namespace_sep);
    696         local_part_err = local_part_start &~ lex.NameScan;
    697         colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon;
    698         ncname_err = ncname_stream & lex.Colon;
    699         pablo.assert_0(void_prefix_err | local_part_err | colon2_err | ncname_err, "name syntax error");
    700                
    701                        
    702         check_streams.non_ascii_name_starts = name_start &~lex.ASCII_name_start;
    703         check_streams.non_ascii_names = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix;
    704    
    705 };   
    706    
    707 function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
    708         pablo.assert_0(marker.CD_closer & ~tag_Callouts.AttVal_spans, "Error: ]]> in text");
    709         check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts;
    710         check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends;
    711         check_streams.att_refs = tag_Callouts.AttVal_spans & marker.Ref_opener;
    712 };
    713 
    714 struct BasisBits {
    715         stream<1> b1;
    716         stream<1> b2;
    717         stream<1> b3;
    718         stream<1> b4;
    719 };
    720 struct BasisBits {
    721         stream b1;
    722         stream b2;
    723         stream b3;
    724         stream b4;
    725 };
    726 function void AssignmentExpressions() {
    727         temp4 = temp;
    728         temp4 &= temp1 | temp2;
    729         temp4 |= temp1 ^ temp2;
    730         temp4 ^= temp1 & temp2;
    731 };function void BasicExpressions() {
    732 
    733         temp4 = temp;
    734         temp4 = temp1 | temp2;
    735         temp4 = temp1 ^ temp2;
    736         temp4 = temp1 & temp2;
    737         temp4 = temp1 ^ temp2 | temp3;
    738         temp4 = temp1 | temp2 ^ temp3;
    739         temp4 = temp1 & temp2 | temp3;
    740         temp4 = temp1 | temp2 & temp3;
    741         temp4 = temp1 & (temp2 | temp3);
    742         temp4 = (temp1 | temp2) & temp3;
    743         temp4 = ~temp;
    744        
    745 };
    746 
    747 function void Assignments() {
    748         var stream s;
    749         s = 0;
    750         s &= 0;
    751         s |= 0;
    752         s ^= 0;
    753 };function struct A FunctionExpressions() {
    754          a.b.Advance();
    755 };
    756 function void RecordExpressions() {
    757 
    758         // records
    759         temp4 = temp1.temp2;
    760         temp4 = temp1.temp2.temp3;
    761        
    762         temp1.temp2 = temp4;
    763         temp1.temp2.temp3 = temp4;
    764                
    765 };function void Function() {
    766 var stream cursor = pablo.ScanToFirst(lex.opener);
    767 }function void localDecl() {
    768         var stream A;
    769         var stream A=0;
    770         var stream a=0,b=0,c=0;
    771 }function void localDecl() {
    772 
    773 var struct BasisBits {
    774 stream<1> b1;
    775 stream<1> b2;
    776 stream<1> b3;
    777 stream<1> b4;
    778 } A,B,C;
    779 
    780 };function void Assignments() {
    781         var stream s = 4;
    782         var stream s &= 4;
    783         var stream s |= 4;
    784         var stream s ^= 4;
    785 };function void localDecl() {
    786 
    787         var struct BasisBits {
    788         stream b1;
    789         stream b2;
    790         stream b3;
    791         stream b4;
    792         } A,B ;
    793 
    794 } function void Function() {   
    795        
    796         if(cursor & a) {
    797                 if(cursor & b) {
    798                
    799                 }
    800         }
    801        
    802 };
    803 function void Function() {     
    804        
    805         if(cursor & a) {
    806                 if(cursor & b) {
    807                
    808                 } else {
    809                
    810                 }
    811 
    812         } else {
    813 
    814         }
    815        
    816 };
    817 function void Function() {             
    818         if(cursor) {
    819 
    820         }
    821 };
    822 function void Function() {     
    823        
    824         if(cursor & a) {
    825 
    826         } else {
    827 
    828         }
    829        
    830 };
    831 /*
    832         Block comment.
    833 */
    834 
    835 // EOL terminated comment.
    836 
    837 // Another EOL terminated comment.
    838 
    839 function struct Lex ClassifyBytes(struct BasisBit basis) {};
    840 function stream Function(stream a, stream b, stream c) {};
    841 function void Lex() {};
    842 struct Lex {
    843         stream LAngle;
    844         stream RAngle;
    845 };
    846 
    847 typedef struct Lex Lex;
    848 
    849 typedef Lex Lex;typedef stream s;
    850 
    851 typedef stream<1> s1;typedef struct BasisBits {
    852 stream b1;
    853 stream b2;
    854 stream b3;
    855 stream b4;
    856 } BasisBitsAlias;# Demo - Hand ported Python pablo code (parses)
    857 #
    858 # Removed '-' operators.
    859 # Added statement terminators as needed ';'
    860 
    861 struct Basis_bits{     
    862         stream bit_0;
    863         stream bit_1;
    864         stream bit_2;
    865         stream bit_3;
    866         stream bit_4;
    867         stream bit_5;
    868         stream bit_6;
    869         stream bit_7;
    870 };
    871 
    872 struct u8 {
    873   stream unibyte;
    874   stream prefix;
    875   stream prefix2;
    876   stream prefix3;
    877   stream prefix4;
    878   stream suffix;
    879   stream badprefix;
    880   stream xE0;
    881   stream xED;
    882   stream xF0;
    883   stream xF4;
    884   stream xA0_xBF;
    885   stream x80_x9F;
    886   stream x90_xBF;
    887   stream x80_x8F;
    888   stream xEF;
    889   stream xBF;
    890   stream xBE;
    891   stream scope22;
    892   stream scope32;
    893   stream scope33;
    894   stream scope42;
    895   stream scope43;
    896   stream scope44;
    897   stream xE0_scope;
    898   stream xED_scope;
    899   stream xF0_scope;
    900   stream xF4_scope;
    901   stream xEF_scope;
    902 };
    903 
    904 struct Lex {
    905         stream CR;
    906         stream LF;
    907         stream HT;
    908         stream SP;
    909         stream CRLF;
    910         stream RefStart;
    911         stream Semicolon; 
    912         stream Colon;
    913         stream LAngle;
    914         stream RAngle;
    915         stream LBracket;
    916         stream RBracket;
    917         stream Exclam;
    918         stream QMark;
    919         stream Hyphen;
    920         stream Equals;
    921         stream SQuote;
    922         stream DQuote;
    923         stream Slash;
    924         stream Hash;
    925         stream x;
    926         stream ASCII_name_start;
    927         stream ASCII_name_char;
    928         stream NameScan;
    929         stream Digit;
    930         stream Hex;
    931         stream WS;
    932 };
    933 
    934 struct Marker {
    935         stream LAngle_scope;
    936         stream Ref_opener;
    937         stream CD_closer;
    938 };
    939 
    940 struct CtCDPI_Callouts{
    941         stream Ct_starts;
    942         stream Ct_ends;
    943         stream CD_starts;
    944         stream CD_ends;
    945         stream PI_starts;
    946         stream PI_name_starts;
    947         stream PI_name_ends;
    948         stream PI_ends;
    949 };
    950 
    951 struct Ref_Callouts{
    952         stream GenRef_starts;
    953         stream GenRef_ends;
    954         stream DecRef_starts;
    955         stream DecRef_ends;
    956         stream HexRef_starts;
    957         stream HexRef_ends;
    958 };
    959 
    960 struct Tag_Callouts{
    961         stream ElemName_starts;
    962         stream ElemName_ends;
    963         stream AttName_starts;
    964         stream AttName_ends;
    965         stream AttVal_starts;
    966         stream AttVal_ends;
    967         stream AttVal_spans;
    968         stream EmptyTag_marks;
    969         stream EndTag_marks;
    970 };
    971        
    972 struct Check_streams{
    973         stream misc_mask;
    974         stream non_ascii_name_starts;
    975         stream non_ascii_names;
    976         stream tag_marks;
    977         stream name_follows;
    978         stream att_refs;
    979 };
    980 
    981 function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) { 
    982         temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    983         temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
    984         temp3 = (temp2 &~ temp1);
    985         temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
    986         temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
    987         temp6 = (temp4 & temp5);
    988         lex.RefStart = (temp3 & temp6);
    989         temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
    990         temp8 = (temp7 &~ temp1);
    991         temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
    992         temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
    993         temp11 = (temp9 & temp10);
    994         lex.Semicolon = (temp8 & temp11);
    995         temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
    996         temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
    997         temp14 = (temp12 &~ temp13);
    998         lex.LAngle = (temp8 & temp14);
    999         temp15 = (temp12 & temp5);
    1000         lex.RAngle = (temp8 & temp15);
    1001         temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
    1002         temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
    1003         temp18 = (temp16 & temp17);
    1004         lex.LBracket = (temp18 & temp11);
    1005         temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
    1006         temp20 = (temp12 & temp19);
    1007         lex.RBracket = (temp18 & temp20);
    1008         temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
    1009         temp22 = (temp19 &~ temp21);
    1010         lex.Exclam = (temp3 & temp22);
    1011         temp23 = (temp12 & temp10);
    1012         lex.QMark = (temp8 & temp23);
    1013         lex.Hyphen = (temp3 & temp20);
    1014         lex.Equals = (temp8 & temp20);
    1015         temp24 = (temp4 & temp10);
    1016         lex.SQuote = (temp3 & temp24);
    1017         temp25 = (temp5 &~ temp21);
    1018         lex.DQuote = (temp3 & temp25);
    1019         lex.Slash = (temp3 & temp23);
    1020         temp26 = (temp10 &~ temp21);
    1021         lex.Hash = (temp3 & temp26);
    1022         temp27 = (temp16 & temp7);
    1023         temp28 = (temp9 &~ temp13);
    1024         lex.x = (temp27 & temp28);
    1025         temp29 = (temp9 & temp5);
    1026         lex.Colon = (temp8 & temp29);
    1027         temp30 = (temp18 & temp23);
    1028         temp31 = (temp30 | lex.Colon);
    1029         temp32 = (temp16 &~ basis_bits.bit_2);
    1030         temp33 = (basis_bits.bit_5 | temp10);
    1031         temp34 = (basis_bits.bit_4 & temp33);
    1032         temp35 = (~temp34);
    1033         temp36 = (temp21 | temp13);
    1034         temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
    1035         temp38 = (temp32 & temp37);
    1036         temp39 = (temp31 | temp38);
    1037         temp40 = (temp16 & basis_bits.bit_2);
    1038         temp41 = (temp40 & temp37);
    1039         lex.ASCII_name_start = (temp39 | temp41);
    1040         temp42 = (temp30 | lex.Hyphen);
    1041         temp43 = (temp3 & temp15);
    1042         temp44 = (temp42 | temp43);
    1043         temp45 = (temp8 &~ temp34);
    1044         temp46 = (temp44 | temp45);
    1045         temp47 = (temp46 | temp38);
    1046         lex.ASCII_name_char = (temp47 | temp41);
    1047         lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
    1048         temp48 = (temp1 | basis_bits.bit_2);
    1049         x00_x1F = (~temp48);
    1050         temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
    1051         temp50 = (temp1 | temp49);
    1052         lex.CR = (temp20 &~ temp50);
    1053         lex.LF = (temp29 &~ temp50);
    1054         temp51 = (temp9 & temp19);
    1055         lex.HT = (temp51 &~ temp50);
    1056         lex.SP = (temp3 &~ temp36);
    1057         temp52 = (temp20 | temp29);
    1058         temp53 = (temp52 | temp51);
    1059         temp54 = (temp53 &~ temp50);
    1060         lex.WS = (temp54 | lex.SP);
    1061         temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
    1062         temp56 = (basis_bits.bit_4 & temp55);
    1063         lex.Digit = (temp8 &~ temp56);
    1064         temp57 = (temp16 &~ temp49);
    1065         temp58 = (temp57 &~ basis_bits.bit_4);
    1066         temp59 = (~temp10);
    1067         temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
    1068         temp61 = (temp58 & temp60);
    1069         temp62 = (lex.Digit | temp61);
    1070         temp63 = (temp16 & temp2);
    1071         temp64 = (temp63 &~ basis_bits.bit_4);
    1072         temp65 = (temp64 & temp60);
    1073         lex.Hex = (temp62 | temp65);
    1074         lex_error = x00_x1F &~ lex.WS;
    1075         pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    1076                
    1077        
    1078         ### Validate_utf8(basis_bits, u8):
    1079         u8.unibyte = (~basis_bits.bit_0);
    1080         u8.suffix = 0;
    1081         u8_error = 0;
    1082         u8_FFFE_FFFF = 0;
    1083         u8anyscope = 0; #local
    1084         if (basis_bits.bit_0) {
    1085                 u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
    1086                 u8.prefix2 = (u8.prefix &~ basis_bits.bit_2);
    1087                 u8.prefix3 = (u8.prefix & temp2);
    1088                 u8.prefix4 = (u8.prefix & temp7);
    1089                 u8.suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
    1090                 temp66 = (u8.prefix &~ temp49);
    1091                 temp67 = (temp21 | basis_bits.bit_6);
    1092                 temp68 = (temp66 &~ temp67);
    1093                 temp69 = (basis_bits.bit_5 & temp13);
    1094                 temp70 = (basis_bits.bit_4 | temp69);
    1095                 temp71 = (u8.prefix4 & temp70);
    1096                 u8.badprefix = (temp68 | temp71);
    1097                 u8_error = u8.badprefix;
    1098                 u8.scope22 = pablo.Advance(u8.prefix2);
    1099                 u8anyscope = u8.scope22;
    1100                 if (u8.prefix3 | u8.prefix4) {
    1101                         xE0 = (u8.prefix3 &~ temp36);
    1102                         xED = (u8.prefix3 & temp20);
    1103                         xF0 = (u8.prefix4 &~ temp36);
    1104                         temp72 = (temp4 &~ temp13);
    1105                         xF4 = (u8.prefix4 & temp72);
    1106                         u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
    1107                         u8.x80_x9F = (u8.suffix &~ basis_bits.bit_2);
    1108                         u8.x90_xBF = (u8.suffix & temp49);
    1109                         u8.x80_x8F = (u8.suffix &~ temp49);
    1110                         xEF = (u8.prefix3 & temp23);
    1111                         temp73 = (u8.suffix & temp7);
    1112                         u8.xBF = (temp73 & temp23);
    1113                         u8.xBE = (temp73 & temp15);
    1114 #
    1115 
    1116 #                       scope3_32 = pablo.Advance32(u8.prefix3)
    1117 #                       scope4_32 = pablo.Advance32(u8.prefix4)
    1118 #                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
    1119 #                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
    1120 #                       u8.scope42 = interpose32(u8.prefix4, scope4_32, 1)
    1121 #                       u8.scope43 = interpose32(u8.prefix4, scope4_32, 2)
    1122 #                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
    1123 #
    1124                         u8.scope32 = pablo.Advance(u8.prefix3);
    1125                         u8.scope33 = pablo.Advance(u8.scope32);
    1126                         u8.scope42 = pablo.Advance(u8.prefix4);
    1127                         u8.scope43 = pablo.Advance(u8.scope42);
    1128                         u8.scope44 = pablo.Advance(u8.scope43);
    1129 #
    1130 #                       u8.xE0_scope = pablo.Advance(xE0);
    1131 #                       u8.xED_scope = pablo.Advance(xED);
    1132 #                       u8.xF0_scope = pablo.Advance(xF0);
    1133 #                       u8.xF4_scope = pablo.Advance(xF4);
    1134                         E0_F0_scope = pablo.Advance(xE0 | xF0);
    1135                         ED_F4_scope = pablo.Advance(xED | xF4);
    1136                         u8.xE0_scope = u8.scope32 & E0_F0_scope;
    1137                         u8.xED_scope = u8.scope32 & ED_F4_scope;
    1138                         u8.xF0_scope = u8.scope42 & E0_F0_scope;
    1139                         u8.xF4_scope = u8.scope42 & ED_F4_scope;
    1140                         u8.xEF_scope = pablo.Advance(xEF);
    1141 
    1142                         u8lastscope = u8.scope22 | u8.scope33 | u8.scope44;
    1143                         u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43;
    1144                
    1145                         u8error1 = u8.xE0_scope & u8.x80_x9F;
    1146                         u8error2 = u8.xED_scope & u8.xA0_xBF;
    1147                         u8error3 = u8.xF0_scope & u8.x80_x8F;
    1148                         u8error4 = u8.xF4_scope & u8.x90_xBF;
    1149        
    1150                         u8_error |= u8error1 | u8error2 | u8error3 | u8error4;
    1151 
    1152                         EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF);
    1153 
    1154                         u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
    1155                 }               
    1156                 u8mismatch = u8anyscope ^ u8.suffix;
    1157                 pablo.assert_0(u8_error | u8mismatch | u8_FFFE_FFFF, "UTF-8 error found");
    1158         }
    1159 };
    1160 
    1161 function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    1162         ctCDPI_Callouts.Ct_starts = 0;
    1163         ctCDPI_Callouts.Ct_ends = 0;
    1164         ctCDPI_Callouts.CD_starts = 0;
    1165         ctCDPI_Callouts.CD_ends = 0;
    1166         ctCDPI_Callouts.PI_starts = 0;
    1167         ctCDPI_Callouts.PI_name_starts = 0;
    1168         ctCDPI_Callouts.PI_name_ends = 0;
    1169         ctCDPI_Callouts.PI_ends = 0;
    1170         CtCDPI_starts = 0;
    1171         CtCDPI_ends = 0;
    1172         ctCDPI_mask = 0;
    1173 
    1174         v = lex.LAngle | lex.Hyphen;
    1175         w = lex.Hyphen | lex.QMark;
    1176         v1 = pablo.Advance(v,1);
    1177         w1 = pablo.Advance(w,1);
    1178        
    1179         LAngle_scope = v1 &~ w1;  #pablo.Advance(lex.LAngle);
    1180         PI_opener = LAngle_scope & lex.QMark;
    1181         CtCD_opener= LAngle_scope & lex.Exclam;
    1182         CtCDPI_opener = PI_opener | CtCD_opener;
    1183 
    1184         #DoubleHyphen = 0;
    1185         CD_closer = 0;
    1186         #PI_closer = 0;
    1187        
    1188         #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
    1189         DoubleHyphen = v1 & w1 & lex.Hyphen;
    1190         if (lex.RBracket) {
    1191                 DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket;
    1192                 CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle;
    1193         }
    1194         #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
    1195         PI_closer = w1 & ~v1 & lex.RAngle;
    1196 
    1197         #
    1198         # Initiate the scan
    1199         CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
    1200         while (CtCDPI_Cursor) {
    1201                 CtCDPI_starts |= CtCDPI_Cursor;
    1202                 PI_Cursor = CtCDPI_Cursor & PI_opener;
    1203                 CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor);
    1204                 CD_Cursor = CD_Ct_Cursor & lex.LBracket;
    1205                 Ct_Cursor = CD_Ct_Cursor & lex.Hyphen ;
    1206                 # PI processing
    1207                 if (PI_Cursor) {
    1208                         ctCDPI_Callouts.PI_starts |= PI_Cursor;
    1209                         PI_Cursor = pablo.Advance(PI_Cursor);
    1210                         ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
    1211                         PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
    1212                         PI_error = PI_Cursor & PI_name_end;
    1213                         PI_noWS = PI_name_end & ~ lex.WS;
    1214                         PI_error |= PI_noWS &~ lex.QMark | pablo.Advance(PI_noWS) &~ PI_closer;
    1215                         pablo.assert_0(PI_error, "Error in PI syntax");
    1216                         ctCDPI_Callouts.PI_name_ends |= PI_name_end;
    1217                         PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
    1218                         ctCDPI_Callouts.PI_ends |= PI_Cursor;
    1219                         CtCDPI_ends |= PI_Cursor;
    1220                 }
    1221                 # CDATA section processing
    1222                 if (CD_Cursor) {
    1223                         ctCDPI_Callouts.CD_starts |= CD_Cursor;
    1224                         CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
    1225                         ctCDPI_Callouts.CD_ends |= CD_Cursor;
    1226                         CtCDPI_ends |= CD_Cursor;
    1227                 }
    1228                 # Comment processing
    1229                 if (Ct_Cursor) {
    1230                         ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
    1231                         Ct_Cursor = pablo.Advance(Ct_Cursor); 
    1232                         Ct_error = Ct_Cursor & ~ lex.Hyphen;
    1233                         # Advance twice past <!--, so that we don't treat <!---
    1234                         # as being a terminated comment.
    1235                         Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
    1236                         Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
    1237                         pablo.assert_0(Ct_error | Ct_Cursor & ~ lex.RAngle, "Error in comment syntax");
    1238                         ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
    1239                         CtCDPI_ends |= Ct_Cursor;
    1240                 }
    1241                 # Common processing
    1242                 CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor;
    1243                 ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
    1244 # '-' Not Supported.           
    1245 #               ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends;
    1246                 # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    1247                 pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
    1248                 CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)      ;
    1249         }
    1250 # '-' Not Supported.           
    1251 #       check_streams.misc_mask = (lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends)  -(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
    1252 #  Following is slow
    1253         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;
    1254 
    1255 
    1256         # Identify the remaining significant markers for XML processing.
    1257         marker.LAngle_scope = LAngle_scope &~ ctCDPI_mask;
    1258         marker.Ref_opener = lex.RefStart &~ ctCDPI_mask;
    1259         marker.CD_closer = CD_closer &~ ctCDPI_mask;
    1260 };
    1261 
    1262 function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    1263        
    1264         # Delimiters for scans.
    1265         DQuoteDelim = lex.DQuote | lex.LAngle;
    1266         SQuoteDelim = lex.SQuote | lex.LAngle;
    1267         AttListDelim = lex.Slash | lex.RAngle;
    1268        
    1269         # Start the parallel parsing by inspecting the character
    1270         # after the opening "<" of a tag.
    1271         tag_Callouts.ElemName_starts = marker.LAngle_scope & ~lex.Slash;
    1272         tag_Callouts.EndTag_marks = marker.LAngle_scope & lex.Slash;
    1273        
    1274         # Start Tag/Empty Element Tag Parsing
    1275 
    1276         # Advance all cursors by scanning through the tag name.
    1277         tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    1278         # Must have at least one name character for a legal start tag.
    1279         # Mark any occurrences of null names as errors.
    1280         ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends;
    1281        
    1282         # Initialize the accumulators for attribute name and value positions.
    1283         tag_Callouts.AttName_starts = 0; 
    1284         tag_Callouts.AttName_ends = 0;
    1285         tag_Callouts.AttVal_starts = 0;
    1286         tag_Callouts.AttVal_ends = 0;
    1287 
    1288         # After the element name, there may or may not be an attlist.
    1289         if (tag_Callouts.ElemName_ends & lex.WS) {
    1290                 AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    1291                 AttListEnd = AfterWS & AttListDelim;
    1292                 AttNameStart = AfterWS & ~AttListDelim;
    1293                 #
    1294                 # The following loop iterates through attributes within a start tag.
    1295                 # Because all start tags are processed in parallel, the number of
    1296                 # iterations is the maximum number of attributes found in any one
    1297                 # start tag, plus one.
    1298                 while (AttNameStart) {
    1299                         ParseError |= AttNameStart &~ lex.NameScan;
    1300                         tag_Callouts.AttName_starts |= AttNameStart;
    1301                         AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
    1302                         tag_Callouts.AttName_ends |= AttNameFollow;
    1303                         # Scan through WS to the expected '=' delimiter.
    1304                         # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    1305                         # But use if test to optimize.
    1306                         if (AttNameFollow & lex.WS) {
    1307                                 EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
    1308                         } else { EqExpected = AttNameFollow;
    1309                         ParseError |= EqExpected &~ lex.Equals;
    1310                         AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
    1311 #                       AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
    1312                         tag_Callouts.AttVal_starts |= AttValPos;
    1313                         DQuoteAttVal = AttValPos & lex.DQuote;
    1314                         SQuoteAttVal = AttValPos & lex.SQuote;
    1315 #                       DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    1316 #                       SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
    1317                         DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
    1318                         SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
    1319                         AttValEnd = DQuoteAttEnd | SQuoteAttEnd;
    1320                         ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote);
    1321                         AttValFollow = pablo.Advance(AttValEnd);
    1322                         tag_Callouts.AttVal_ends |= AttValFollow;
    1323                         #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    1324                         }
    1325                         if (AttValFollow & lex.WS) {
    1326                                 AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
    1327                                 AttListEnd |= AfterWS & AttListDelim;
    1328                                 AttNameStart = AfterWS & ~AttListDelim;
    1329                         } else {
    1330                                 AttListEnd |= AttValFollow & AttListDelim;     
    1331                                 AttNameStart = 0;
    1332                                 ParseError |= AttValFollow & ~AttListDelim;
    1333                         }
    1334                 }
    1335         } else {
    1336                 # No WS character after ElemName; must be at the end
    1337                 AttListEnd = tag_Callouts.ElemName_ends & AttListDelim;
    1338                 ParseError |= tag_Callouts.ElemName_ends & ~AttListDelim;
    1339         }
    1340        
    1341         STagEnds = AttListEnd & lex.RAngle;
    1342         # Mark any "/" characters found as the ends of empty element tags.
    1343         tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash);
    1344        
    1345         ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle;
    1346 
    1347         # End Tag Parsing
    1348 
    1349         EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
    1350         if (EndTagEnds & lex.WS) {
    1351                 EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
    1352         }
    1353         ParseError |= EndTagEnds & ~lex.RAngle;
    1354         pablo.assert_0(ParseError, "Tag parsing error found");
    1355                
    1356                
    1357         # Attribute value spans
    1358 #       tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
    1359         tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
    1360 };
    1361 
    1362 function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    1363         ref_Callouts.GenRef_starts = 0;
    1364         ref_Callouts.GenRef_ends = 0;
    1365         ref_Callouts.DecRef_starts = 0;
    1366         ref_Callouts.DecRef_ends = 0;
    1367         ref_Callouts.HexRef_starts = 0;
    1368         ref_Callouts.HexRef_ends = 0;
    1369         ref_error = 0;
    1370 
    1371         # All remaining "&" must be reference start characters; parse them.
    1372         if (marker.Ref_opener) {
    1373                 Ref_scope = pablo.Advance(marker.Ref_opener);
    1374                 NumRef2 = Ref_scope & lex.Hash;
    1375                 ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash;
    1376                 NumRef3 = pablo.Advance(NumRef2);
    1377                 HexRef3 = NumRef3 & lex.x;
    1378                 ref_Callouts.DecRef_starts = NumRef3 &~ lex.x;
    1379                 ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
    1380                 ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan);
    1381                 ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
    1382                 ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
    1383                 # Error checks
    1384                 # At least one digit required for DecRef, one hex digit for HexRef.
    1385                 ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit;
    1386                 ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex;
    1387                 # Semicolon terminator required (also covers unterminated at EOF).
    1388                 ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends;
    1389                 ref_error3 = ref_ends &~ lex.Semicolon;
    1390                 pablo.assert_0(ref_error1 | ref_error2 | ref_error3, "Reference error found");
    1391         }               
    1392 };
    1393 
    1394 function 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) {
    1395 #       PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
    1396 #       GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
    1397 #       ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
    1398 #       AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
    1399         PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    1400         GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
    1401         ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    1402         AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
    1403         qname_stream =  ElemNames | AttNames;
    1404         ncname_stream = PI_names | GenRefs;
    1405         name_stream = qname_stream | ncname_stream;
    1406         name_start = name_stream &~ pablo.Advance(name_stream);
    1407         name_cursor = name_stream & ~pablo.Advance(name_stream);
    1408         void_prefix_err = name_cursor & lex.Colon;
    1409         namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon;
    1410         local_part_start = pablo.Advance(namespace_sep);
    1411         local_part_err = local_part_start &~ lex.NameScan;
    1412         colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon;
    1413         ncname_err = ncname_stream & lex.Colon;
    1414         pablo.assert_0(void_prefix_err | local_part_err | colon2_err | ncname_err, "name syntax error");
    1415                
    1416                        
    1417         check_streams.non_ascii_name_starts = name_start &~lex.ASCII_name_start;
    1418         check_streams.non_ascii_names = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix;
    1419    
    1420 };   
    1421    
    1422 function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
    1423         pablo.assert_0(marker.CD_closer & ~tag_Callouts.AttVal_spans, "Error: ]]> in text");
    1424         check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts;
    1425         check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends;
    1426         check_streams.att_refs = tag_Callouts.AttVal_spans & marker.Ref_opener;
    1427 };
    1428 
  • proto/pablo/input/test/pablo/statements/assign/assign5.pablo.exclude

    r2623 r2624  
    22       
    33        // tuples
    4         /*
    5         temp4 = temp[0];
    6         temp4 = temp.temp1[0];
    7         temp4 = temp[0].temp1[1];
    8         temp4 = temp.temp1[0].temp3;
    94       
    10         temp[0] = temp4;
    11         temp.temp1[0] = temp4;
    12         temp[0].temp1[1] = temp4;
    13         temp.temp1[0].temp3 = temp4;
    14         */
     5        // temp4 = temp[0];
     6        // temp4 = temp.temp1[0];
     7        // temp4 = temp[0].temp1[1];
     8        // temp4 = temp.temp1[0].temp3;
     9       
     10        // temp[0] = temp4;
     11        // temp.temp1[0] = temp4;
     12        // temp[0].temp1[1] = temp4;
     13        // temp.temp1[0].temp3 = temp4;
     14
    1515};
  • proto/pablo/input/test/pablo/statements/if/if1.pablo

    r2368 r2624  
    33
    44        }
    5 };
     5}
  • proto/pablo/input/test/pablo/statements/if/if2.pablo

    r2368 r2624  
    77        }
    88       
    9 };
     9}
  • proto/pablo/input/test/pablo/statements/if/if3.pablo

    r2368 r2624  
    77        }
    88       
    9 };
     9}
  • proto/pablo/input/test/pablo/statements/if/if4.pablo

    r2368 r2624  
    1212        }
    1313       
    14 };
     14}
  • proto/pablo/input/test/pablo/statements/localDecl/localDecl1.pablo

    r2364 r2624  
    66        stream b3;
    77        stream b4;
    8         } A,B ;
     8        } A;
    99
    1010}
  • proto/pablo/input/test/pablo/statements/localDecl/localDecl2.pablo

    r2364 r2624  
    66stream<1> b3;
    77stream<1> b4;
    8 } A,B,C;
     8} A;
    99
    1010};
  • proto/pablo/input/test/pablo/statements/localDecl/localDecl4.pablo

    r2623 r2624  
    11function void localDecl() {
    22        var stream A;
    3 //      var stream A=0;
    4 //      var stream a=0,b=0,c=0; // TODO - add test cases for variable decls list
     3        var stream A=0;
    54}
  • proto/pablo/input/test/pablo/statements/localDecl/localDecl5.pablo

    r2623 r2624  
    55//      var stream s ~= 4;
    66        var stream s ^= 4;
    7 };
     7}
  • proto/pablo/input/test/pablo/statements/while/while1.pablo.exclude

    r2374 r2624  
    77                cursor = cursor &~ terminator;
    88        };
    9 };
     9}
  • proto/pablo/input/test/pablo/statements/while/while2.pablo.exclude

    r2374 r2624  
    66                while(cursor2) {
    77                        cursor = pablo.Advance(cursor);
    8                         cursor = cursor &~ terminator;
     8                        // cursor = cursor &~ terminator;
    99                }
    1010        }
    11 };
     11}
Note: See TracChangeset for help on using the changeset viewer.