Changeset 2377


Ignore:
Timestamp:
Sep 17, 2012, 6:34:36 PM (6 years ago)
Author:
ksherdy
Message:

Updated test cases.

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

Legend:

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

    r2374 r2377  
    4040        s ~= 0;
    4141        s ^= 0;
    42 };function struct A, struct B FunctionExpressions() {
     42};function struct A FunctionExpressions() {
    4343         a.b.Advance();
    4444};
     
    717717};
    718718
     719struct BasisBits {
     720        stream<1> b1;
     721        stream<1> b2;
     722        stream<1> b3;
     723        stream<1> b4;
     724};
     725struct BasisBits {
     726        stream b1;
     727        stream b2;
     728        stream b3;
     729        stream b4;
     730};
     731function void AssignmentExpressions() {
     732        temp4 = temp;
     733        temp4 &= temp1 | temp2;
     734        temp4 |= temp1 ^ temp2;
     735        temp4 ^= temp1 & temp2;
     736        temp4 ~= temp1 ^ temp2 | temp3;
     737};function void BasicExpressions() {
     738
     739        temp4 = temp;
     740        temp4 = temp1 | temp2;
     741        temp4 = temp1 ^ temp2;
     742        temp4 = temp1 & temp2;
     743        temp4 = temp1 ^ temp2 | temp3;
     744        temp4 = temp1 | temp2 ^ temp3;
     745        temp4 = temp1 & temp2 | temp3;
     746        temp4 = temp1 | temp2 & temp3;
     747        temp4 = temp1 & (temp2 | temp3);
     748        temp4 = (temp1 | temp2) & temp3;
     749        temp4 = ~temp;
     750       
     751};
     752
     753function void Assignments() {
     754        var stream s;
     755        s = 0;
     756        s &= 0;
     757        s |= 0;
     758        s ~= 0;
     759        s ^= 0;
     760};function struct A FunctionExpressions() {
     761         a.b.Advance();
     762};
     763function void RecordExpressions() {
     764
     765        // records
     766        temp4 = temp1.temp2;
     767        temp4 = temp1.temp2.temp3;
     768       
     769        temp1.temp2 = temp4;
     770        temp1.temp2.temp3 = temp4;
     771               
     772};function void Function() {
     773var stream cursor = pablo.ScanToFirst(lex.opener);
     774}function void localDecl() {
     775        var stream A;
     776        var stream A=0;
     777        var stream a=0,b=0,c=0;
     778}function void localDecl() {
     779
     780var struct BasisBits {
     781stream<1> b1;
     782stream<1> b2;
     783stream<1> b3;
     784stream<1> b4;
     785} A,B,C;
     786
     787};function void Assignments() {
     788        var stream s = 4;
     789        var stream s &= 4;
     790        var stream s |= 4;
     791        var stream s ~= 4;
     792        var stream s ^= 4;
     793};function void localDecl() {
     794
     795        var struct BasisBits {
     796        stream b1;
     797        stream b2;
     798        stream b3;
     799        stream b4;
     800        } A,B ;
     801
     802} function void Function() {   
     803       
     804        if(cursor & a) {
     805                if(cursor & b) {
     806               
     807                }
     808        }
     809       
     810};
     811function void Function() {     
     812       
     813        if(cursor & a) {
     814                if(cursor & b) {
     815               
     816                } else {
     817               
     818                }
     819
     820        } else {
     821
     822        }
     823       
     824};
     825function void Function() {             
     826        if(cursor) {
     827
     828        }
     829};
     830function void Function() {     
     831       
     832        if(cursor & a) {
     833
     834        } else {
     835
     836        }
     837       
     838};
     839/*
     840        Block comment.
     841*/
     842
     843// EOL terminated comment.
     844
     845// Another EOL terminated comment.
     846
     847function struct Lex ClassifyBytes(struct BasisBit basis) {};
     848function stream Function(stream a, stream b, stream c) {};
     849function void Lex() {};
     850struct Lex {
     851        stream LAngle;
     852        stream RAngle;
     853};
     854
     855typedef struct Lex Lex;
     856
     857typedef Lex Lex;typedef stream s;
     858
     859typedef stream<1> s1;typedef struct BasisBits {
     860stream b1;
     861stream b2;
     862stream b3;
     863stream b4;
     864} BasisBitsAlias;# Demo - Hand ported Python pablo code (parses)
     865#
     866# Removed '-' operators.
     867# Added statement terminators as needed ';'
     868
     869struct Basis_bits{     
     870        stream bit_0;
     871        stream bit_1;
     872        stream bit_2;
     873        stream bit_3;
     874        stream bit_4;
     875        stream bit_5;
     876        stream bit_6;
     877        stream bit_7;
     878};
     879
     880struct u8 {
     881  stream unibyte;
     882  stream prefix;
     883  stream prefix2;
     884  stream prefix3;
     885  stream prefix4;
     886  stream suffix;
     887  stream badprefix;
     888  stream xE0;
     889  stream xED;
     890  stream xF0;
     891  stream xF4;
     892  stream xA0_xBF;
     893  stream x80_x9F;
     894  stream x90_xBF;
     895  stream x80_x8F;
     896  stream xEF;
     897  stream xBF;
     898  stream xBE;
     899  stream scope22;
     900  stream scope32;
     901  stream scope33;
     902  stream scope42;
     903  stream scope43;
     904  stream scope44;
     905  stream xE0_scope;
     906  stream xED_scope;
     907  stream xF0_scope;
     908  stream xF4_scope;
     909  stream xEF_scope;
     910};
     911
     912struct Lex {
     913        stream CR;
     914        stream LF;
     915        stream HT;
     916        stream SP;
     917        stream CRLF;
     918        stream RefStart;
     919        stream Semicolon; 
     920        stream Colon;
     921        stream LAngle;
     922        stream RAngle;
     923        stream LBracket;
     924        stream RBracket;
     925        stream Exclam;
     926        stream QMark;
     927        stream Hyphen;
     928        stream Equals;
     929        stream SQuote;
     930        stream DQuote;
     931        stream Slash;
     932        stream Hash;
     933        stream x;
     934        stream ASCII_name_start;
     935        stream ASCII_name_char;
     936        stream NameScan;
     937        stream Digit;
     938        stream Hex;
     939        stream WS;
     940};
     941
     942struct Marker {
     943        stream LAngle_scope;
     944        stream Ref_opener;
     945        stream CD_closer;
     946};
     947
     948struct CtCDPI_Callouts{
     949        stream Ct_starts;
     950        stream Ct_ends;
     951        stream CD_starts;
     952        stream CD_ends;
     953        stream PI_starts;
     954        stream PI_name_starts;
     955        stream PI_name_ends;
     956        stream PI_ends;
     957};
     958
     959struct Ref_Callouts{
     960        stream GenRef_starts;
     961        stream GenRef_ends;
     962        stream DecRef_starts;
     963        stream DecRef_ends;
     964        stream HexRef_starts;
     965        stream HexRef_ends;
     966};
     967
     968struct Tag_Callouts{
     969        stream ElemName_starts;
     970        stream ElemName_ends;
     971        stream AttName_starts;
     972        stream AttName_ends;
     973        stream AttVal_starts;
     974        stream AttVal_ends;
     975        stream AttVal_spans;
     976        stream EmptyTag_marks;
     977        stream EndTag_marks;
     978};
     979       
     980struct Check_streams{
     981        stream misc_mask;
     982        stream non_ascii_name_starts;
     983        stream non_ascii_names;
     984        stream tag_marks;
     985        stream name_follows;
     986        stream att_refs;
     987};
     988
     989function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) { 
     990        temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
     991        temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
     992        temp3 = (temp2 &~ temp1);
     993        temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
     994        temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
     995        temp6 = (temp4 & temp5);
     996        lex.RefStart = (temp3 & temp6);
     997        temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
     998        temp8 = (temp7 &~ temp1);
     999        temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
     1000        temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
     1001        temp11 = (temp9 & temp10);
     1002        lex.Semicolon = (temp8 & temp11);
     1003        temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
     1004        temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
     1005        temp14 = (temp12 &~ temp13);
     1006        lex.LAngle = (temp8 & temp14);
     1007        temp15 = (temp12 & temp5);
     1008        lex.RAngle = (temp8 & temp15);
     1009        temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
     1010        temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
     1011        temp18 = (temp16 & temp17);
     1012        lex.LBracket = (temp18 & temp11);
     1013        temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
     1014        temp20 = (temp12 & temp19);
     1015        lex.RBracket = (temp18 & temp20);
     1016        temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
     1017        temp22 = (temp19 &~ temp21);
     1018        lex.Exclam = (temp3 & temp22);
     1019        temp23 = (temp12 & temp10);
     1020        lex.QMark = (temp8 & temp23);
     1021        lex.Hyphen = (temp3 & temp20);
     1022        lex.Equals = (temp8 & temp20);
     1023        temp24 = (temp4 & temp10);
     1024        lex.SQuote = (temp3 & temp24);
     1025        temp25 = (temp5 &~ temp21);
     1026        lex.DQuote = (temp3 & temp25);
     1027        lex.Slash = (temp3 & temp23);
     1028        temp26 = (temp10 &~ temp21);
     1029        lex.Hash = (temp3 & temp26);
     1030        temp27 = (temp16 & temp7);
     1031        temp28 = (temp9 &~ temp13);
     1032        lex.x = (temp27 & temp28);
     1033        temp29 = (temp9 & temp5);
     1034        lex.Colon = (temp8 & temp29);
     1035        temp30 = (temp18 & temp23);
     1036        temp31 = (temp30 | lex.Colon);
     1037        temp32 = (temp16 &~ basis_bits.bit_2);
     1038        temp33 = (basis_bits.bit_5 | temp10);
     1039        temp34 = (basis_bits.bit_4 & temp33);
     1040        temp35 = (~temp34);
     1041        temp36 = (temp21 | temp13);
     1042        temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
     1043        temp38 = (temp32 & temp37);
     1044        temp39 = (temp31 | temp38);
     1045        temp40 = (temp16 & basis_bits.bit_2);
     1046        temp41 = (temp40 & temp37);
     1047        lex.ASCII_name_start = (temp39 | temp41);
     1048        temp42 = (temp30 | lex.Hyphen);
     1049        temp43 = (temp3 & temp15);
     1050        temp44 = (temp42 | temp43);
     1051        temp45 = (temp8 &~ temp34);
     1052        temp46 = (temp44 | temp45);
     1053        temp47 = (temp46 | temp38);
     1054        lex.ASCII_name_char = (temp47 | temp41);
     1055        lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
     1056        temp48 = (temp1 | basis_bits.bit_2);
     1057        x00_x1F = (~temp48);
     1058        temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
     1059        temp50 = (temp1 | temp49);
     1060        lex.CR = (temp20 &~ temp50);
     1061        lex.LF = (temp29 &~ temp50);
     1062        temp51 = (temp9 & temp19);
     1063        lex.HT = (temp51 &~ temp50);
     1064        lex.SP = (temp3 &~ temp36);
     1065        temp52 = (temp20 | temp29);
     1066        temp53 = (temp52 | temp51);
     1067        temp54 = (temp53 &~ temp50);
     1068        lex.WS = (temp54 | lex.SP);
     1069        temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
     1070        temp56 = (basis_bits.bit_4 & temp55);
     1071        lex.Digit = (temp8 &~ temp56);
     1072        temp57 = (temp16 &~ temp49);
     1073        temp58 = (temp57 &~ basis_bits.bit_4);
     1074        temp59 = (~temp10);
     1075        temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
     1076        temp61 = (temp58 & temp60);
     1077        temp62 = (lex.Digit | temp61);
     1078        temp63 = (temp16 & temp2);
     1079        temp64 = (temp63 &~ basis_bits.bit_4);
     1080        temp65 = (temp64 & temp60);
     1081        lex.Hex = (temp62 | temp65);
     1082        lex_error = x00_x1F &~ lex.WS;
     1083        pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
     1084               
     1085       
     1086        ### Validate_utf8(basis_bits, u8):
     1087        u8.unibyte = (~basis_bits.bit_0);
     1088        u8.suffix = 0;
     1089        u8_error = 0;
     1090        u8_FFFE_FFFF = 0;
     1091        u8anyscope = 0; #local
     1092        if (basis_bits.bit_0) {
     1093                u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     1094                u8.prefix2 = (u8.prefix &~ basis_bits.bit_2);
     1095                u8.prefix3 = (u8.prefix & temp2);
     1096                u8.prefix4 = (u8.prefix & temp7);
     1097                u8.suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
     1098                temp66 = (u8.prefix &~ temp49);
     1099                temp67 = (temp21 | basis_bits.bit_6);
     1100                temp68 = (temp66 &~ temp67);
     1101                temp69 = (basis_bits.bit_5 & temp13);
     1102                temp70 = (basis_bits.bit_4 | temp69);
     1103                temp71 = (u8.prefix4 & temp70);
     1104                u8.badprefix = (temp68 | temp71);
     1105                u8_error = u8.badprefix;
     1106                u8.scope22 = pablo.Advance(u8.prefix2);
     1107                u8anyscope = u8.scope22;
     1108                if (u8.prefix3 | u8.prefix4) {
     1109                        xE0 = (u8.prefix3 &~ temp36);
     1110                        xED = (u8.prefix3 & temp20);
     1111                        xF0 = (u8.prefix4 &~ temp36);
     1112                        temp72 = (temp4 &~ temp13);
     1113                        xF4 = (u8.prefix4 & temp72);
     1114                        u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
     1115                        u8.x80_x9F = (u8.suffix &~ basis_bits.bit_2);
     1116                        u8.x90_xBF = (u8.suffix & temp49);
     1117                        u8.x80_x8F = (u8.suffix &~ temp49);
     1118                        xEF = (u8.prefix3 & temp23);
     1119                        temp73 = (u8.suffix & temp7);
     1120                        u8.xBF = (temp73 & temp23);
     1121                        u8.xBE = (temp73 & temp15);
     1122#
     1123
     1124#                       scope3_32 = pablo.Advance32(u8.prefix3)
     1125#                       scope4_32 = pablo.Advance32(u8.prefix4)
     1126#                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
     1127#                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
     1128#                       u8.scope42 = interpose32(u8.prefix4, scope4_32, 1)
     1129#                       u8.scope43 = interpose32(u8.prefix4, scope4_32, 2)
     1130#                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
     1131#
     1132                        u8.scope32 = pablo.Advance(u8.prefix3);
     1133                        u8.scope33 = pablo.Advance(u8.scope32);
     1134                        u8.scope42 = pablo.Advance(u8.prefix4);
     1135                        u8.scope43 = pablo.Advance(u8.scope42);
     1136                        u8.scope44 = pablo.Advance(u8.scope43);
     1137#
     1138#                       u8.xE0_scope = pablo.Advance(xE0);
     1139#                       u8.xED_scope = pablo.Advance(xED);
     1140#                       u8.xF0_scope = pablo.Advance(xF0);
     1141#                       u8.xF4_scope = pablo.Advance(xF4);
     1142                        E0_F0_scope = pablo.Advance(xE0 | xF0);
     1143                        ED_F4_scope = pablo.Advance(xED | xF4);
     1144                        u8.xE0_scope = u8.scope32 & E0_F0_scope;
     1145                        u8.xED_scope = u8.scope32 & ED_F4_scope;
     1146                        u8.xF0_scope = u8.scope42 & E0_F0_scope;
     1147                        u8.xF4_scope = u8.scope42 & ED_F4_scope;
     1148                        u8.xEF_scope = pablo.Advance(xEF);
     1149
     1150                        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44;
     1151                        u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43;
     1152               
     1153                        u8error1 = u8.xE0_scope & u8.x80_x9F;
     1154                        u8error2 = u8.xED_scope & u8.xA0_xBF;
     1155                        u8error3 = u8.xF0_scope & u8.x80_x8F;
     1156                        u8error4 = u8.xF4_scope & u8.x90_xBF;
     1157       
     1158                        u8_error |= u8error1 | u8error2 | u8error3 | u8error4;
     1159
     1160                        EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF);
     1161
     1162                        u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
     1163                }               
     1164                u8mismatch = u8anyscope ^ u8.suffix;
     1165                pablo.assert_0(u8_error | u8mismatch | u8_FFFE_FFFF, "UTF-8 error found");
     1166        }
     1167};
     1168
     1169function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
     1170        ctCDPI_Callouts.Ct_starts = 0;
     1171        ctCDPI_Callouts.Ct_ends = 0;
     1172        ctCDPI_Callouts.CD_starts = 0;
     1173        ctCDPI_Callouts.CD_ends = 0;
     1174        ctCDPI_Callouts.PI_starts = 0;
     1175        ctCDPI_Callouts.PI_name_starts = 0;
     1176        ctCDPI_Callouts.PI_name_ends = 0;
     1177        ctCDPI_Callouts.PI_ends = 0;
     1178        CtCDPI_starts = 0;
     1179        CtCDPI_ends = 0;
     1180        ctCDPI_mask = 0;
     1181
     1182        v = lex.LAngle | lex.Hyphen;
     1183        w = lex.Hyphen | lex.QMark;
     1184        v1 = pablo.Advance(v,1);
     1185        w1 = pablo.Advance(w,1);
     1186       
     1187        LAngle_scope = v1 &~ w1;  #pablo.Advance(lex.LAngle);
     1188        PI_opener = LAngle_scope & lex.QMark;
     1189        CtCD_opener= LAngle_scope & lex.Exclam;
     1190        CtCDPI_opener = PI_opener | CtCD_opener;
     1191
     1192        #DoubleHyphen = 0;
     1193        CD_closer = 0;
     1194        #PI_closer = 0;
     1195       
     1196        #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
     1197        DoubleHyphen = v1 & w1 & lex.Hyphen;
     1198        if (lex.RBracket) {
     1199                DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket;
     1200                CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle;
     1201        }
     1202        #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
     1203        PI_closer = w1 & ~v1 & lex.RAngle;
     1204
     1205        #
     1206        # Initiate the scan
     1207        CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     1208        while (CtCDPI_Cursor) {
     1209                CtCDPI_starts |= CtCDPI_Cursor;
     1210                PI_Cursor = CtCDPI_Cursor & PI_opener;
     1211                CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor);
     1212                CD_Cursor = CD_Ct_Cursor & lex.LBracket;
     1213                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen ;
     1214                # PI processing
     1215                if (PI_Cursor) {
     1216                        ctCDPI_Callouts.PI_starts |= PI_Cursor;
     1217                        PI_Cursor = pablo.Advance(PI_Cursor);
     1218                        ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
     1219                        PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
     1220                        PI_error = PI_Cursor & PI_name_end;
     1221                        PI_noWS = PI_name_end & ~ lex.WS;
     1222                        PI_error |= PI_noWS &~ lex.QMark | pablo.Advance(PI_noWS) &~ PI_closer;
     1223                        pablo.assert_0(PI_error, "Error in PI syntax");
     1224                        ctCDPI_Callouts.PI_name_ends |= PI_name_end;
     1225                        PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
     1226                        ctCDPI_Callouts.PI_ends |= PI_Cursor;
     1227                        CtCDPI_ends |= PI_Cursor;
     1228                }
     1229                # CDATA section processing
     1230                if (CD_Cursor) {
     1231                        ctCDPI_Callouts.CD_starts |= CD_Cursor;
     1232                        CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
     1233                        ctCDPI_Callouts.CD_ends |= CD_Cursor;
     1234                        CtCDPI_ends |= CD_Cursor;
     1235                }
     1236                # Comment processing
     1237                if (Ct_Cursor) {
     1238                        ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
     1239                        Ct_Cursor = pablo.Advance(Ct_Cursor); 
     1240                        Ct_error = Ct_Cursor & ~ lex.Hyphen;
     1241                        # Advance twice past <!--, so that we don't treat <!---
     1242                        # as being a terminated comment.
     1243                        Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
     1244                        Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
     1245                        pablo.assert_0(Ct_error | Ct_Cursor & ~ lex.RAngle, "Error in comment syntax");
     1246                        ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
     1247                        CtCDPI_ends |= Ct_Cursor;
     1248                }
     1249                # Common processing
     1250                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor;
     1251                ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
     1252# '-' Not Supported.           
     1253#               ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends;
     1254                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
     1255                pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
     1256                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)      ;
     1257        }
     1258# '-' Not Supported.           
     1259#       check_streams.misc_mask = (lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends)  -(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
     1260#  Following is slow
     1261        check_streams.misc_mask = (lex.WS | lex.LAngle | pablo.InclusiveSpan(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts, ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends) | CtCDPI_starts) & EOF_mask;
     1262
     1263
     1264        # Identify the remaining significant markers for XML processing.
     1265        marker.LAngle_scope = LAngle_scope &~ ctCDPI_mask;
     1266        marker.Ref_opener = lex.RefStart &~ ctCDPI_mask;
     1267        marker.CD_closer = CD_closer &~ ctCDPI_mask;
     1268};
     1269
     1270function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
     1271       
     1272        # Delimiters for scans.
     1273        DQuoteDelim = lex.DQuote | lex.LAngle;
     1274        SQuoteDelim = lex.SQuote | lex.LAngle;
     1275        AttListDelim = lex.Slash | lex.RAngle;
     1276       
     1277        # Start the parallel parsing by inspecting the character
     1278        # after the opening "<" of a tag.
     1279        tag_Callouts.ElemName_starts = marker.LAngle_scope & ~lex.Slash;
     1280        tag_Callouts.EndTag_marks = marker.LAngle_scope & lex.Slash;
     1281       
     1282        # Start Tag/Empty Element Tag Parsing
     1283
     1284        # Advance all cursors by scanning through the tag name.
     1285        tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
     1286        # Must have at least one name character for a legal start tag.
     1287        # Mark any occurrences of null names as errors.
     1288        ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends;
     1289       
     1290        # Initialize the accumulators for attribute name and value positions.
     1291        tag_Callouts.AttName_starts = 0; 
     1292        tag_Callouts.AttName_ends = 0;
     1293        tag_Callouts.AttVal_starts = 0;
     1294        tag_Callouts.AttVal_ends = 0;
     1295
     1296        # After the element name, there may or may not be an attlist.
     1297        if (tag_Callouts.ElemName_ends & lex.WS) {
     1298                AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
     1299                AttListEnd = AfterWS & AttListDelim;
     1300                AttNameStart = AfterWS & ~AttListDelim;
     1301                #
     1302                # The following loop iterates through attributes within a start tag.
     1303                # Because all start tags are processed in parallel, the number of
     1304                # iterations is the maximum number of attributes found in any one
     1305                # start tag, plus one.
     1306                while (AttNameStart) {
     1307                        ParseError |= AttNameStart &~ lex.NameScan;
     1308                        tag_Callouts.AttName_starts |= AttNameStart;
     1309                        AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
     1310                        tag_Callouts.AttName_ends |= AttNameFollow;
     1311                        # Scan through WS to the expected '=' delimiter.
     1312                        # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
     1313                        # But use if test to optimize.
     1314                        if (AttNameFollow & lex.WS) {
     1315                                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
     1316                        } else { EqExpected = AttNameFollow;
     1317                        ParseError |= EqExpected &~ lex.Equals;
     1318                        AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
     1319#                       AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
     1320                        tag_Callouts.AttVal_starts |= AttValPos;
     1321                        DQuoteAttVal = AttValPos & lex.DQuote;
     1322                        SQuoteAttVal = AttValPos & lex.SQuote;
     1323#                       DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
     1324#                       SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
     1325                        DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
     1326                        SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
     1327                        AttValEnd = DQuoteAttEnd | SQuoteAttEnd;
     1328                        ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote);
     1329                        AttValFollow = pablo.Advance(AttValEnd);
     1330                        tag_Callouts.AttVal_ends |= AttValFollow;
     1331                        #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
     1332                        }
     1333                        if (AttValFollow & lex.WS) {
     1334                                AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
     1335                                AttListEnd |= AfterWS & AttListDelim;
     1336                                AttNameStart = AfterWS & ~AttListDelim;
     1337                        } else {
     1338                                AttListEnd |= AttValFollow & AttListDelim;     
     1339                                AttNameStart = 0;
     1340                                ParseError |= AttValFollow & ~AttListDelim;
     1341                        }
     1342                }
     1343        } else {
     1344                # No WS character after ElemName; must be at the end
     1345                AttListEnd = tag_Callouts.ElemName_ends & AttListDelim;
     1346                ParseError |= tag_Callouts.ElemName_ends & ~AttListDelim;
     1347        }
     1348       
     1349        STagEnds = AttListEnd & lex.RAngle;
     1350        # Mark any "/" characters found as the ends of empty element tags.
     1351        tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash);
     1352       
     1353        ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle;
     1354
     1355        # End Tag Parsing
     1356
     1357        EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
     1358        if (EndTagEnds & lex.WS) {
     1359                EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
     1360        }
     1361        ParseError |= EndTagEnds & ~lex.RAngle;
     1362        pablo.assert_0(ParseError, "Tag parsing error found");
     1363               
     1364               
     1365        # Attribute value spans
     1366#       tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
     1367        tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
     1368};
     1369
     1370function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
     1371        ref_Callouts.GenRef_starts = 0;
     1372        ref_Callouts.GenRef_ends = 0;
     1373        ref_Callouts.DecRef_starts = 0;
     1374        ref_Callouts.DecRef_ends = 0;
     1375        ref_Callouts.HexRef_starts = 0;
     1376        ref_Callouts.HexRef_ends = 0;
     1377        ref_error = 0;
     1378
     1379        # All remaining "&" must be reference start characters; parse them.
     1380        if (marker.Ref_opener) {
     1381                Ref_scope = pablo.Advance(marker.Ref_opener);
     1382                NumRef2 = Ref_scope & lex.Hash;
     1383                ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash;
     1384                NumRef3 = pablo.Advance(NumRef2);
     1385                HexRef3 = NumRef3 & lex.x;
     1386                ref_Callouts.DecRef_starts = NumRef3 &~ lex.x;
     1387                ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
     1388                ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan);
     1389                ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
     1390                ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
     1391                # Error checks
     1392                # At least one digit required for DecRef, one hex digit for HexRef.
     1393                ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit;
     1394                ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex;
     1395                # Semicolon terminator required (also covers unterminated at EOF).
     1396                ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends;
     1397                ref_error3 = ref_ends &~ lex.Semicolon;
     1398                pablo.assert_0(ref_error1 | ref_error2 | ref_error3, "Reference error found");
     1399        }               
     1400};
     1401
     1402function void Validate_xml_names(struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Lex lex, struct U8 u8, struct Check_streams check_streams) {
     1403#       PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
     1404#       GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
     1405#       ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
     1406#       AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
     1407        PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
     1408        GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
     1409        ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
     1410        AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
     1411        qname_stream =  ElemNames | AttNames;
     1412        ncname_stream = PI_names | GenRefs;
     1413        name_stream = qname_stream | ncname_stream;
     1414        name_start = name_stream &~ pablo.Advance(name_stream);
     1415        name_cursor = name_stream & ~pablo.Advance(name_stream);
     1416        void_prefix_err = name_cursor & lex.Colon;
     1417        namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon;
     1418        local_part_start = pablo.Advance(namespace_sep);
     1419        local_part_err = local_part_start &~ lex.NameScan;
     1420        colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon;
     1421        ncname_err = ncname_stream & lex.Colon;
     1422        pablo.assert_0(void_prefix_err | local_part_err | colon2_err | ncname_err, "name syntax error");
     1423               
     1424                       
     1425        check_streams.non_ascii_name_starts = name_start &~lex.ASCII_name_start;
     1426        check_streams.non_ascii_names = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix;
     1427   
     1428};   
     1429   
     1430function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
     1431        pablo.assert_0(marker.CD_closer & ~tag_Callouts.AttVal_spans, "Error: ]]> in text");
     1432        check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts;
     1433        check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends;
     1434        check_streams.att_refs = tag_Callouts.AttVal_spans & marker.Ref_opener;
     1435};
     1436
  • proto/pablo/input/test/pablo/statements/assign/assign6.pablo

    r2374 r2377  
    1 function struct A, struct B FunctionExpressions() {
     1function struct A FunctionExpressions() {
    22         a.b.Advance();
    33};
Note: See TracChangeset for help on using the changeset viewer.