Changeset 2623


Ignore:
Timestamp:
Nov 7, 2012, 7:50:47 PM (6 years ago)
Author:
ksherdy
Message:

Removed unsupported syntax from test cases.

Location:
proto/pablo/input/test/pablo
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/test/pablo/decl/decl3.pablo.exclude

    r2374 r2623  
    1 tuple Streams (stream, stream);
    2 tuple Streams (stream<1>, stream<8>);
     1//tuple Streams (stream, stream);
     2//tuple Streams (stream<1>, stream<8>);
  • proto/pablo/input/test/pablo/funcDef/funcDef4.pablo.exclude

    r2374 r2623  
    1 function tuple T Foo(stream a, stream b) {};
     1//function tuple T Foo(stream a, stream b) {};
  • proto/pablo/input/test/pablo/scratch/test.pablo

    r2415 r2623  
    1 function void Test() {
    2         simd_or(A,B);
    3 }
     1struct BasisBits {
     2        stream<1> b1;
     3        stream<1> b2;
     4        stream<1> b3;
     5        stream<1> b4;
     6};
     7struct BasisBits {
     8        stream b1;
     9        stream b2;
     10        stream b3;
     11        stream b4;
     12};
     13function 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
     32function 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};
     41function 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() {
     51var 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
     58var struct BasisBits {
     59stream<1> b1;
     60stream<1> b2;
     61stream<1> b3;
     62stream<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};
     88function void Function() {     
     89       
     90        if(cursor & a) {
     91                if(cursor & b) {
     92               
     93                } else {
     94               
     95                }
     96
     97        } else {
     98
     99        }
     100       
     101};
     102function void Function() {             
     103        if(cursor) {
     104
     105        }
     106};
     107function 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
     124function struct Lex ClassifyBytes(struct BasisBit basis) {};
     125function stream Function(stream a, stream b, stream c) {};
     126function void Lex() {};
     127struct Lex {
     128        stream LAngle;
     129        stream RAngle;
     130};
     131
     132typedef struct Lex Lex;
     133
     134typedef Lex Lex;typedef stream s;
     135
     136typedef stream<1> s1;typedef struct BasisBits {
     137stream b1;
     138stream b2;
     139stream b3;
     140stream b4;
     141} BasisBitsAlias;# Demo - Hand ported Python pablo code (parses)
     142#
     143# Removed '-' operators.
     144# Added statement terminators as needed ';'
     145
     146struct 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
     157struct 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
     189struct 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
     219struct Marker {
     220        stream LAngle_scope;
     221        stream Ref_opener;
     222        stream CD_closer;
     223};
     224
     225struct 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
     236struct 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
     245struct 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       
     257struct 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
     266function 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
     446function 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
     547function 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
     647function 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
     679function 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   
     707function 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
     714struct BasisBits {
     715        stream<1> b1;
     716        stream<1> b2;
     717        stream<1> b3;
     718        stream<1> b4;
     719};
     720struct BasisBits {
     721        stream b1;
     722        stream b2;
     723        stream b3;
     724        stream b4;
     725};
     726function 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
     747function 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};
     756function 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() {
     766var 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
     773var struct BasisBits {
     774stream<1> b1;
     775stream<1> b2;
     776stream<1> b3;
     777stream<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};
     803function void Function() {     
     804       
     805        if(cursor & a) {
     806                if(cursor & b) {
     807               
     808                } else {
     809               
     810                }
     811
     812        } else {
     813
     814        }
     815       
     816};
     817function void Function() {             
     818        if(cursor) {
     819
     820        }
     821};
     822function 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
     839function struct Lex ClassifyBytes(struct BasisBit basis) {};
     840function stream Function(stream a, stream b, stream c) {};
     841function void Lex() {};
     842struct Lex {
     843        stream LAngle;
     844        stream RAngle;
     845};
     846
     847typedef struct Lex Lex;
     848
     849typedef Lex Lex;typedef stream s;
     850
     851typedef stream<1> s1;typedef struct BasisBits {
     852stream b1;
     853stream b2;
     854stream b3;
     855stream b4;
     856} BasisBitsAlias;# Demo - Hand ported Python pablo code (parses)
     857#
     858# Removed '-' operators.
     859# Added statement terminators as needed ';'
     860
     861struct 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
     872struct 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
     904struct 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
     934struct Marker {
     935        stream LAngle_scope;
     936        stream Ref_opener;
     937        stream CD_closer;
     938};
     939
     940struct 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
     951struct 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
     960struct 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       
     972struct 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
     981function 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
     1161function 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
     1262function 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
     1362function 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
     1394function 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   
     1422function 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/assign1.pablo

    r2368 r2623  
    44        s &= 0;
    55        s |= 0;
    6         s ~= 0;
     6//      s ~= 0;
    77        s ^= 0;
    88};
  • proto/pablo/input/test/pablo/statements/assign/assign2.pablo

    r2368 r2623  
    1111        temp4 = temp1 & (temp2 | temp3);
    1212        temp4 = (temp1 | temp2) & temp3;
    13         temp4 = ~temp;
     13//      temp4 = ~temp;
    1414       
    1515};
  • proto/pablo/input/test/pablo/statements/assign/assign3.pablo

    r2368 r2623  
    55        temp4 |= temp1 ^ temp2;
    66        temp4 ^= temp1 & temp2;
    7         temp4 ~= temp1 ^ temp2 | temp3;
     7//      temp4 ~= temp1 ^ temp2 | temp3;
    88};
  • proto/pablo/input/test/pablo/statements/assign/assign5.pablo.exclude

    r2374 r2623  
    22       
    33        // tuples
     4        /*
    45        temp4 = temp[0];
    56        temp4 = temp.temp1[0];
     
    1112        temp[0].temp1[1] = temp4;
    1213        temp.temp1[0].temp3 = temp4;
    13 
     14        */
    1415};
  • proto/pablo/input/test/pablo/statements/localDecl/localDecl3.pablo.exclude

    r2374 r2623  
    11function void localDecl() {
    22
    3 var tuple Streams (stream, stream) A;
    4 var tuple Streams (stream<1>, stream<8>) A;
     3//var tuple Streams (stream, stream) A;
     4//var tuple Streams (stream<1>, stream<8>) A;
    55
    66}
  • proto/pablo/input/test/pablo/statements/localDecl/localDecl4.pablo

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

    r2368 r2623  
    33        var stream s &= 4;
    44        var stream s |= 4;
    5         var stream s ~= 4;
     5//      var stream s ~= 4;
    66        var stream s ^= 4;
    77};
  • proto/pablo/input/test/pablo/typedef/typedef2.pablo.exclude

    r2374 r2623  
    1 typedef tuple Streams (stream, stream) streamsAlias;
     1//typedef tuple Streams (stream, stream) streamsAlias;
    22
    3 typedef tuple Streams (stream<1>, stream<8>) streamsAlias ;
     3//typedef tuple Streams (stream<1>, stream<8>) streamsAlias ;
Note: See TracChangeset for help on using the changeset viewer.