Changeset 2641


Ignore:
Timestamp:
Nov 18, 2012, 4:38:40 PM (6 years ago)
Author:
ksherdy
Message:

Added print_register visitor. Updated test suite. Minor visitor fixes.

Location:
proto/pablo
Files:
1 added
14 edited
5 moved

Legend:

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

    r2624 r2641  
    6363nodes {
    6464  binaryOperator {} [expression, expression1],//, expression4],
    65   unaryOperator {} [expression2,],// expression5],
     65  unaryOperator {} [expression2],// expression5],
    6666  assignment {} [assignmentRest],
    6767  functionInvocation {} [functionInvocationRest],
     
    136136        //
    137137        // e x p r e s s i o n s
    138         //
     138        //     
    139139        expression              #->     expression1 ((OR^|XOR^) expression)? ;
    140140                                       
  • proto/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude

    r2624 r2641  
    1 
    2 
    3 struct Basis_bits{
    4     stream<1> bit_0;
    5     stream<1> bit_1;
    6     stream<1> bit_2;
    7     stream<1> bit_3;
    8     stream<1> bit_4;
    9     stream<1> bit_5;
    10     stream<1> bit_6;
    11     stream<1> bit_7;
    12 };
    13 
    14 struct u8{
    15     stream<1> unibyte;
    16     stream<1> prefix;
    17     stream<1> prefix2;
    18     stream<1> prefix3;
    19     stream<1> prefix4;
    20     stream<1> suffix;
    21     stream<1> badprefix;
    22     stream<1> xE0;
    23     stream<1> xED;
    24     stream<1> xF0;
    25     stream<1> xF4;
    26     stream<1> xA0_xBF;
    27     stream<1> x80_x9F;
    28     stream<1> x90_xBF;
    29     stream<1> x80_x8F;
    30     stream<1> xEF;
    31     stream<1> xBF;
    32     stream<1> xBE;
    33     stream<1> scope22;
    34     stream<1> scope32;
    35     stream<1> scope33;
    36     stream<1> scope42;
    37     stream<1> scope43;
    38     stream<1> scope44;
    39     stream<1> xE0_scope;
    40     stream<1> xED_scope;
    41     stream<1> xF0_scope;
    42     stream<1> xF4_scope;
    43     stream<1> xEF_scope;
    44 };
    45 
    46 struct Lex{
    47     stream<1> CR;
    48     stream<1> LF;
    49     stream<1> HT;
    50     stream<1> SP;
    51     stream<1> CRLF;
    52     stream<1> RefStart;
    53     stream<1> Semicolon;
    54     stream<1> Colon;
    55     stream<1> LAngle;
    56     stream<1> RAngle;
    57     stream<1> LBracket;
    58     stream<1> RBracket;
    59     stream<1> Exclam;
    60     stream<1> QMark;
    61     stream<1> Hyphen;
    62     stream<1> Equals;
    63     stream<1> SQuote;
    64     stream<1> DQuote;
    65     stream<1> Slash;
    66     stream<1> Hash;
    67     stream<1> x;
    68     stream<1> ASCII_name_start;
    69     stream<1> ASCII_name_char;
    70     stream<1> NameScan;
    71     stream<1> Digit;
    72     stream<1> Hex;
    73     stream<1> WS;
    74 };
    75 
    76 struct Marker{
    77     stream<1> LAngle_scope;
    78     stream<1> Ref_opener;
    79     stream<1> CD_closer;
    80 };
    81 
    82 struct CtCDPI_Callouts{
    83     stream<1> Ct_starts;
    84     stream<1> Ct_ends;
    85     stream<1> CD_starts;
    86     stream<1> CD_ends;
    87     stream<1> PI_starts;
    88     stream<1> PI_name_starts;
    89     stream<1> PI_name_ends;
    90     stream<1> PI_ends;
    91 };
    92 
    93 struct Ref_Callouts{
    94     stream<1> GenRef_starts;
    95     stream<1> GenRef_ends;
    96     stream<1> DecRef_starts;
    97     stream<1> DecRef_ends;
    98     stream<1> HexRef_starts;
    99     stream<1> HexRef_ends;
    100 };
    101 
    102 struct Tag_Callouts{
    103     stream<1> ElemName_starts;
    104     stream<1> ElemName_ends;
    105     stream<1> AttName_starts;
    106     stream<1> AttName_ends;
    107     stream<1> AttVal_starts;
    108     stream<1> AttVal_ends;
    109     stream<1> AttVal_spans;
    110     stream<1> EmptyTag_marks;
    111     stream<1> EndTag_marks;
    112 };
    113 
    114 struct Check_streams{
    115     stream<1> misc_mask;
    116     stream<1> non_ascii_name_starts;
    117     stream<1> non_ascii_names;
    118     stream<1> tag_marks;
    119     stream<1> name_follows;
    120     stream<1> att_refs;
    121 };
    122 
    123 function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
    124     var stream<1> temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    125     var stream<1> temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
    126     var stream<1> temp3 = (temp2 & (~ temp1));
    127     var stream<1> temp4 = (basis_bits.bit_5 & (~ basis_bits.bit_4));
    128     var stream<1> temp5 = (basis_bits.bit_6 & (~ basis_bits.bit_7));
    129     var stream<1> temp6 = (temp4 & temp5);
    130     lex.RefStart = (temp3 & temp6);
    131     var stream<1> temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
    132     var stream<1> temp8 = (temp7 & (~ temp1));
    133     var stream<1> temp9 = (basis_bits.bit_4 & (~ basis_bits.bit_5));
    134     var stream<1> temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
    135     var stream<1> temp11 = (temp9 & temp10);
    136     lex.Semicolon = (temp8 & temp11);
    137     var stream<1> temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
    138     var stream<1> temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
    139     var stream<1> temp14 = (temp12 & (~ temp13));
    140     lex.LAngle = (temp8 & temp14);
    141     var stream<1> temp15 = (temp12 & temp5);
    142     lex.RAngle = (temp8 & temp15);
    143     var stream<1> temp16 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    144     var stream<1> temp17 = (basis_bits.bit_3 & (~ basis_bits.bit_2));
    145     var stream<1> temp18 = (temp16 & temp17);
    146     lex.LBracket = (temp18 & temp11);
    147     var stream<1> temp19 = (basis_bits.bit_7 & (~ basis_bits.bit_6));
    148     var stream<1> temp20 = (temp12 & temp19);
    149     lex.RBracket = (temp18 & temp20);
    150     var stream<1> temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
    151     var stream<1> temp22 = (temp19 & (~ temp21));
    152     lex.Exclam = (temp3 & temp22);
    153     var stream<1> temp23 = (temp12 & temp10);
    154     lex.QMark = (temp8 & temp23);
    155     lex.Hyphen = (temp3 & temp20);
    156     lex.Equals = (temp8 & temp20);
    157     var stream<1> temp24 = (temp4 & temp10);
    158     lex.SQuote = (temp3 & temp24);
    159     var stream<1> temp25 = (temp5 & (~ temp21));
    160     lex.DQuote = (temp3 & temp25);
    161     lex.Slash = (temp3 & temp23);
    162     var stream<1> temp26 = (temp10 & (~ temp21));
    163     lex.Hash = (temp3 & temp26);
    164     var stream<1> temp27 = (temp16 & temp7);
    165     var stream<1> temp28 = (temp9 & (~ temp13));
    166     lex.x = (temp27 & temp28);
    167     var stream<1> temp29 = (temp9 & temp5);
    168     lex.Colon = (temp8 & temp29);
    169     var stream<1> temp30 = (temp18 & temp23);
    170     var stream<1> temp31 = (temp30 | lex.Colon);
    171     var stream<1> temp32 = (temp16 & (~ basis_bits.bit_2));
    172     var stream<1> temp33 = (basis_bits.bit_5 | temp10);
    173     var stream<1> temp34 = (basis_bits.bit_4 & temp33);
    174     var stream<1> temp35 = (~ temp34);
    175     var stream<1> temp36 = (temp21 | temp13);
    176     var stream<1> temp37 = ((basis_bits.bit_3 & temp35) | ((~ basis_bits.bit_3) & temp36));
    177     var stream<1> temp38 = (temp32 & temp37);
    178     var stream<1> temp39 = (temp31 | temp38);
    179     var stream<1> temp40 = (temp16 & basis_bits.bit_2);
    180     var stream<1> temp41 = (temp40 & temp37);
    181     lex.ASCII_name_start = (temp39 | temp41);
    182     var stream<1> temp42 = (temp30 | lex.Hyphen);
    183     var stream<1> temp43 = (temp3 & temp15);
    184     var stream<1> temp44 = (temp42 | temp43);
    185     var stream<1> temp45 = (temp8 & (~ temp34));
    186     var stream<1> temp46 = (temp44 | temp45);
    187     var stream<1> temp47 = (temp46 | temp38);
    188     lex.ASCII_name_char = (temp47 | temp41);
    189     lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
    190     var stream<1> temp48 = (temp1 | basis_bits.bit_2);
    191     var stream<1> x00_x1F = (~ temp48);
    192     var stream<1> temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
    193     var stream<1> temp50 = (temp1 | temp49);
    194     lex.CR = (temp20 & (~ temp50));
    195     lex.LF = (temp29 & (~ temp50));
    196     var stream<1> temp51 = (temp9 & temp19);
    197     lex.HT = (temp51 & (~ temp50));
    198     lex.SP = (temp3 & (~ temp36));
    199     var stream<1> temp52 = (temp20 | temp29);
    200     var stream<1> temp53 = (temp52 | temp51);
    201     var stream<1> temp54 = (temp53 & (~ temp50));
    202     lex.WS = (temp54 | lex.SP);
    203     var stream<1> temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
    204     var stream<1> temp56 = (basis_bits.bit_4 & temp55);
    205     lex.Digit = (temp8 & (~ temp56));
    206     var stream<1> temp57 = (temp16 & (~ temp49));
    207     var stream<1> temp58 = (temp57 & (~ basis_bits.bit_4));
    208     var stream<1> temp59 = (~ temp10);
    209     var stream<1> temp60 = ((basis_bits.bit_5 & temp59) | ((~ basis_bits.bit_5) & temp13));
    210     var stream<1> temp61 = (temp58 & temp60);
    211     var stream<1> temp62 = (lex.Digit | temp61);
    212     var stream<1> temp63 = (temp16 & temp2);
    213     var stream<1> temp64 = (temp63 & (~ basis_bits.bit_4));
    214     var stream<1> temp65 = (temp64 & temp60);
    215     lex.Hex = (temp62 | temp65);
    216     var stream<1> lex_error = (x00_x1F & (~ lex.WS));
    217     pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    218     u8.unibyte = (~ basis_bits.bit_0);
    219     u8.suffix = 0;
    220     var stream<1> u8_error = 0;
    221     var stream<1> u8_FFFE_FFFF = 0;
    222     var stream<1> u8anyscope = 0;
    223     if (basis_bits.bit_0) {
    224         u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
    225         u8.prefix2 = (u8.prefix & (~ basis_bits.bit_2));
    226         u8.prefix3 = (u8.prefix & temp2);
    227         u8.prefix4 = (u8.prefix & temp7);
    228         u8.suffix = (basis_bits.bit_0 & (~ basis_bits.bit_1));
    229         var stream<1> temp66 = (u8.prefix & (~ temp49));
    230         var stream<1> temp67 = (temp21 | basis_bits.bit_6);
    231         var stream<1> temp68 = (temp66 & (~ temp67));
    232         var stream<1> temp69 = (basis_bits.bit_5 & temp13);
    233         var stream<1> temp70 = (basis_bits.bit_4 | temp69);
    234         var stream<1> temp71 = (u8.prefix4 & temp70);
    235         u8.badprefix = (temp68 | temp71);
    236         u8_error = u8.badprefix;
    237         u8.scope22 = pablo.Advance(u8.prefix2);
    238         u8anyscope = u8.scope22;
    239         if ((u8.prefix3 | u8.prefix4)) {
    240             var stream<1> xE0 = (u8.prefix3 & (~ temp36));
    241             var stream<1> xED = (u8.prefix3 & temp20);
    242             var stream<1> xF0 = (u8.prefix4 & (~ temp36));
    243             var stream<1> temp72 = (temp4 & (~ temp13));
    244             var stream<1> xF4 = (u8.prefix4 & temp72);
    245             u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
    246             u8.x80_x9F = (u8.suffix & (~ basis_bits.bit_2));
    247             u8.x90_xBF = (u8.suffix & temp49);
    248             u8.x80_x8F = (u8.suffix & (~ temp49));
    249             var stream<1> xEF = (u8.prefix3 & temp23);
    250             var stream<1> temp73 = (u8.suffix & temp7);
    251             u8.xBF = (temp73 & temp23);
    252             u8.xBE = (temp73 & temp15);
    253             u8.scope32 = pablo.Advance(u8.prefix3);
    254             u8.scope33 = pablo.Advance(u8.scope32);
    255             u8.scope42 = pablo.Advance(u8.prefix4);
    256             u8.scope43 = pablo.Advance(u8.scope42);
    257             u8.scope44 = pablo.Advance(u8.scope43);
    258             var stream<1> E0_F0_scope = pablo.Advance((xE0 | xF0));
    259             var stream<1> ED_F4_scope = pablo.Advance((xED | xF4));
    260             u8.xE0_scope = (u8.scope32 & E0_F0_scope);
    261             u8.xED_scope = (u8.scope32 & ED_F4_scope);
    262             u8.xF0_scope = (u8.scope42 & E0_F0_scope);
    263             u8.xF4_scope = (u8.scope42 & ED_F4_scope);
    264             u8.xEF_scope = pablo.Advance(xEF);
    265             var stream<1> u8lastscope = ((u8.scope22 | u8.scope33) | u8.scope44);
    266             u8anyscope = (((u8lastscope | u8.scope32) | u8.scope42) | u8.scope43);
    267             var stream<1> u8error1 = (u8.xE0_scope & u8.x80_x9F);
    268             var stream<1> u8error2 = (u8.xED_scope & u8.xA0_xBF);
    269             var stream<1> u8error3 = (u8.xF0_scope & u8.x80_x8F);
    270             var stream<1> u8error4 = (u8.xF4_scope & u8.x90_xBF);
    271             u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
    272             var stream<1> EF_BF_pending = pablo.Advance((u8.xEF_scope & u8.xBF));
    273             u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
    274         }
    275         var stream<1> u8mismatch = (u8anyscope ^ u8.suffix);
    276         pablo.assert_0(((u8_error | u8mismatch) | u8_FFFE_FFFF), "UTF-8 error found");
    277     }
    278 }
    279 
    280 function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    281     ctCDPI_Callouts.Ct_starts = 0;
    282     ctCDPI_Callouts.Ct_ends = 0;
    283     ctCDPI_Callouts.CD_starts = 0;
    284     ctCDPI_Callouts.CD_ends = 0;
    285     ctCDPI_Callouts.PI_starts = 0;
    286     ctCDPI_Callouts.PI_name_starts = 0;
    287     ctCDPI_Callouts.PI_name_ends = 0;
    288     ctCDPI_Callouts.PI_ends = 0;
    289     var stream<1> CtCDPI_starts = 0;
    290     var stream<1> CtCDPI_ends = 0;
    291     var stream<1> ctCDPI_mask = 0;
    292     var stream<1> v = (lex.LAngle | lex.Hyphen);
    293     var stream<1> w = (lex.Hyphen | lex.QMark);
    294     var stream<1> v1 = pablo.Advance(v, 1);
    295     var stream<1> w1 = pablo.Advance(w, 1);
    296     var stream<1> LAngle_scope = (v1 & (~ w1));
    297     var stream<1> PI_opener = (LAngle_scope & lex.QMark);
    298     var stream<1> CtCD_opener = (LAngle_scope & lex.Exclam);
    299     var stream<1> CtCDPI_opener = (PI_opener | CtCD_opener);
    300     var stream<1> CD_closer = 0;
    301     var stream<1> DoubleHyphen = ((v1 & w1) & lex.Hyphen);
    302     if (lex.RBracket) {
    303         var stream<1> DoubleRBracket = (pablo.Advance(lex.RBracket) & lex.RBracket);
    304         CD_closer = (pablo.Advance(DoubleRBracket) & lex.RAngle);
    305     }
    306     var stream<1> PI_closer = ((w1 & (~ v1)) & lex.RAngle);
    307     var stream<1> CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
    308     while (CtCDPI_Cursor) {
    309         CtCDPI_starts |= CtCDPI_Cursor;
    310         var stream<1> PI_Cursor = (CtCDPI_Cursor & PI_opener);
    311         var stream<1> CD_Ct_Cursor = pablo.Advance((CtCDPI_Cursor & (~ PI_Cursor)));
    312         var stream<1> CD_Cursor = (CD_Ct_Cursor & lex.LBracket);
    313         var stream<1> Ct_Cursor = (CD_Ct_Cursor & lex.Hyphen);
    314         if (PI_Cursor) {
    315             ctCDPI_Callouts.PI_starts |= PI_Cursor;
    316             PI_Cursor = pablo.Advance(PI_Cursor);
    317             ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
    318             var stream<1> PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
    319             var stream<1> PI_error = (PI_Cursor & PI_name_end);
    320             var stream<1> PI_noWS = (PI_name_end & (~ lex.WS));
    321             PI_error |= ((PI_noWS & (~ lex.QMark)) | (pablo.Advance(PI_noWS) & (~ PI_closer)));
    322             pablo.assert_0(PI_error, "Error in PI syntax");
    323             ctCDPI_Callouts.PI_name_ends |= PI_name_end;
    324             PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
    325             ctCDPI_Callouts.PI_ends |= PI_Cursor;
    326             CtCDPI_ends |= PI_Cursor;
    327         }
    328         if (CD_Cursor) {
    329             ctCDPI_Callouts.CD_starts |= CD_Cursor;
    330             CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
    331             ctCDPI_Callouts.CD_ends |= CD_Cursor;
    332             CtCDPI_ends |= CD_Cursor;
    333         }
    334         if (Ct_Cursor) {
    335             ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
    336             Ct_Cursor = pablo.Advance(Ct_Cursor);
    337             var stream<1> Ct_error = (Ct_Cursor & (~ lex.Hyphen));
    338             Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
    339             Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
    340             pablo.assert_0((Ct_error | (Ct_Cursor & (~ lex.RAngle))), "Error in comment syntax");
    341             ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
    342             CtCDPI_ends |= Ct_Cursor;
    343         }
    344         CtCDPI_Cursor = ((PI_Cursor | CD_Cursor) | Ct_Cursor);
    345         ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
    346         pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
    347         CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener);
    348     }
    349     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);
    350     marker.LAngle_scope = (LAngle_scope & (~ ctCDPI_mask));
    351     marker.Ref_opener = (lex.RefStart & (~ ctCDPI_mask));
    352     marker.CD_closer = (CD_closer & (~ ctCDPI_mask));
    353 }
    354 
    355 function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    356     var stream<1> DQuoteDelim = (lex.DQuote | lex.LAngle);
    357     var stream<1> SQuoteDelim = (lex.SQuote | lex.LAngle);
    358     var stream<1> AttListDelim = (lex.Slash | lex.RAngle);
    359     tag_Callouts.ElemName_starts = (marker.LAngle_scope & (~ lex.Slash));
    360     tag_Callouts.EndTag_marks = (marker.LAngle_scope & lex.Slash);
    361     tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    362     var stream<1> ParseError = (tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends);
    363     tag_Callouts.AttName_starts = 0;
    364     tag_Callouts.AttName_ends = 0;
    365     tag_Callouts.AttVal_starts = 0;
    366     tag_Callouts.AttVal_ends = 0;
    367     if ((tag_Callouts.ElemName_ends & lex.WS)) {
    368         var stream<1> AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    369         var stream<1> AttListEnd = (AfterWS & AttListDelim);
    370         var stream<1> AttNameStart = (AfterWS & (~ AttListDelim));
    371         while (AttNameStart) {
    372             ParseError |= (AttNameStart & (~ lex.NameScan));
    373             tag_Callouts.AttName_starts |= AttNameStart;
    374             var stream<1> AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
    375             tag_Callouts.AttName_ends |= AttNameFollow;
    376             if ((AttNameFollow & lex.WS)) {
    377                 var stream<1> EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
    378             }
    379             else {
    380                 var stream<1> EqExpected = AttNameFollow;
    381             }
    382             ParseError |= (EqExpected & (~ lex.Equals));
    383             var stream<1> AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
    384             tag_Callouts.AttVal_starts |= AttValPos;
    385             var stream<1> DQuoteAttVal = (AttValPos & lex.DQuote);
    386             var stream<1> SQuoteAttVal = (AttValPos & lex.SQuote);
    387             var stream<1> DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
    388             var stream<1> SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
    389             var stream<1> AttValEnd = (DQuoteAttEnd | SQuoteAttEnd);
    390             ParseError |= ((AttValPos | AttValEnd) & (~ (lex.DQuote | lex.SQuote)));
    391             var stream<1> AttValFollow = pablo.Advance(AttValEnd);
    392             tag_Callouts.AttVal_ends |= AttValFollow;
    393             if ((AttValFollow & lex.WS)) {
    394                 AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
    395                 AttListEnd |= (AfterWS & AttListDelim);
    396                 AttNameStart = (AfterWS & (~ AttListDelim));
    397             }
    398             else {
    399                 AttListEnd |= (AttValFollow & AttListDelim);
    400                 AttNameStart = 0;
    401                 ParseError |= (AttValFollow & (~ AttListDelim));
    402             }
    403         }
    404     }
    405     else {
    406         var stream<1> AttListEnd = (tag_Callouts.ElemName_ends & AttListDelim);
    407         ParseError |= (tag_Callouts.ElemName_ends & (~ AttListDelim));
    408     }
    409     var stream<1> STagEnds = (AttListEnd & lex.RAngle);
    410     tag_Callouts.EmptyTag_marks = pablo.Advance((AttListEnd & lex.Slash));
    411     ParseError |= (tag_Callouts.EmptyTag_marks & (~ lex.RAngle));
    412     var stream<1> EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
    413     if ((EndTagEnds & lex.WS)) {
    414         EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
    415     }
    416     ParseError |= (EndTagEnds & (~ lex.RAngle));
    417     pablo.assert_0(ParseError, "Tag parsing error found");
    418     tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
    419 }
    4201
    4212function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
     
    4256    ref_Callouts.DecRef_ends = 0;
    4267    ref_Callouts.HexRef_starts = 0;
    427     ref_Callouts.HexRef_ends = 0;
     8    ref_Callouts.HexRef_ends = a&b;
    4289    var stream<1> ref_error = 0;
    42910    if (marker.Ref_opener) {
     
    44627}
    44728
    448 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) {
    449     var stream<1> PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    450     var stream<1> GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
    451     var stream<1> ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    452     var stream<1> AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
    453     var stream<1> qname_stream = (ElemNames | AttNames);
    454     var stream<1> ncname_stream = (PI_names | GenRefs);
    455     var stream<1> name_stream = (qname_stream | ncname_stream);
    456     var stream<1> name_start = (name_stream & (~ pablo.Advance(name_stream)));
    457     var stream<1> name_cursor = (name_stream & (~ pablo.Advance(name_stream)));
    458     var stream<1> void_prefix_err = (name_cursor & lex.Colon);
    459     var stream<1> namespace_sep = (pablo.ScanThru(name_cursor, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
    460     var stream<1> local_part_start = pablo.Advance(namespace_sep);
    461     var stream<1> local_part_err = (local_part_start & (~ lex.NameScan));
    462     var stream<1> colon2_err = (pablo.ScanThru(local_part_start, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
    463     var stream<1> ncname_err = (ncname_stream & lex.Colon);
    464     pablo.assert_0((((void_prefix_err | local_part_err) | colon2_err) | ncname_err), "name syntax error");
    465     check_streams.non_ascii_name_starts = (name_start & (~ lex.ASCII_name_start));
    466     check_streams.non_ascii_names = (((name_stream & (~ name_start)) & (~ lex.ASCII_name_char)) & (~ u8.suffix));
    467 }
    468 
    469 function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
    470     pablo.assert_0((marker.CD_closer & (~ tag_Callouts.AttVal_spans)), "Error: ]]> in text");
    471     check_streams.tag_marks = (((tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts) | tag_Callouts.EndTag_marks) | tag_Callouts.AttName_starts);
    472     check_streams.name_follows = (tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends);
    473     check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
    474 }
    475 
    476 function void Main(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, struct Xml_char xml_char, struct Scope1 scope1, struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Masks masks, struct Xml_names xml_names, struct Check_streams check_streams) {
    477     Classify_bytes_Validate_utf8(basis_bits, lex, u8);
    478     Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams);
    479     Parse_tags(lex, marker, tag_Callouts);
    480     Parse_refs(lex, marker, ref_Callouts);
    481     Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
    482     Do_check_streams(marker, tag_Callouts, check_streams);
    483 }
  • proto/pablo/input/test/visitors/AdvanceCombiner/advance.pablo

    r2621 r2641  
    1414        temp = Advance(X,3);
    1515        temp = Advance(Advance(X,2));
     16       
    1617       
    1718        temp = Advance(X,3);
     
    5657        temp = Advance(X,3);
    5758        temp = Advance(Advance(Advance(X)));
    58        
     59               
    5960}
  • proto/pablo/input/test/visitors/CarryIntroCi/pablo2CarryQ.pablo

    r2607 r2641  
    1212        R = pablo.Advance(C);
    1313       
    14         R = CarryQ.BitBlock_scantofirst(C,M,CarryQ.get_carry_in(2),2);
    15         R = ScanToFirst(C,M);
     14        R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(2),2);
     15        R = ScanToFirst(M);
    1616
    17         R = CarryQ.BitBlock_scantofirst(C,M,CarryQ.get_carry_in(3),3); 
    18         R = pablo.ScanToFirst(C,M);
     17        R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(3),3);   
     18        R = pablo.ScanToFirst(M);
    1919
    2020        R = CarryQ.BitBlock_scanthru_ci_co(C,X,CarryQ.get_carry_in(4),4);
  • proto/pablo/input/test/visitors/CarryIntroCiCo/pablo2CarryQ.pablo

    r2607 r2641  
    1212        R = pablo.Advance(C);
    1313       
    14         R = CarryQ.BitBlock_scantofirst(C,M,CarryQ.get_carry_in(2),2);
    15         R = ScanToFirst(C,M);
     14        R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(2),2);
     15        R = ScanToFirst(M);
    1616
    17         R = CarryQ.BitBlock_scantofirst(C,M,CarryQ.get_carry_in(3),3); 
    18         R = pablo.ScanToFirst(C,M);
     17        R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(3),3);   
     18        R = pablo.ScanToFirst(M);
    1919
    2020        R = CarryQ.BitBlock_scanthru_ci_co(C,X,CarryQ.get_carry_in(4),4);
  • proto/pablo/src/ast/ASTNode.java

    r2415 r2641  
    125125        }
    126126    }
    127        
     127        public void insertAfterChild(ASTNode node, ASTNode successor) {
     128                int index = children.indexOf(node);
     129                insertChildAfter(index, successor);
     130                successor.setParent(this);
     131        }
     132       
     133        private void insertChildAfter(int index, ASTNode successor) {
     134                if(index == children.size()-1) {
     135                        children.add(successor);
     136                } else {
     137                        children.add(index+1, successor);
     138                }       
     139        }               
    128140       
    129141////////////////////////////////////////////////////////////////////////////////////
  • proto/pablo/src/compiler/PabloCompiler.java

    r2633 r2641  
    77
    88import java.io.FileNotFoundException;
     9import java.util.ArrayList;
     10import java.util.List;
    911import java.util.Map;
    1012
     
    5355                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    5456                       
    55                     //AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
    56                     //advanceCombiner.transform();
     57                    AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
     58                    advanceCombiner.transform();
    5759                   
    5860                    //CarryCounter carryCounter = new CarryCounter(entry.getValue());
     
    7072                        augmentedAssignment.transform();
    7173                       
    72                         CarryQIntro carryIf = new CarryQIntro(entry.getValue());
    73                         carryIf.transform(true, false);
     74                        DumpAssignmentStatementsTransformer dumpAssignmentStatementsTransformer = new DumpAssignmentStatementsTransformer(entry.getValue()); 
     75                        dumpAssignmentStatementsTransformer.transform();
     76                                               
     77                        CarryQIntro carryQIntro = new CarryQIntro(entry.getValue());
     78                        carryQIntro.transform(true, false);
    7479                       
    75                         Pablo2CarryQ carryIntro = new Pablo2CarryQ(entry.getValue());
    76                         carryIntro.transform(true, false);                 
     80                        Pablo2CarryQ pablo2CarryQ = new Pablo2CarryQ(entry.getValue());
     81                        pablo2CarryQ.transform(true, false);               
    7782                   
    78                         Bitwise2IDISA bitwiseToIDISA = new Bitwise2IDISA(entry.getValue());
     83                        // System.out.println(entry.getValue());
     84                       
     85                        Bitwise2IDISA bitwiseToIDISA = new Bitwise2IDISA(entry.getValue()); // 0 -> simd::constant<1>(0);
    7986                        bitwiseToIDISA.transform();
    8087                       
  • proto/pablo/src/compiler/PabloCompilerTestHarness.java

    r2633 r2641  
    187187                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    188188               
    189                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                         
    190                         Pablo2CarryQ carryIntro = new Pablo2CarryQ(entry.getValue());
    191                         carryIntro.transform(ciMode, coMode);                   
     189                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
     190                                               
     191                        Pablo2CarryQ pablo2CarryQ = new Pablo2CarryQ(entry.getValue());
     192                        pablo2CarryQ.transform(ciMode, coMode);                 
     193                       
    192194                }   
    193195               
  • proto/pablo/src/compiler/ReadMe.txt

    r2633 r2641  
    1 Compiler Design 
     1Implementation Changes
     2
     31. Split CarryIntro visitor into two vistor passes.
     4   If, While, Body. Add Carry Calls.
     5           
     6           Pablo 'if'
     7               
     8       Parallel bit stream language construct --> Block-at-a-time implementation.
     9   
     10           if(C) { S* } --> if (C || any_carry(base,count)) { S* } else { enqueue_dequeue(base, count) }
     11           
     12           Pablo 'while'
     13           
     14       while(C) { S* } --> if (C || any_carry(base, count))
     15                           {
     16                             S*
     17                             while(C) {
     18                               S*
     19                             }
     20                           }
     21                           else
     22                           {
     23                             enqueue_dequeue(base, count)
     24                           } 
     25                                   
     26       Pablo 'body'
     27       
     28       (ii) Translate carry generating built-in operations.
     29
     30Todo List
     31
     321. Support negative numbers.
     332. Fix indentation. Nested if's etc.   
     343. simd::constant<1>(0) <-- if CarryQ ignore
     354. Add assert compiler.
     36//5. Add SIMD register dump.
     376. if stream_function.carry_count > 0:
     38         node.body += [mkCallStmt('carryQ.CarryQ_Adjust', [ast.Num(stream_function.carry_count)])]
     39
     40Current Compiler Design Issues
    241 
    3 1. Negative numbers.
    4 2. Replace all occurrences of X.getCPPCode() with a generic getCode call
     421. Replace all occurrences of X.getCPPCode() with a generic getCode call
    543   that is configurable based on the target back-end. e.g. C macro syntax
    6    versus C++ template syntax etc.
    7 3. Function call expressions versus function call statements.
    8 4. Visitor dependency. Tree transformation, e.g. carry counter depends on
     44   versus C++ template syntax etc.
     45   
     462. Divide the compiler into phases to promote the decoupling of visitor passes.
     47   (a) Analysis phases - Gather information and populate symbol table information.
     48   
     49   (b) AST augmenting / altering phases that alter the PABLO AST in a
     50       target back-end independent fashion.
     51   
     52   (c) Code generation phases. Dependent on the target language and hardware.
     53
     54   (d) Name Visitors SomeNameVisitor, InnerSomeNameVisitor; and Name SomeNameTransformer, InnerSomeNameTransformer.
     55   
     563. Visitor dependency. Tree transformation, e.g. carry counter depends on
    957   'Advance(x)' function name and argument count.
     58   
     594. Boolean OR, Boolean AND. Pablo may require a boolean type as well as binary and boolean
     60   AND,OR operators.
     61
     62   Options:
     63   
     64   Restricted compiler operator.
     65   Add to Pablo language, poor choice.
     66   Boolean type.
     67   String value produced for evaluation as a function name within 'if' tests.
     68
     69   I believe the following the correct block-at-a-time implementation. This avoids the
     70   introduction of a Boolean type to the Pablo language.
     71
     72   --> if((bitblock::any(C | CarryQ.CarryTest(base,count))
     73
     745. Verify function call expressions versus function call statements. Go over code
     75   generation scheme.
     76         
     77         
  • proto/pablo/src/compiler/ast/Accessors.java

    r2633 r2641  
    5959        ////////////////////////////////////////////////////////////////////////////
    6060        // Local Variable Declaration Statements
    61         ////////////////////////////////////////////////////////////////////////////                           
     61        ////////////////////////////////////////////////////////////////////////////
     62       
    6263        public static ASTNode lhs(LocalVarDeclNode node) {
    6364                return node.child(1);
     
    6566       
    6667        public static ASTNode rhs(LocalVarDeclNode node) {
     68       
    6769                return node.child(2);
    6870        }               
     
    7577
    7678                if (node.nChildren() > 2) {
    77                         ASTNode child = node.child(2);
    78                         // assert child instanceof ExpressionNode;
    7979                        return true;
    8080                }
     
    163163                return false;
    164164        }
     165       
     166        public static BlockStatementNode blockStatementNode(FunctionDefNode node) {
     167                int blockStatementNodeIndex;
     168               
     169                if(Accessors.hasParameters(node)) {
     170                        blockStatementNodeIndex = 3;
     171                } else {
     172                        blockStatementNodeIndex = 2;
     173                }
     174               
     175                ASTNode child = node.child(blockStatementNodeIndex);
     176                assert child instanceof BlockStatementNode;
     177        return (BlockStatementNode) child;
     178        }       
    165179       
    166180        ////////////////////////////////////////////////////////////////////////////
     
    244258        }       
    245259       
    246                
    247260        public static boolean hasStructBody(StructTypeNode node) {
    248261                if (node.nChildren() > 1) {
     
    262275        return name;
    263276        }       
    264        
     277                       
    265278        ////////////////////////////////////////////////////////////////////////////
    266279        // StructMemberNode helpers
     
    297310        }       
    298311       
    299        
    300312}
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinOperations.java

    r2632 r2641  
    2222
    2323    ATEOF(Carry.None, "atEOF", 1, "atEOF"),
    24     INFILE(Carry.None, "inFile", 1, "inFile");
     24    INFILE(Carry.None, "inFile", 1, "inFile"),
    2525       
     26    PRINTBITBLOCK(Carry.None, "PrintBitBlock", 1, "print_register<BitBlock>"); // psuedo builtin
     27   
    2628    public enum Carry{One, N, None};   
    2729   
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinsUtil.java

    r2632 r2641  
    1010       
    1111    public static boolean isAdvance(ASTNode node) {
    12         if(node != null && !(node instanceof FunctionInvocationNode)) {
     12        if(node == null) {
     13                return false;
     14        }
     15       
     16        if (!(node instanceof FunctionInvocationNode)) {
    1317            return false;
    1418        }
     
    1721        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    1822        ASTNode argumentsListNode = (ASTNode)Accessors.functionInvocationArgumentsListNode(fNode);
    19        
     23   
     24        // Advance(X)
    2025        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())
    2126                && argumentsListNode.nChildren() == 1) {
    2227            return true;
    2328        }
    24    
     29
     30        // Advance(X,n)
     31        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())
     32                && argumentsListNode.nChildren() == 2) {       
     33                        return true;
     34        }
     35       
    2536        return false;       
    2637    }
    2738
    28     public static boolean isAdvanceN(ASTNode node) {
    29         if(node != null && !(node instanceof FunctionInvocationNode)) {
    30             return false;
    31         }
    32        
    33         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    34         ASTNode nameNode = Accessors.functionInvocationName(fNode);
    35         ASTNode argumentsListNode = (ASTNode)Accessors.functionInvocationArgumentsListNode(fNode);
    36        
    37         if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName())
    38                 && argumentsListNode.nChildren() == 2) {       
    39                         return true;
    40         }
    41    
    42         return false;       
    43     }   
    44    
    4539    public static boolean isBuiltinOperations(ASTNode node) {
    4640       
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2632 r2641  
    4646                                return;
    4747                        }
    48                                
    49                         FunctionInvocationNode child = (FunctionInvocationNode)streamBeingAdvanced(node);
     48                                                       
     49                        ASTNode argumentsList = Accessors.functionInvocationArgumentsList((FunctionInvocationNode) node);
     50                        FunctionInvocationNode child = (FunctionInvocationNode)argumentsList.child(0);
    5051                       
    5152                        int amount1 = advanceAmount(node);
     
    7980                if(!BuiltinsUtil.isAdvance(node)) {
    8081                        return false;
    81                 }
    82                 ASTNode child = streamBeingAdvanced((FunctionInvocationNode) node);                             
    83                 return BuiltinsUtil.isAdvance(child);
     82                }                       
     83               
     84                ASTNode argumentsList = Accessors.functionInvocationArgumentsList((FunctionInvocationNode) node);
     85               
     86                return BuiltinsUtil.isAdvance(argumentsList.child(0));
    8487        }
    8588       
  • proto/pablo/src/compiler/visitors/Bitwise2IDISA.java

    r2634 r2641  
    5454                }
    5555               
     56               
     57               
     58                /*
    5659                public void visitLeave(IntegerConstantNode node) {
    5760                        String name;
     
    6871                        }
    6972                }
     73                */
     74                public void visitLeave(LocalVarDeclNode node) {
     75                        if(Accessors.hasInitializationAssignment(node)) {
     76                                ASTNode rhs = Accessors.rhs(node);
     77                                integerConstant2IDISA(node, rhs);
     78                        }
     79                }
     80
     81                public void visitLeave(AssignmentNode node) {
     82                        ASTNode rhs = Accessors.rhs(node);
     83                        integerConstant2IDISA(node, rhs);
     84                }
     85               
     86                private void integerConstant2IDISA(ASTNode node, ASTNode rhs) {
     87                        if(rhs instanceof IntegerConstantNode) {
     88                       
     89                                int constantValue = ((IntegerConstantNode) rhs).getValue();
     90                               
     91                                if(constantValue == 0 || constantValue == -1) {
     92                                       
     93                                        int fieldWidth = 1;
     94                                        int constant = -1 * constantValue;
     95                                       
     96                                        String name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
     97                                        FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(name, node.getToken());
     98                                        rhs.updateSelf(functionInvocationNode);
     99                                }
     100                        }
     101                }               
     102               
     103               
    70104
    71105//          def visit_If_Node(self, ifNode):
  • proto/pablo/src/compiler/visitors/CPPUnparser.java

    r2633 r2641  
    9393                }
    9494                               
    95                 code.addFormattedLine("%s %s (%s)",
     95                code.addFormattedLine("%s %s(%s)",
    9696                                returnType.getResultVariableName(),
    9797                                functionName.getResultVariableName(),
  • proto/pablo/src/compiler/visitors/CarryQIntro.java

    r2633 r2641  
    6060                //      #    fndef.body.insert(0, mkCallStmt('CarryDeclare', [self.carryvar, ast.Num(carry_count)]))
    6161                //          return fndef
    62                 public void visitLeave(FunctionDefNode node) {  // TODO - CarryIf duplicates
     62                public void visitEnter(FunctionDefNode node) {  // TODO - CarryIf duplicates
    6363                        this.currentCarry = 0;
    6464                        this.currentAdvN = 0;
    65                         //this.lastStmtCarries = 0;                     
     65                        //this.lastStmtCarries = 0;
     66                       
     67                        int carryCount = (new CarryCounter(node)).count();
     68                        if(carryCount > 0) {
     69                       
     70                                IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
     71                               
     72                                FunctionInvocationNode carryAdjustFunctionInvocation = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     73                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYQADJUST.cPPCode()},
     74                                                node.getToken(),
     75                                                new ASTNode [] {carryCountNode});
     76                               
     77                                BlockStatementNode blockStatementNode = Accessors.blockStatementNode(node);
     78                                blockStatementNode.appendChild(carryAdjustFunctionInvocation);
     79                        }
    6680                }               
    6781               
     
    8498                //return ast.If(new_test, ifNode.body, new_else_part)
    8599
    86                 public void visitLeave(IfStatementNode node) { // Current if strategy does not test any_carry() on n bits
     100                public void visitEnter(IfStatementNode node) { // Current if strategy does not test any_carry() on n bits
    87101                        assert (new AdvanceNCounter(node).count() == 0): "Advance(x,n) within if: illegal\n";
    88102                       
    89103                        int carryBase = this.currentCarry;
    90104                        int carryCount = (new CarryCounter(node)).count();
    91 
    92                         //System.out.println(Accessors.ifBlockStatement(node));                 
    93                         //System.out.println(carryCount);
    94                        
     105                                               
    95106                        if((carryCount == 0) || (!this.ciMode)) {
    96107                                return;
  • proto/pablo/src/compiler/visitors/Pablo2CarryQ.java

    r2633 r2641  
    7272                //      #    fndef.body.insert(0, mkCallStmt('CarryDeclare', [self.carryvar, ast.Num(carry_count)]))
    7373                //          return fndef
    74                 public void visitLeave(FunctionDefNode node) { // TODO - CarryIf duplicates
     74                public void visitEnter(FunctionDefNode node) { // TODO - CarryIf duplicates
    7575                        this.currentCarry = 0;
    7676                        this.currentAdvN = 0;
Note: See TracChangeset for help on using the changeset viewer.