Changeset 2657


Ignore:
Timestamp:
Nov 19, 2012, 4:51:23 PM (6 years ago)
Author:
ksherdy
Message:

Refactored carry set code generation.

Location:
proto/pablo
Files:
4 added
19 edited
5 copied

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/test/pablo/all/all.pablo

    r2632 r2657  
    1 
     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};
     13
     14function void Foo() {
     15
     16}
     17function void AssignmentExpressions() {
     18        temp4 = temp;
     19        temp4 &= temp1 | temp2;
     20        temp4 |= temp1 ^ temp2;
     21        temp4 ^= temp1 & temp2;
     22//      temp4 ~= temp1 ^ temp2 | temp3;
     23};function void BasicExpressions() {
     24
     25        temp4 = temp;
     26        temp4 = temp1 | temp2;
     27        temp4 = temp1 ^ temp2;
     28        temp4 = temp1 & temp2;
     29        temp4 = temp1 ^ temp2 | temp3;
     30        temp4 = temp1 | temp2 ^ temp3;
     31        temp4 = temp1 & temp2 | temp3;
     32        temp4 = temp1 | temp2 & temp3;
     33        temp4 = temp1 & (temp2 | temp3);
     34        temp4 = (temp1 | temp2) & temp3;
     35//      temp4 = ~temp;
     36       
     37};
     38
     39function void Assignments() {
     40        var stream s;
     41        s = 0;
     42        s &= 0;
     43        s |= 0;
     44//      s ~= 0;
     45        s ^= 0;
     46};function struct A FunctionExpressions() {
     47         var stream<1> a = b.Advance();
     48};
     49function void RecordExpressions() {
     50
     51        // records
     52        temp4 = temp1.temp2;
     53        temp4 = temp1.temp2.temp3;
     54       
     55        temp1.temp2 = temp4;
     56        temp1.temp2.temp3 = temp4;
     57               
     58};function void localDecl() {
     59        var stream A;
     60        var stream A=0;
     61}function void localDecl() {
     62
     63var struct BasisBits {
     64stream<1> b1;
     65stream<1> b2;
     66stream<1> b3;
     67stream<1> b4;
     68} A;
     69
     70};function void Assignments() {
     71        var stream s = 4;
     72        var stream s &= 4;
     73        var stream s |= 4;
     74//      var stream s ~= 4;
     75        var stream s ^= 4;
     76}function void localDecl() {
     77
     78        var struct BasisBits {
     79        stream b1;
     80        stream b2;
     81        stream b3;
     82        stream b4;
     83        } A;
     84
     85} function void Function() {   
     86       
     87        if(cursor & a) {
     88                if(cursor & b) {
     89               
     90                }
     91        }
     92       
     93}
     94function void Function() {     
     95       
     96        if(cursor & a) {
     97                if(cursor & b) {
     98               
     99                } else {
     100               
     101                }
     102
     103        } else {
     104
     105        }
     106       
     107}
     108function void Function() {             
     109        if(cursor) {
     110
     111        }
     112}
     113function void Function() {     
     114       
     115        if(cursor & a) {
     116
     117        } else {
     118
     119        }
     120       
     121}
     122function struct Lex ClassifyBytes(struct BasisBit basis) {};
     123function stream Function(stream a, stream b, stream c) {};
     124struct B
     125{
     126        stream a;
     127        stream a;
     128        stream a;
     129        stream a;
     130};
     131
     132function struct B Foo() { }
     133struct Lex {
     134        stream LAngle;
     135        stream RAngle;
     136};
     137
     138typedef struct Lex Lex;
     139
     140typedef Lex Lex;typedef stream s;
     141
     142typedef stream<1> s1;typedef struct BasisBits {
     143stream b1;
     144stream b2;
     145stream b3;
     146stream b4;
     147} BasisBitsAlias;
    2148
    3149struct Basis_bits{
  • proto/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude

    r2641 r2657  
     1
     2
     3struct 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
     14struct 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
     46struct 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
     76struct Marker{
     77    stream<1> LAngle_scope;
     78    stream<1> Ref_opener;
     79    stream<1> CD_closer;
     80};
     81
     82struct 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
     93struct 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
     102struct 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
     114struct 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
     123function 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
     280function 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
     355function 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 = (AttValFollow & (~ AttListDelim));
     401            }
     402            ParseError |= (AttValFollow & AttNameStart);
     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}
    1420
    2421function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
     
    6425    ref_Callouts.DecRef_ends = 0;
    7426    ref_Callouts.HexRef_starts = 0;
    8     ref_Callouts.HexRef_ends = a&b;
     427    ref_Callouts.HexRef_ends = 0;
    9428    var stream<1> ref_error = 0;
    10429    if (marker.Ref_opener) {
     
    27446}
    28447
     448function 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
     469function 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
     476function 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/Pablo2CarryQCiCoTransformer/pablo2CarryQ.pablo

    r2649 r2657  
    66       
    77       
    8         R = CarryQ.BitBlock_advance_ci_co(C,CarryQ.get_carry_in(0),0);  // Expected
     8        R = carryQ.BitBlock_advance_ci_co(C,carryQ.get_carry_in(0),0);  // Expected
    99        R = Advance(C);                                                                                                 // Translated
    1010               
    11         R = CarryQ.BitBlock_advance_ci_co(C,CarryQ.get_carry_in(1),1);
     11        R = carryQ.BitBlock_advance_ci_co(C,carryQ.get_carry_in(1),1);
    1212        R = pablo.Advance(C);
    1313       
    14         R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(2),2);
     14        R = carryQ.BitBlock_scantofirst(M,carryQ.get_carry_in(2),2);
    1515        R = ScanToFirst(M);
    1616
    17         R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(3),3);   
     17        R = carryQ.BitBlock_scantofirst(M,carryQ.get_carry_in(3),3);   
    1818        R = pablo.ScanToFirst(M);
    1919
    20         R = CarryQ.BitBlock_scanthru_ci_co(C,X,CarryQ.get_carry_in(4),4);
     20        R = carryQ.BitBlock_scanthru_ci_co(C,X,carryQ.get_carry_in(4),4);
    2121        R = ScanThru(C,X);
    2222
    23         R = CarryQ.BitBlock_scanthru_ci_co(C,X,CarryQ.get_carry_in(5),5);
     23        R = carryQ.BitBlock_scanthru_ci_co(C,X,carryQ.get_carry_in(5),5);
    2424        R = pablo.ScanThru(C,X);
    2525
    26         R = CarryQ.BitBlock_scanto_ci_co(C,X,CarryQ.get_carry_in(6),6);
     26        R = carryQ.BitBlock_scanto_ci_co(C,X,carryQ.get_carry_in(6),6);
    2727        R = ScanTo(C,X);
    2828       
    29         R = CarryQ.BitBlock_scanto_ci_co(C,X,CarryQ.get_carry_in(7),7);
     29        R = carryQ.BitBlock_scanto_ci_co(C,X,carryQ.get_carry_in(7),7);
    3030        R = pablo.ScanTo(C,X);
    3131
    32         R = CarryQ.BitBlock_advance_then_scanthru(C,X,CarryQ.get_carry_in(8),8);
     32        R = carryQ.BitBlock_advance_then_scanthru(C,X,carryQ.get_carry_in(8),8);
    3333        R = AdvanceThenScanThru(C,X);
    3434       
    35         R = CarryQ.BitBlock_advance_then_scanthru(C,X,CarryQ.get_carry_in(9),9);       
     35        R = carryQ.BitBlock_advance_then_scanthru(C,X,carryQ.get_carry_in(9),9);       
    3636        R = pablo.AdvanceThenScanThru(C,X);
    3737
    38         R = CarryQ.BitBlock_advance_then_scanto(C,X,CarryQ.get_carry_in(10),10);                       
     38        R = carryQ.BitBlock_advance_then_scanto(C,X,carryQ.get_carry_in(10),10);                       
    3939        R = AdvanceThenScanTo(C,X);
    4040       
    41         R = CarryQ.BitBlock_advance_then_scanto(C,X,CarryQ.get_carry_in(11),11);       
     41        R = carryQ.BitBlock_advance_then_scanto(C,X,carryQ.get_carry_in(11),11);       
    4242        R = pablo.AdvanceThenScanTo(C,X);
    4343
    44         R = CarryQ.BitBlock_span_upto(C,X,CarryQ.get_carry_in(12),12);
     44        R = carryQ.BitBlock_span_upto(C,X,carryQ.get_carry_in(12),12);
    4545        R = SpanUpTo(C,X);
    4646       
    47         R = CarryQ.BitBlock_span_upto(C,X,CarryQ.get_carry_in(13),13); 
     47        R = carryQ.BitBlock_span_upto(C,X,carryQ.get_carry_in(13),13); 
    4848        R = pablo.SpanUpTo(C,X);
    4949               
    50         R = CarryQ.BitBlock_inclusive_span(C,X,CarryQ.get_carry_in(14),14);     
     50        R = carryQ.BitBlock_inclusive_span(C,X,carryQ.get_carry_in(14),14);     
    5151        R = InclusiveSpan(C,X);
    5252       
    53         R = CarryQ.BitBlock_inclusive_span(C,X,CarryQ.get_carry_in(15),15);     
     53        R = carryQ.BitBlock_inclusive_span(C,X,carryQ.get_carry_in(15),15);     
    5454        R = pablo.InclusiveSpan(C,X);                   
    5555
    56         R = CarryQ.BitBlock_exclusive_span(C,X,CarryQ.get_carry_in(16),16);     
     56        R = carryQ.BitBlock_exclusive_span(C,X,carryQ.get_carry_in(16),16);     
    5757        R = ExclusiveSpan(C,X);
    5858       
    59         R = CarryQ.BitBlock_exclusive_span(C,X,CarryQ.get_carry_in(17),17);             
     59        R = carryQ.BitBlock_exclusive_span(C,X,carryQ.get_carry_in(17),17);             
    6060        R = pablo.ExclusiveSpan(C,X);                   
    6161               
  • proto/pablo/input/test/visitors/Pablo2CarryQCiTransformer/pablo2CarryQ.pablo

    r2650 r2657  
    66       
    77       
    8         R = CarryQ.BitBlock_advance_ci_co(C,CarryQ.get_carry_in(0),0);  // Expected
     8        R = carryQ.BitBlock_advance_ci_co(C,carryQ.get_carry_in(0),0);  // Expected
    99        R = Advance(C);                                                                                                 // Translated
    1010               
    11         R = CarryQ.BitBlock_advance_ci_co(C,CarryQ.get_carry_in(1),1);
     11        R = carryQ.BitBlock_advance_ci_co(C,carryQ.get_carry_in(1),1);
    1212        R = pablo.Advance(C);
    1313       
    14         R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(2),2);
     14        R = carryQ.BitBlock_scantofirst(M,carryQ.get_carry_in(2),2);
    1515        R = ScanToFirst(M);
    1616
    17         R = CarryQ.BitBlock_scantofirst(M,CarryQ.get_carry_in(3),3);   
     17        R = carryQ.BitBlock_scantofirst(M,carryQ.get_carry_in(3),3);   
    1818        R = pablo.ScanToFirst(M);
    1919
    20         R = CarryQ.BitBlock_scanthru_ci_co(C,X,CarryQ.get_carry_in(4),4);
     20        R = carryQ.BitBlock_scanthru_ci_co(C,X,carryQ.get_carry_in(4),4);
    2121        R = ScanThru(C,X);
    2222
    23         R = CarryQ.BitBlock_scanthru_ci_co(C,X,CarryQ.get_carry_in(5),5);
     23        R = carryQ.BitBlock_scanthru_ci_co(C,X,carryQ.get_carry_in(5),5);
    2424        R = pablo.ScanThru(C,X);
    2525
    26         R = CarryQ.BitBlock_scanto_ci_co(C,X,CarryQ.get_carry_in(6),6);
     26        R = carryQ.BitBlock_scanto_ci_co(C,X,carryQ.get_carry_in(6),6);
    2727        R = ScanTo(C,X);
    2828       
    29         R = CarryQ.BitBlock_scanto_ci_co(C,X,CarryQ.get_carry_in(7),7);
     29        R = carryQ.BitBlock_scanto_ci_co(C,X,carryQ.get_carry_in(7),7);
    3030        R = pablo.ScanTo(C,X);
    3131
    32         R = CarryQ.BitBlock_advance_then_scanthru(C,X,CarryQ.get_carry_in(8),8);
     32        R = carryQ.BitBlock_advance_then_scanthru(C,X,carryQ.get_carry_in(8),8);
    3333        R = AdvanceThenScanThru(C,X);
    3434       
    35         R = CarryQ.BitBlock_advance_then_scanthru(C,X,CarryQ.get_carry_in(9),9);       
     35        R = carryQ.BitBlock_advance_then_scanthru(C,X,carryQ.get_carry_in(9),9);       
    3636        R = pablo.AdvanceThenScanThru(C,X);
    3737
    38         R = CarryQ.BitBlock_advance_then_scanto(C,X,CarryQ.get_carry_in(10),10);                       
     38        R = carryQ.BitBlock_advance_then_scanto(C,X,carryQ.get_carry_in(10),10);                       
    3939        R = AdvanceThenScanTo(C,X);
    4040       
    41         R = CarryQ.BitBlock_advance_then_scanto(C,X,CarryQ.get_carry_in(11),11);       
     41        R = carryQ.BitBlock_advance_then_scanto(C,X,carryQ.get_carry_in(11),11);       
    4242        R = pablo.AdvanceThenScanTo(C,X);
    4343
    44         R = CarryQ.BitBlock_span_upto(C,X,CarryQ.get_carry_in(12),12);
     44        R = carryQ.BitBlock_span_upto(C,X,carryQ.get_carry_in(12),12);
    4545        R = SpanUpTo(C,X);
    4646       
    47         R = CarryQ.BitBlock_span_upto(C,X,CarryQ.get_carry_in(13),13); 
     47        R = carryQ.BitBlock_span_upto(C,X,carryQ.get_carry_in(13),13); 
    4848        R = pablo.SpanUpTo(C,X);
    4949               
    50         R = CarryQ.BitBlock_inclusive_span(C,X,CarryQ.get_carry_in(14),14);     
     50        R = carryQ.BitBlock_inclusive_span(C,X,carryQ.get_carry_in(14),14);     
    5151        R = InclusiveSpan(C,X);
    5252       
    53         R = CarryQ.BitBlock_inclusive_span(C,X,CarryQ.get_carry_in(15),15);     
     53        R = carryQ.BitBlock_inclusive_span(C,X,carryQ.get_carry_in(15),15);     
    5454        R = pablo.InclusiveSpan(C,X);                   
    5555
    56         R = CarryQ.BitBlock_exclusive_span(C,X,CarryQ.get_carry_in(16),16);     
     56        R = carryQ.BitBlock_exclusive_span(C,X,carryQ.get_carry_in(16),16);     
    5757        R = ExclusiveSpan(C,X);
    5858       
    59         R = CarryQ.BitBlock_exclusive_span(C,X,CarryQ.get_carry_in(17),17);             
     59        R = carryQ.BitBlock_exclusive_span(C,X,carryQ.get_carry_in(17),17);             
    6060        R = pablo.ExclusiveSpan(C,X);                   
    6161               
  • proto/pablo/runConfigurations/pabloCompiler.launch

    r2655 r2657  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="compiler.PabloCompiler"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="--input ${workspace_loc}/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude -a -d"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${workspace_loc}/pablo/input/test/pablo/py2pablo/parabix2_pablo.pablo.exclude"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pablo"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pablo/src/compiler/PabloCompiler.java

    r2655 r2657  
    1111import parser.Parser;
    1212import  logging.ScatterLogger;
     13import compiler.lang.carry.CarrySet2CPP;
     14import compiler.lang.carry.CarrySet2Lang;
    1315import compiler.lang.idisa.*;
    14 import compiler.lang.pablo.builtins.Builtins2CPP;
    15 import compiler.lang.pablo.builtins.Builtins2Lang;
     16import compiler.lang.pablo.Builtins2CPP;
     17import compiler.lang.pablo.Builtins2Lang;
    1618import compiler.visitors.*;
    1719//import semanticAnalyzer.SampleSemanticAnalyzer;
     
    7779               
    7880                Builtins2Lang builtins2CPP = new Builtins2CPP();
     81                CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
    7982               
    8083                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
     
    98101                        augmentedAssignment.transform();
    99102                       
    100                         CarryIntroTransformer carryQIntro = new CarryIntroTransformer(value);
     103                        CarryIntroTransformer carryQIntro = new CarryIntroTransformer(value, carrySet2CPP);
    101104                        carryQIntro.transform(true, false);
    102105                       
    103                         Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP);
     106                        Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP, carrySet2CPP);
    104107                        pablo2CarryQ.transform(true, false);               
    105108                   
     
    115118                        if(PabloCompiler.addAssertBitBlockAlignStatements) {
    116119                                AssertBitBlockAlignStatementsTransformer assertBitBlockAlignStatementsTransformer
    117                                         = new AssertBitBlockAlignStatementsTransformer(value, builtins2CPP); 
     120                                        = new AssertBitBlockAlignStatementsTransformer(value, builtins2CPP, carrySet2CPP); 
    118121                                assertBitBlockAlignStatementsTransformer.transform();
    119122                        }                       
  • proto/pablo/src/compiler/PabloCompilerTestHarness.java

    r2655 r2657  
    1919import  logging.ScatterLogger;
    2020
     21import compiler.lang.carry.CarrySet2CPP;
     22import compiler.lang.carry.CarrySet2Lang;
    2123import compiler.lang.idisa.*;
    22 import compiler.lang.pablo.builtins.Builtins2CPP;
    23 import compiler.lang.pablo.builtins.Builtins2Lang;
     24import compiler.lang.pablo.Builtins2CPP;
     25import compiler.lang.pablo.Builtins2Lang;
    2426import compiler.visitors.*;
    2527import compiler.test.*;
     
    195197                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    196198                        ASTNode value = entry.getValue();                               
    197                        
    198                         Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP);
     199                        CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
     200                        Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP, carrySet2CPP);
    199201                        pablo2CarryQ.transform(ciMode, coMode);                 
    200202                       
  • proto/pablo/src/compiler/ReadMe.txt

    r2652 r2657  
    33332. Fix indentation. Nested if's etc.   
    3434//3. simd::constant<1>(0) <-- if CarryQ ignore
    35 4. Add assert compiler.
     35//4. Add assert compiler.
    3636//5. Add SIMD register dump.
    3737//6. if stream_function.carry_count > 0:
     
    4343   that is configurable based on the target back-end. e.g. C macro syntax
    4444   versus C++ template syntax etc.
     45 
     46   Done.
    4547   
    46482. Divide the compiler into phases to promote the decoupling of visitor passes.
     
    8183   generation scheme.
    8284         
    83          
     85   Pending.     
  • proto/pablo/src/compiler/lang/carry/CarrySet.java

    r2655 r2657  
    1 package compiler.lang.pablo.builtins;
     1package compiler.lang.carry;
    22
    3 public enum CarryQ {
    4                
    5         CARRYTEST(2, "CarryTest"),
    6         GETCARRYIN(1, "get_carry_in"),
    7         GETPENDING64(1, "get_pending64"),
    8         CARRYCOMBINE(3, "CarryCombine"),
    9         CARRYQADJUST(2, "CarryQ_Adjust"),
    10         CARRYFLIP(2, "carry_flip"),
    11         CARRYDEQUEUEENQUEUE(2, "CarryDequeueEnqueue"),
    12         VALUEOF(1, "cq[%d]");
     3public enum CarrySet {
     4       
     5        CARRYTEST(2),
     6        GETCARRYIN(1),
     7        GETPENDING64(1),
     8        CARRYCOMBINE(3),
     9        CARRYQADJUST(2),
     10        CARRYFLIP(2),
     11        CARRYDEQUEUEENQUEUE(2),
     12        VALUEOF(1);
    1313                       
    14         private final String cPPName;
    1514        private final int argCount;
    1615
    17         public static String CarryQ_PACKAGE_NAME = "CarryQ";
    18        
    19         CarryQ(int argCount, String cPPName ) {
     16        public static String CarryQ_TYPE = "CarryQ";
     17        public static String CarryQ_IDENTIFIER = "carryQ";
     18               
     19        CarrySet(int argCount ) {
    2020                this.argCount = argCount;
    21                 this.cPPName = cPPName;
    22         }
    23        
    24         public String cPPCode() {
    25                 return this.cPPName;
    2621        }
    2722       
  • proto/pablo/src/compiler/lang/idisa/BITBLOCK.java

    r2414 r2657  
    1717        private static final String BITBLOCK = "bitblock";
    1818       
    19         public String getFunctionName() { return BITBLOCK + "::" + name; }
    20         public int getArgCount() { return argCount; }
     19        public String IDISAName() { return BITBLOCK + "::" + name; }
     20        public int argCount() { return argCount; }
    2121}
    2222
  • proto/pablo/src/compiler/lang/idisa/SIMD.java

    r2444 r2657  
    5151                return (SIMD + "<" + Integer.toString(fieldWidth) + ">::" + CONSTANT.name + "<" + Integer.toString(constant) +">");
    5252        }
    53         public int getArgCount() { return argCount; }
     53        public int argCount() { return argCount; }
    5454               
    5555}
  • proto/pablo/src/compiler/lang/pablo/Builtins.java

    r2655 r2657  
    1 package compiler.lang.pablo.builtins;
     1package compiler.lang.pablo;
    22
    33import java.util.ArrayList;
  • proto/pablo/src/compiler/lang/pablo/Builtins2CPP.java

    r2655 r2657  
    1 package compiler.lang.pablo.builtins;
     1package compiler.lang.pablo;
    22
    33import java.util.HashMap;
  • proto/pablo/src/compiler/lang/pablo/Builtins2Lang.java

    r2655 r2657  
    1 package compiler.lang.pablo.builtins;
     1package compiler.lang.pablo;
    22
    33public abstract class Builtins2Lang {
  • proto/pablo/src/compiler/lang/pablo/BuiltinsUtil.java

    r2655 r2657  
    1 package compiler.lang.pablo.builtins;
     1package compiler.lang.pablo;
    22
    33import ast.*;
  • proto/pablo/src/compiler/visitors/AdvanceCombinerTransformer.java

    r2651 r2657  
    44import compiler.ast.Accessors;
    55import compiler.ast.Generators;
    6 import compiler.lang.pablo.builtins.BuiltinsUtil;
     6import compiler.lang.pablo.BuiltinsUtil;
    77
    88import tokens.*;
  • proto/pablo/src/compiler/visitors/AdvanceNCounterVisitor.java

    r2651 r2657  
    11package compiler.visitors;
    22
    3 import compiler.lang.pablo.builtins.BuiltinsUtil;
     3import compiler.lang.pablo.BuiltinsUtil;
    44import ast.*;
    55
  • proto/pablo/src/compiler/visitors/AssertBitBlockAlignStatementsTransformer.java

    r2655 r2657  
    44import compiler.ast.Accessors;
    55import compiler.ast.Generators;
    6 import compiler.lang.pablo.builtins.Builtins;
    7 import compiler.lang.pablo.builtins.Builtins2Lang;
     6import compiler.lang.pablo.Builtins;
     7import compiler.lang.pablo.Builtins2Lang;
     8import compiler.lang.carry.CarrySet2Lang;
    89
    910public class AssertBitBlockAlignStatementsTransformer {
    1011        private ASTNode ASTree;
     12       
    1113        private Builtins2Lang builtins2Lang;
     14        private CarrySet2Lang carrySet2Lang;
    1215       
    13         public AssertBitBlockAlignStatementsTransformer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
     16        public AssertBitBlockAlignStatementsTransformer(ASTNode ASTree, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
    1417                this.ASTree = ASTree;
    1518                this.builtins2Lang = builtins2Lang;
     19                this.carrySet2Lang = carrySet2Lang;
    1620        }
    1721       
  • proto/pablo/src/compiler/visitors/Bitwise2IDISATransformer.java

    r2644 r2657  
    109109                public void visitLeave(IfStatementNode node) {
    110110                        ASTNode ifTest = Accessors.ifTest(node);                       
    111                         String functionName = BITBLOCK.ANY.getFunctionName();
     111                        String functionName = BITBLOCK.ANY.IDISAName();
    112112                        FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(functionName,
    113113                                                                                                                                                                                                node.getToken(),
     
    122122                public void visitLeave(WhileStatementNode node) {
    123123                        ASTNode whileTest = Accessors.whileCondition(node);
    124                         String functionName = BITBLOCK.ANY.getFunctionName();
     124                        String functionName = BITBLOCK.ANY.IDISAName();
    125125                       
    126126                                                                                                                               
  • proto/pablo/src/compiler/visitors/CPPUnparser.java

    r2641 r2657  
    7171                CodeStore code = new CodeStore();
    7272                Iterator<CodeStore> iter = childResults.iterator();
    73                 code.setResultVariableName(makeDelimitedList(iter, ","));
     73                code.setResultVariableName(makeDelimitedList(iter, ", "));
    7474                return code;           
    7575        }               
     
    107107                CodeStore code = new CodeStore();               
    108108                Iterator<CodeStore> iter = childResults.iterator();
    109                 code.setResultVariableName(makeDelimitedList(iter, ","));               
     109                code.setResultVariableName(makeDelimitedList(iter, ", "));             
    110110                return code;
    111111        }
     
    162162                CodeStore code = new CodeStore();
    163163                Iterator<CodeStore> iter = childResults.iterator();
    164                 code.setResultVariableName(makeDelimitedList(iter, ","));
     164                code.setResultVariableName(makeDelimitedList(iter, ", "));
    165165                return code;
    166166        }
  • proto/pablo/src/compiler/visitors/CarryCounterVisitor.java

    r2651 r2657  
    22
    33import ast.*;
    4 import compiler.lang.pablo.builtins.BuiltinsUtil;
     4import compiler.lang.pablo.BuiltinsUtil;
    55
    66public class CarryCounterVisitor {
  • proto/pablo/src/compiler/visitors/CarryIntroTransformer.java

    r2655 r2657  
    55import compiler.ast.Accessors;
    66import compiler.ast.Generators;
    7 import compiler.lang.pablo.builtins.BuiltinsUtil;
    8 import compiler.lang.pablo.builtins.CarryQ;
     7import compiler.lang.carry.CarrySet;
     8import compiler.lang.carry.CarrySet2Lang;
     9import compiler.lang.pablo.BuiltinsUtil;
    910
    1011import ast.*;
     
    1314               
    1415        private ASTNode ASTTree; // FunctionDefNode     
     16       
     17        private CarrySet2Lang carrySet2Lang;
    1518               
    16     public CarryIntroTransformer(ASTNode node) {
     19    public CarryIntroTransformer(ASTNode node, CarrySet2Lang carrySet2Lang) {
    1720        assert node instanceof FunctionDefNode;
    1821        this.ASTTree = node;
     22        this.carrySet2Lang = carrySet2Lang;
    1923    }
    2024
     
    7175                               
    7276                                FunctionInvocationNode carryAdjustFunctionInvocation = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
    73                                                 new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYQADJUST.cPPCode()},
     77                                                new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.CARRYQADJUST)},
    7478                                                node.getToken(),
    7579                                                new ASTNode [] {carryCountNode});
     
    118122               
    119123                        FunctionInvocationNode rhs = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
    120                                         new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYTEST.cPPCode()},
     124                                        new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.CARRYTEST)},
    121125                                        node.getToken(),
    122126                                        new ASTNode [] {carryBaseNode, carryCountNode});
     
    130134                        // else part, append CarryDequeueEnqueue call
    131135                        FunctionInvocationNode carryDequeueEnqueue = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
    132                                         new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYDEQUEUEENQUEUE.cPPCode()},
     136                                        new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.CARRYDEQUEUEENQUEUE)},
    133137                                        node.getToken(),
    134138                                        new ASTNode [] {carryBaseNode, carryCountNode});
  • proto/pablo/src/compiler/visitors/DumpAssignmentStatementsTransformer.java

    r2655 r2657  
    44import compiler.ast.Accessors;
    55import compiler.ast.Generators;
    6 import compiler.lang.pablo.builtins.Builtins;
    7 import compiler.lang.pablo.builtins.Builtins2Lang;
     6import compiler.lang.pablo.Builtins;
     7import compiler.lang.pablo.Builtins2Lang;
    88
    99public class DumpAssignmentStatementsTransformer {
  • proto/pablo/src/compiler/visitors/Pablo2CarryTransformer.java

    r2655 r2657  
    66import compiler.ast.Accessors;
    77import compiler.ast.Generators;
     8import compiler.lang.carry.CarrySet;
     9import compiler.lang.carry.CarrySet2Lang;
    810import compiler.lang.idisa.SIMD;
    9 import compiler.lang.pablo.builtins.*;
     11import compiler.lang.pablo.*;
    1012
    1113
     
    1517               
    1618        private Builtins2Lang builtins2Lang;
     19        private CarrySet2Lang carrySet2Lang;
    1720       
    1821        private ASTNode ASTTree; // FunctionDefNode     
     
    2326        //    self.carryout = carryout   
    2427       
    25     public Pablo2CarryTransformer(ASTNode node, Builtins2Lang builtins2Lang) {
     28    public Pablo2CarryTransformer(ASTNode node, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
    2629        assert node instanceof FunctionDefNode;
    2730        this.ASTTree = node;
    2831        this.builtins2Lang = builtins2Lang;
     32        this.carrySet2Lang = carrySet2Lang;
    2933    }
    3034
     
    9599                        if(ciMode) {
    96100                                carryCall = Generators.makeFunctionInvocationNode(
    97                                                 new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()},
     101                                                new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.GETCARRYIN)},
    98102                                                node.getToken(),
    99103                                                new ASTNode [] {currentCarry});
    100104                               
    101105                                advNCall = Generators.makeFunctionInvocationNode(
    102                                                 new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()},
     106                                                new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.GETPENDING64)},
    103107                                                node.getToken(),
    104108                                                new ASTNode [] {currentAdvN});
     
    117121                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName(), Builtins.ADVANCE.argCount())) {         
    118122                                replaceFunctionInvocationNode(node,
    119                                                 CarryQ.CarryQ_PACKAGE_NAME,
     123                                                CarrySet.CarryQ_IDENTIFIER,
    120124                                                builtins2Lang.getCode(Builtins.ADVANCE),
    121125                                                carryCall,
     
    132136                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloName(), Builtins.SCANTHRU.argCount())) {                           
    133137                                replaceFunctionInvocationNode(node,
    134                                                 CarryQ.CarryQ_PACKAGE_NAME,
     138                                                CarrySet.CarryQ_IDENTIFIER,
    135139                                                builtins2Lang.getCode(Builtins.SCANTHRU),
    136140                                                carryCall,
     
    147151                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
    148152                                replaceFunctionInvocationNode(node,
    149                                                 CarryQ.CarryQ_PACKAGE_NAME,
     153                                                CarrySet.CarryQ_IDENTIFIER,
    150154                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
    151155                                                carryCall,
     
    162166                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloName(), Builtins.SPANUPTO.argCount())) {
    163167                                replaceFunctionInvocationNode(node,
    164                                                 CarryQ.CarryQ_PACKAGE_NAME,
     168                                                CarrySet.CarryQ_IDENTIFIER,
    165169                                                builtins2Lang.getCode(Builtins.SPANUPTO),
    166170                                                carryCall,
     
    179183                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloName(), Builtins.ADVANCETHENSCANTO.argCount())) {
    180184                                replaceFunctionInvocationNode(node,
    181                                                 CarryQ.CarryQ_PACKAGE_NAME,
     185                                                CarrySet.CarryQ_IDENTIFIER,
    182186                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTO),
    183187                                                carryCall,
     
    197201                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloName(), Builtins.INCLUSIVESPAN.argCount())) {
    198202                                replaceFunctionInvocationNode(node,
    199                                                 CarryQ.CarryQ_PACKAGE_NAME,
     203                                                CarrySet.CarryQ_IDENTIFIER,
    200204                                                builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
    201205                                                carryCall,
     
    215219                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloName(), Builtins.EXCLUSIVESPAN.argCount())) {
    216220                                replaceFunctionInvocationNode(node,
    217                                                 CarryQ.CarryQ_PACKAGE_NAME,
     221                                                CarrySet.CarryQ_IDENTIFIER,
    218222                                                builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
    219223                                                carryCall,
     
    235239                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloName(), Builtins.SCANTO.argCount())) {
    236240                                replaceFunctionInvocationNode(node,
    237                                                 CarryQ.CarryQ_PACKAGE_NAME,
     241                                                CarrySet.CarryQ_IDENTIFIER,
    238242                                                builtins2Lang.getCode(Builtins.SCANTO),
    239243                                                carryCall,
     
    252256                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
    253257                                replaceFunctionInvocationNode(node,
    254                                                 CarryQ.CarryQ_PACKAGE_NAME,
     258                                                CarrySet.CarryQ_IDENTIFIER,
    255259                                                builtins2Lang.getCode(Builtins.SCANTOFIRST),
    256260                                                carryCall,
     
    269273                                // TODO ==> verify advNCall
    270274                                replaceFunctionInvocationNode(node,
    271                                                 CarryQ.CarryQ_PACKAGE_NAME,
     275                                                CarrySet.CarryQ_IDENTIFIER,
    272276                                                builtins2Lang.getCode(Builtins.ADVANCE32),
    273277                                                advNCall,
     
    286290                                // TODO ==> verify advNCall
    287291                                replaceFunctionInvocationNode(node,
    288                                                 CarryQ.CarryQ_PACKAGE_NAME,
     292                                                CarrySet.CarryQ_IDENTIFIER,
    289293                                                builtins2Lang.getCode(Builtins.ADVANCE32),
    290294                                                advNCall,
Note: See TracChangeset for help on using the changeset viewer.