Changeset 3004


Ignore:
Timestamp:
Apr 8, 2013, 1:37:17 AM (6 years ago)
Author:
ksherdy
Message:

Implemented framework skeleton to support PabloB IDISA function call translation to C,C++,LLVM.

Location:
proto/pabloj/trunk
Files:
16 added
9 deleted
108 edited
2 copied
8 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/docs/notes

    r2988 r3004  
    19191. Add field width to pablo.operation builtin calls.
    2020        e.g. pablo.operation() -> pablos.operation<fw>(...)
    21 
    2221
    2322--------------------------------------------------------------------------------
     
    4443       
    4544       
     45IDISA enum and Signatures ...
     46
     47Signatures has-a build method
     48
     49Build method takes a builder
     50
     51Generator Visitor takes a builder argument     
    4652       
    4753================================================================================
  • proto/pabloj/trunk/input/grammar/scatter/pabloB.scatter

    r2988 r3004  
    44// PabloB (block-at-a-time language)
    55//
    6 // Modified: 02-12-2012 - Original definition.
    7 // Modified: 29-03-2013 - Added IDISA function call.
    8 //                                              - Added 2^k integer types.
    9 //
    10 // TODO: Add BlockMode blocks to specify SIMD field width.
    11 // TODO: Add compile time integer expressions evaluation '+','-','*','/'.
    12 // TODO: Add Code Block.
    13 //
     6// Modified:    02-12-2012      Original definition.
     7//                      29-03-2013      Added IDISA function call.
     8//                              06-04-2013      Updated to Scatter with types.
     9//
     10// TODO:                Add BlockMode blocks to specify SIMD field width.
     11//                              Add compile time integer expressions evaluation '+','-','*','/'.
     12//                              Add Code Block.
     13
     14types {}
     15
    1416context main {
    1517  recognizers {
     
    3335        KERNEL,
    3436        FUNCTION,       
    35         STREAM,
     37        STREAM, // TODO - remove
    3638        STRUCT,
    3739        VOID,
    3840       
    39         UINT8           "uint8",
    40         UINT16          "uint16",
    41         UINT32          "uint32",
    42         UINT64          "uint64",
    43         UINT128         "uint128",
    44         UINT256         "uint256",
     41        BITFIELD        "BitField",     
    4542        BITBLOCK        "BitBlock", // alias for architecture dependent SIMD instruction width
    4643       
     
    7370//       escapable {boolean escaped = false;},
    7471         intValued {int value = 0;},
     72         
    7573}
    7674
    7775nodes {
    78   assign {} [assignRest],
    79   funcCall {} [funcCallRest],
    80   idisaCall {} [idisaCallRest],
    81   integerConstant{intValued;} [],
    82   streamConstant{intValued;} [],
     76        assign {} [assignRest],
     77        funcCall {} [funcCallRest],
     78        idisaFuncCall {} [idisaFuncCallRest],
     79        integerConstant{intValued;} [],
     80        streamConstant{intValued;} [],
    8381}
    8482
     
    106104        //
    107105               
    108         kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)*  RCURLY TERMINATOR? ;
     106        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)* expr TERMINATOR? RCURLY TERMINATOR? ; // TODO - hack - stick CarryDeclare at end for now
    109107       
    110108        kernelName                      #-> identifier ;
     
    115113        initDef                         ->  INIT initBlock TERMINATOR? ;
    116114       
    117         // initBlock                    #-> LCURLY (stateInitStmt)* RCURLY;
    118        
    119         initBlock                       #-> LCURLY (funcCallOrAssignStmt)* RCURLY; // TODO - hack - stick carry set decl stuff in the init section for now
    120        
     115        initBlock                       #-> LCURLY (stateInitStmt)* RCURLY;
     116               
    121117        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
    122118       
     
    159155        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    160156       
    161         funcCallOrAssignStmt    #-> expr ( (idisaCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
     157        funcCallOrAssignStmt    #-> expr ( (idisaFuncCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
    162158       
    163159        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
     
    165161        funcCallArgList                 -> (expr (COMMA expr)*)? ;
    166162       
    167         idisaCallRest                   -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
    168 
    169         idisaCallArgList                -> (expr (COMMA expr)*)? ;     
     163        idisaFuncCallRest               -> LANGLE^ fieldWidth RANGLE LROUND (expr (COMMA expr)*)? RROUND;
     164
     165        //idisaFuncCallArgList  ->  (expr (COMMA expr)*)? ;
    170166               
    171167        assignOperator                  -> ASSIGN;                             
     
    191187                                        |integerConstant
    192188                                        | stringConstant
    193                                         | compoundIdentifier (funcCallRest _promote_ | idisaCallRest _promote_)?
     189                                        | compoundIdentifier (funcCallRest _promote_ | idisaFuncCallRest _promote_)?
    194190                                        ;
    195191                                                                                                                                                                                       
     
    214210        type                    #->     identifier      |
    215211                                                        voidType        |
    216                                                         streamType      |
     212                                                        streamType      | // TODO - update in PabloS2PabloB
    217213                                                        structType      |
    218                                                         uint8Type       |
    219                                                         uint16Type      |
    220                                                         uint32Type      |
    221                                                         uint64Type      |
    222                                                         uint128Type |
    223                                                         uint256Type |
     214                                                        bitFieldType|
    224215                                                        bitBlockType; // | tupleType;
    225216       
     
    230221        streamTypeName  #->     identifier ;                           
    231222               
    232         uint8Type               -> UINT8 ;
    233         uint16Type              -> UINT16 ;
    234         uint32Type              -> UINT32 ;
    235         uint64Type              -> UINT64 ;
    236         uint128Type             -> UINT128 ;
    237         uint256Type             -> UINT256 ;
    238        
    239         bitBlockType    -> BITBLOCK;
     223        bitFieldType    -> BITFIELD ; // Power-of-2 bit field
     224       
     225        bitBlockType    -> BITBLOCK; // SIMD vector
    240226               
    241227        //     
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r2988 r3004  
    1010//
    1111//
     12types {}
     13
    1214context main {
    1315
  • proto/pabloj/trunk/input/test/pabloB/proto/parabix2_pablo.pablob

    r2988 r3004  
    131131        init
    132132        {
    133                 CarryDeclare(carry_set_0, 10, 0);       
     133               
    134134        }
    135135         
     
    483483        }
    484484       
     485        CarryDeclare(carry_set_0, 10, 0);
    485486};
    486487 
     
    489490        init
    490491        {
    491                 CarryDeclare(carry_set_0, 17, 2);
    492492                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2),2));
    493493        }
     
    826826        }
    827827       
     828        CarryDeclare(carry_set_0, 17, 2);
    828829};
    829830 
     
    832833        init
    833834        {
    834                 CarryDeclare(carry_set_0, 13, 0);       
     835               
    835836        }
    836837         
     
    10981099        }
    10991100       
     1101        CarryDeclare(carry_set_0, 13, 0);       
     1102       
    11001103};
    11011104 
     
    11041107        init
    11051108        {
    1106                 CarryDeclare(carry_set_0, 6, 0);       
     1109                       
    11071110        }
    11081111         
     
    11801183        }
    11811184       
     1185        CarryDeclare(carry_set_0, 6, 0);
    11821186};
    11831187 
     
    11861190        init
    11871191        {
    1188                 CarryDeclare(carry_set_0, 9, 0);       
     1192                       
    11891193        }
    11901194         
     
    12401244        }
    12411245       
     1246        CarryDeclare(carry_set_0, 9, 0);
    12421247};
    12431248 
     
    12461251        init
    12471252        {
    1248                 CarryDeclare(carry_set_0, 0, 0);       
     1253                       
    12491254        }
    12501255         
     
    12711276        }
    12721277       
    1273 };
     1278        CarryDeclare(carry_set_0, 0, 0);
     1279};
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r2990 r3004  
    5757// namespace pablo
    5858// {
    59 struct Basis_bits
     59struct KernelName
    6060{
    61         BitBlock bit_0;
    62         BitBlock bit_1;
    63         BitBlock bit_2;
    64         BitBlock bit_3;
    65         BitBlock bit_4;
    66         BitBlock bit_5;
    67         BitBlock bit_6;
    68         BitBlock bit_7;
    69 };
    70  
    71 struct U8
    72 {
    73         BitBlock unibyte;
    74         BitBlock prefix;
    75         BitBlock prefix2;
    76         BitBlock prefix3;
    77         BitBlock prefix4;
    78         BitBlock suffix;
    79         BitBlock badprefix;
    80         BitBlock xE0;
    81         BitBlock xED;
    82         BitBlock xF0;
    83         BitBlock xF4;
    84         BitBlock xA0_xBF;
    85         BitBlock x80_x9F;
    86         BitBlock x90_xBF;
    87         BitBlock x80_x8F;
    88         BitBlock xEF;
    89         BitBlock xBF;
    90         BitBlock xBE;
    91         BitBlock scope22;
    92         BitBlock scope32;
    93         BitBlock scope33;
    94         BitBlock scope42;
    95         BitBlock scope43;
    96         BitBlock scope44;
    97         BitBlock xE0_scope;
    98         BitBlock xED_scope;
    99         BitBlock xF0_scope;
    100         BitBlock xF4_scope;
    101         BitBlock xEF_scope;
    102 };
    103  
    104 struct Lex
    105 {
    106         BitBlock CR;
    107         BitBlock LF;
    108         BitBlock HT;
    109         BitBlock SP;
    110         BitBlock CRLF;
    111         BitBlock RefStart;
    112         BitBlock Semicolon;
    113         BitBlock Colon;
    114         BitBlock LAngle;
    115         BitBlock RAngle;
    116         BitBlock LBracket;
    117         BitBlock RBracket;
    118         BitBlock Exclam;
    119         BitBlock QMark;
    120         BitBlock Hyphen;
    121         BitBlock Equals;
    122         BitBlock SQuote;
    123         BitBlock DQuote;
    124         BitBlock Slash;
    125         BitBlock Hash;
    126         BitBlock x;
    127         BitBlock ASCII_name_start;
    128         BitBlock ASCII_name_char;
    129         BitBlock NameScan;
    130         BitBlock Digit;
    131         BitBlock Hex;
    132         BitBlock WS;
    133 };
    134  
    135 struct Marker
    136 {
    137         BitBlock LAngle_scope;
    138         BitBlock Ref_opener;
    139         BitBlock CD_closer;
    140 };
    141  
    142 struct CtCDPI_Callouts
    143 {
    144         BitBlock Ct_starts;
    145         BitBlock Ct_ends;
    146         BitBlock CD_starts;
    147         BitBlock CD_ends;
    148         BitBlock PI_starts;
    149         BitBlock PI_name_starts;
    150         BitBlock PI_name_ends;
    151         BitBlock PI_ends;
    152 };
    153  
    154 struct Ref_Callouts
    155 {
    156         BitBlock GenRef_starts;
    157         BitBlock GenRef_ends;
    158         BitBlock DecRef_starts;
    159         BitBlock DecRef_ends;
    160         BitBlock HexRef_starts;
    161         BitBlock HexRef_ends;
    162 };
    163  
    164 struct Tag_Callouts
    165 {
    166         BitBlock ElemName_starts;
    167         BitBlock ElemName_ends;
    168         BitBlock AttName_starts;
    169         BitBlock AttName_ends;
    170         BitBlock AttVal_starts;
    171         BitBlock AttVal_ends;
    172         BitBlock AttVal_spans;
    173         BitBlock EmptyTag_marks;
    174         BitBlock EndTag_marks;
    175 };
    176  
    177 struct Check_streams
    178 {
    179         BitBlock misc_mask;
    180         BitBlock non_ascii_name_starts;
    181         BitBlock non_ascii_names;
    182         BitBlock tag_marks;
    183         BitBlock name_follows;
    184         BitBlock att_refs;
    185 };
    186  
    187 struct Classify_bytes_Validate_utf8
    188 {
    189         Classify_bytes_Validate_utf8()
     61        KernelName()
    19062        {
    19163               
    19264        }
    19365         
    194         IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8)
     66        IDISA_INLINE void do_block()
    19567        {
    196                 BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
    197                 BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
    198                 BitBlock temp3 = simd_andc(temp2, temp1);
    199                 BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
    200                 BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
    201                 BitBlock temp6 = simd_and(temp4, temp5);
    202                 lex.RefStart = simd_and(temp3, temp6);
    203                 BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
    204                 BitBlock temp8 = simd_andc(temp7, temp1);
    205                 BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
    206                 BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
    207                 BitBlock temp11 = simd_and(temp9, temp10);
    208                 lex.Semicolon = simd_and(temp8, temp11);
    209                 BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
    210                 BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
    211                 BitBlock temp14 = simd_andc(temp12, temp13);
    212                 lex.LAngle = simd_and(temp8, temp14);
    213                 BitBlock temp15 = simd_and(temp12, temp5);
    214                 lex.RAngle = simd_and(temp8, temp15);
    215                 BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
    216                 BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
    217                 BitBlock temp18 = simd_and(temp16, temp17);
    218                 lex.LBracket = simd_and(temp18, temp11);
    219                 BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
    220                 BitBlock temp20 = simd_and(temp12, temp19);
    221                 lex.RBracket = simd_and(temp18, temp20);
    222                 BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
    223                 BitBlock temp22 = simd_andc(temp19, temp21);
    224                 lex.Exclam = simd_and(temp3, temp22);
    225                 BitBlock temp23 = simd_and(temp12, temp10);
    226                 lex.QMark = simd_and(temp8, temp23);
    227                 lex.Hyphen = simd_and(temp3, temp20);
    228                 lex.Equals = simd_and(temp8, temp20);
    229                 BitBlock temp24 = simd_and(temp4, temp10);
    230                 lex.SQuote = simd_and(temp3, temp24);
    231                 BitBlock temp25 = simd_andc(temp5, temp21);
    232                 lex.DQuote = simd_and(temp3, temp25);
    233                 lex.Slash = simd_and(temp3, temp23);
    234                 BitBlock temp26 = simd_andc(temp10, temp21);
    235                 lex.Hash = simd_and(temp3, temp26);
    236                 BitBlock temp27 = simd_and(temp16, temp7);
    237                 BitBlock temp28 = simd_andc(temp9, temp13);
    238                 lex.x = simd_and(temp27, temp28);
    239                 BitBlock temp29 = simd_and(temp9, temp5);
    240                 lex.Colon = simd_and(temp8, temp29);
    241                 BitBlock temp30 = simd_and(temp18, temp23);
    242                 BitBlock temp31 = simd_or(temp30, lex.Colon);
    243                 BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
    244                 BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
    245                 BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
    246                 BitBlock temp35 = simd_not(temp34);
    247                 BitBlock temp36 = simd_or(temp21, temp13);
    248                 BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
    249                 BitBlock temp38 = simd_and(temp32, temp37);
    250                 BitBlock temp39 = simd_or(temp31, temp38);
    251                 BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
    252                 BitBlock temp41 = simd_and(temp40, temp37);
    253                 lex.ASCII_name_start = simd_or(temp39, temp41);
    254                 BitBlock temp42 = simd_or(temp30, lex.Hyphen);
    255                 BitBlock temp43 = simd_and(temp3, temp15);
    256                 BitBlock temp44 = simd_or(temp42, temp43);
    257                 BitBlock temp45 = simd_andc(temp8, temp34);
    258                 BitBlock temp46 = simd_or(temp44, temp45);
    259                 BitBlock temp47 = simd_or(temp46, temp38);
    260                 lex.ASCII_name_char = simd_or(temp47, temp41);
    261                 lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
    262                 BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
    263                 BitBlock x00_x1F = simd_not(temp48);
    264                 BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
    265                 BitBlock temp50 = simd_or(temp1, temp49);
    266                 lex.CR = simd_andc(temp20, temp50);
    267                 lex.LF = simd_andc(temp29, temp50);
    268                 BitBlock temp51 = simd_and(temp9, temp19);
    269                 lex.HT = simd_andc(temp51, temp50);
    270                 lex.SP = simd_andc(temp3, temp36);
    271                 BitBlock temp52 = simd_or(temp20, temp29);
    272                 BitBlock temp53 = simd_or(temp52, temp51);
    273                 BitBlock temp54 = simd_andc(temp53, temp50);
    274                 lex.WS = simd_or(temp54, lex.SP);
    275                 BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
    276                 BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
    277                 lex.Digit = simd_andc(temp8, temp56);
    278                 BitBlock temp57 = simd_andc(temp16, temp49);
    279                 BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
    280                 BitBlock temp59 = simd_not(temp10);
    281                 BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
    282                 BitBlock temp61 = simd_and(temp58, temp60);
    283                 BitBlock temp62 = simd_or(lex.Digit, temp61);
    284                 BitBlock temp63 = simd_and(temp16, temp2);
    285                 BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
    286                 BitBlock temp65 = simd_and(temp64, temp60);
    287                 lex.Hex = simd_or(temp62, temp65);
    288                 BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
    289                 if (bitblock::any(lex_error))
    290                 {
    291                         assert_0_error("Error: illegal character", lex_error);
    292                 }
    293                 u8.unibyte = simd_not(basis_bits.bit_0);
    294                 u8.suffix = simd<1>::constant<0>();
    295                 BitBlock u8_error = simd<1>::constant<0>();
    296                 BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
    297                 BitBlock u8anyscope = simd<1>::constant<0>();
    298                 if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
    299                 {
    300                         u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
    301                         u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
    302                         u8.prefix3 = simd_and(u8.prefix, temp2);
    303                         u8.prefix4 = simd_and(u8.prefix, temp7);
    304                         u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
    305                         BitBlock temp66 = simd_andc(u8.prefix, temp49);
    306                         BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
    307                         BitBlock temp68 = simd_andc(temp66, temp67);
    308                         BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
    309                         BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
    310                         BitBlock temp71 = simd_and(u8.prefix4, temp70);
    311                         u8.badprefix = simd_or(temp68, temp71);
    312                         u8_error = u8.badprefix;
    313                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
    314                         u8anyscope = u8.scope22;
    315                         if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
    316                         {
    317                                 BitBlock xE0 = simd_andc(u8.prefix3, temp36);
    318                                 BitBlock xED = simd_and(u8.prefix3, temp20);
    319                                 BitBlock xF0 = simd_andc(u8.prefix4, temp36);
    320                                 BitBlock temp72 = simd_andc(temp4, temp13);
    321                                 BitBlock xF4 = simd_and(u8.prefix4, temp72);
    322                                 u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
    323                                 u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
    324                                 u8.x90_xBF = simd_and(u8.suffix, temp49);
    325                                 u8.x80_x8F = simd_andc(u8.suffix, temp49);
    326                                 BitBlock xEF = simd_and(u8.prefix3, temp23);
    327                                 BitBlock temp73 = simd_and(u8.suffix, temp7);
    328                                 u8.xBF = simd_and(temp73, temp23);
    329                                 u8.xBE = simd_and(temp73, temp15);
    330                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
    331                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
    332                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
    333                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
    334                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
    335                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
    336                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
    337                                 u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    338                                 u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    339                                 u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    340                                 u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    341                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
    342                                 BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    343                                 u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    344                                 BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
    345                                 BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
    346                                 BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
    347                                 BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    348                                 u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    349                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
    350                                 u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    351                         }
    352                         else
    353                         {
    354                                 carry_set_0.CarryDequeueEnqueue(1, 9);
    355                         }
    356                         BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
    357                         if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF)))
    358                         {
    359                                 assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
    360                         }
    361                 }
    362                 else
    363                 {
    364                         carry_set_0.CarryDequeueEnqueue(0, 10);
    365                 }
    366                 carry_set_0.CarryAdjust(10);
     68                BitBlock a;
     69                BitBlock b;
     70                BitBlock c;
     71                BitBlock k;
     72                BitBlock r;
     73                r = simd<1>::simd.add(a,b);
     74                r = simd<2>::simd.sub(a,b);
     75                r = simd<4>::simd.mul(a,b);
     76                r = simd<8>::simd.eq(a,b);
     77                r = simd<16>::simd.gt(a,b);
     78                r = simd<32>::simd.ugt(a,b);
     79                r = simd<64>::simd.lt(a,b);
     80                r = simd<128>::simd.ult(a,b);
     81                r = simd<256>::simd.max(a,b);
     82                r = simd<1>::simd.umax(a,b);
     83                r = simd<2>::simd.min(a,b);
     84                r = simd<4>::simd.umin(a,b);
     85                r = simd<8>::simd.sll(a,b);
     86                r = simd<16>::simd.srl(a,b);
     87                r = simd<32>::simd.sra(a,b);
    36788        }
    36889       
    369         void do_final_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8, BitBlock & EOF_mask)
    370         {
    371                 BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
    372                 BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
    373                 BitBlock temp3 = simd_andc(temp2, temp1);
    374                 BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
    375                 BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
    376                 BitBlock temp6 = simd_and(temp4, temp5);
    377                 lex.RefStart = simd_and(temp3, temp6);
    378                 BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
    379                 BitBlock temp8 = simd_andc(temp7, temp1);
    380                 BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
    381                 BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
    382                 BitBlock temp11 = simd_and(temp9, temp10);
    383                 lex.Semicolon = simd_and(temp8, temp11);
    384                 BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
    385                 BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
    386                 BitBlock temp14 = simd_andc(temp12, temp13);
    387                 lex.LAngle = simd_and(temp8, temp14);
    388                 BitBlock temp15 = simd_and(temp12, temp5);
    389                 lex.RAngle = simd_and(temp8, temp15);
    390                 BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
    391                 BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
    392                 BitBlock temp18 = simd_and(temp16, temp17);
    393                 lex.LBracket = simd_and(temp18, temp11);
    394                 BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
    395                 BitBlock temp20 = simd_and(temp12, temp19);
    396                 lex.RBracket = simd_and(temp18, temp20);
    397                 BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
    398                 BitBlock temp22 = simd_andc(temp19, temp21);
    399                 lex.Exclam = simd_and(temp3, temp22);
    400                 BitBlock temp23 = simd_and(temp12, temp10);
    401                 lex.QMark = simd_and(temp8, temp23);
    402                 lex.Hyphen = simd_and(temp3, temp20);
    403                 lex.Equals = simd_and(temp8, temp20);
    404                 BitBlock temp24 = simd_and(temp4, temp10);
    405                 lex.SQuote = simd_and(temp3, temp24);
    406                 BitBlock temp25 = simd_andc(temp5, temp21);
    407                 lex.DQuote = simd_and(temp3, temp25);
    408                 lex.Slash = simd_and(temp3, temp23);
    409                 BitBlock temp26 = simd_andc(temp10, temp21);
    410                 lex.Hash = simd_and(temp3, temp26);
    411                 BitBlock temp27 = simd_and(temp16, temp7);
    412                 BitBlock temp28 = simd_andc(temp9, temp13);
    413                 lex.x = simd_and(temp27, temp28);
    414                 BitBlock temp29 = simd_and(temp9, temp5);
    415                 lex.Colon = simd_and(temp8, temp29);
    416                 BitBlock temp30 = simd_and(temp18, temp23);
    417                 BitBlock temp31 = simd_or(temp30, lex.Colon);
    418                 BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
    419                 BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
    420                 BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
    421                 BitBlock temp35 = simd_not(temp34);
    422                 BitBlock temp36 = simd_or(temp21, temp13);
    423                 BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
    424                 BitBlock temp38 = simd_and(temp32, temp37);
    425                 BitBlock temp39 = simd_or(temp31, temp38);
    426                 BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
    427                 BitBlock temp41 = simd_and(temp40, temp37);
    428                 lex.ASCII_name_start = simd_or(temp39, temp41);
    429                 BitBlock temp42 = simd_or(temp30, lex.Hyphen);
    430                 BitBlock temp43 = simd_and(temp3, temp15);
    431                 BitBlock temp44 = simd_or(temp42, temp43);
    432                 BitBlock temp45 = simd_andc(temp8, temp34);
    433                 BitBlock temp46 = simd_or(temp44, temp45);
    434                 BitBlock temp47 = simd_or(temp46, temp38);
    435                 lex.ASCII_name_char = simd_or(temp47, temp41);
    436                 lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
    437                 BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
    438                 BitBlock x00_x1F = simd_not(temp48);
    439                 BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
    440                 BitBlock temp50 = simd_or(temp1, temp49);
    441                 lex.CR = simd_andc(temp20, temp50);
    442                 lex.LF = simd_andc(temp29, temp50);
    443                 BitBlock temp51 = simd_and(temp9, temp19);
    444                 lex.HT = simd_andc(temp51, temp50);
    445                 lex.SP = simd_andc(temp3, temp36);
    446                 BitBlock temp52 = simd_or(temp20, temp29);
    447                 BitBlock temp53 = simd_or(temp52, temp51);
    448                 BitBlock temp54 = simd_andc(temp53, temp50);
    449                 lex.WS = simd_or(temp54, lex.SP);
    450                 BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
    451                 BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
    452                 lex.Digit = simd_andc(temp8, temp56);
    453                 BitBlock temp57 = simd_andc(temp16, temp49);
    454                 BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
    455                 BitBlock temp59 = simd_not(temp10);
    456                 BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
    457                 BitBlock temp61 = simd_and(temp58, temp60);
    458                 BitBlock temp62 = simd_or(lex.Digit, temp61);
    459                 BitBlock temp63 = simd_and(temp16, temp2);
    460                 BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
    461                 BitBlock temp65 = simd_and(temp64, temp60);
    462                 lex.Hex = simd_or(temp62, temp65);
    463                 BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
    464                 if (bitblock::any(simd_and(lex_error, EOF_mask)))
    465                 {
    466                         assert_0_error("Error: illegal character", simd_and(lex_error, EOF_mask));
    467                 }
    468                 u8.unibyte = simd_not(basis_bits.bit_0);
    469                 u8.suffix = simd<1>::constant<0>();
    470                 BitBlock u8_error = simd<1>::constant<0>();
    471                 BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
    472                 BitBlock u8anyscope = simd<1>::constant<0>();
    473                 if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
    474                 {
    475                         u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
    476                         u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
    477                         u8.prefix3 = simd_and(u8.prefix, temp2);
    478                         u8.prefix4 = simd_and(u8.prefix, temp7);
    479                         u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
    480                         BitBlock temp66 = simd_andc(u8.prefix, temp49);
    481                         BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
    482                         BitBlock temp68 = simd_andc(temp66, temp67);
    483                         BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
    484                         BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
    485                         BitBlock temp71 = simd_and(u8.prefix4, temp70);
    486                         u8.badprefix = simd_or(temp68, temp71);
    487                         u8_error = u8.badprefix;
    488                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
    489                         u8anyscope = u8.scope22;
    490                         if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
    491                         {
    492                                 BitBlock xE0 = simd_andc(u8.prefix3, temp36);
    493                                 BitBlock xED = simd_and(u8.prefix3, temp20);
    494                                 BitBlock xF0 = simd_andc(u8.prefix4, temp36);
    495                                 BitBlock temp72 = simd_andc(temp4, temp13);
    496                                 BitBlock xF4 = simd_and(u8.prefix4, temp72);
    497                                 u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
    498                                 u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
    499                                 u8.x90_xBF = simd_and(u8.suffix, temp49);
    500                                 u8.x80_x8F = simd_andc(u8.suffix, temp49);
    501                                 BitBlock xEF = simd_and(u8.prefix3, temp23);
    502                                 BitBlock temp73 = simd_and(u8.suffix, temp7);
    503                                 u8.xBF = simd_and(temp73, temp23);
    504                                 u8.xBE = simd_and(temp73, temp15);
    505                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
    506                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
    507                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
    508                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
    509                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
    510                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
    511                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
    512                                 u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    513                                 u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    514                                 u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    515                                 u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    516                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
    517                                 BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    518                                 u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    519                                 BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
    520                                 BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
    521                                 BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
    522                                 BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    523                                 u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    524                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
    525                                 u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    526                         }
    527                         else
    528                         {
    529                                 carry_set_0.CarryDequeueEnqueue(1, 9);
    530                         }
    531                         BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
    532                         if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF)))
    533                         {
    534                                 assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
    535                         }
    536                 }
    537                 else
    538                 {
    539                         carry_set_0.CarryDequeueEnqueue(0, 10);
    540                 }
    541         }
    542        
    543         CarryDeclare(carry_set_0, 10, 0);
    544 };
    545  
    546 struct Parse_CtCDPI
    547 {
    548         Parse_CtCDPI()
    549         {
    550                 carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)), 2);
    551         }
    552          
    553         IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams)
    554         {
    555                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    556                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    557                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    558                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    559                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    560                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    561                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    562                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    563                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
    564                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
    565                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
    566                 BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
    567                 BitBlock w = simd_or(lex.Hyphen, lex.QMark);
    568                 BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
    569                 BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    570                 BitBlock LAngle_scope = simd_andc(v1, w1);
    571                 BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
    572                 BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
    573                 BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
    574                 BitBlock CD_closer = simd<1>::constant<0>();
    575                 BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    576                 if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    577                 {
    578                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
    579                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    580                 }
    581                 else
    582                 {
    583                         carry_set_0.CarryDequeueEnqueue(0, 2);
    584                 }
    585                 BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    586                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    587                 if (bitblock::any(simd_or(CtCDPI_Cursor, carry_set_0.CarryRange(3, 13))))
    588                 {
    589                         CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    590                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    591                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    592                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    593                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    594                         if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    595                         {
    596                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    597                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    598                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    599                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    600                                 BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    601                                 BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    602                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    603                                 if (bitblock::any(PI_error))
    604                                 {
    605                                         assert_0_error("Error in PI syntax", PI_error);
    606                                 }
    607                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    608                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carry_set_0.GetCarry(7), 7);
    609                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    610                                 CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    611                         }
    612                         else
    613                         {
    614                                 carry_set_0.CarryDequeueEnqueue(4, 4);
    615                         }
    616                         if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    617                         {
    618                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    619                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carry_set_0.GetCarry(8), 8);
    620                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    621                                 CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    622                         }
    623                         else
    624                         {
    625                                 carry_set_0.CarryDequeueEnqueue(8, 1);
    626                         }
    627                         if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    628                         {
    629                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    630                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    631                                 BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    632                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
    633                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    634                                 if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    635                                 {
    636                                         assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    637                                 }
    638                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    639                                 CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    640                         }
    641                         else
    642                         {
    643                                 carry_set_0.CarryDequeueEnqueue(9, 5);
    644                         }
    645                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    646                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    647                         if (bitblock::any(simd<1>::constant<0>()))
    648                         {
    649                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    650                         }
    651                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    652                         while (bitblock::any(CtCDPI_Cursor))
    653                         {
    654                                 CarryDeclare(carry_set_1, 13, 0);
    655                                 CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    656                                 BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    657                                 BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    658                                 BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    659                                 BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    660                                 if (bitblock::any(PI_Cursor))
    661                                 {
    662                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    663                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    664                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    665                                         BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    666                                         BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    667                                         BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    668                                         PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    669                                         if (bitblock::any(PI_error))
    670                                         {
    671                                                 assert_0_error("Error in PI syntax", PI_error);
    672                                         }
    673                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    674                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 4);
    675                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    676                                         CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    677                                 }
    678                                 if (bitblock::any(CD_Cursor))
    679                                 {
    680                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    681                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 5);
    682                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    683                                         CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    684                                 }
    685                                 if (bitblock::any(Ct_Cursor))
    686                                 {
    687                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    688                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    689                                         BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    690                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
    691                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    692                                         if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    693                                         {
    694                                                 assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    695                                         }
    696                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    697                                         CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    698                                 }
    699                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    700                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    701                                 if (bitblock::any(simd<1>::constant<0>()))
    702                                 {
    703                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    704                                 }
    705                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 12);
    706                                 LocalCarryCombine(carry_set_0, carry_set_1, 3, 13);
    707                         }
    708                 }
    709                 else
    710                 {
    711                         carry_set_0.CarryDequeueEnqueue(3, 13);
    712                 }
    713                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    714                 marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    715                 marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
    716                 marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
    717                 carry_set_0.CarryAdjust(17);
    718         }
    719        
    720         void do_final_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
    721         {
    722                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    723                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    724                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    725                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    726                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    727                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    728                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    729                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    730                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
    731                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
    732                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
    733                 BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
    734                 BitBlock w = simd_or(lex.Hyphen, lex.QMark);
    735                 BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
    736                 BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    737                 BitBlock LAngle_scope = simd_andc(v1, w1);
    738                 BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
    739                 BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
    740                 BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
    741                 BitBlock CD_closer = simd<1>::constant<0>();
    742                 BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    743                 if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    744                 {
    745                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
    746                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    747                 }
    748                 else
    749                 {
    750                         carry_set_0.CarryDequeueEnqueue(0, 2);
    751                 }
    752                 BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    753                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    754                 if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor, EOF_mask), carry_set_0.CarryRange(3, 13))))
    755                 {
    756                         CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    757                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    758                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    759                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    760                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    761                         if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    762                         {
    763                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    764                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    765                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    766                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    767                                 BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    768                                 BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    769                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    770                                 if (bitblock::any(PI_error))
    771                                 {
    772                                         assert_0_error("Error in PI syntax", PI_error);
    773                                 }
    774                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    775                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_set_0.GetCarry(7), 7);
    776                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    777                                 CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    778                         }
    779                         else
    780                         {
    781                                 carry_set_0.CarryDequeueEnqueue(4, 4);
    782                         }
    783                         if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    784                         {
    785                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    786                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_set_0.GetCarry(8), 8);
    787                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    788                                 CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    789                         }
    790                         else
    791                         {
    792                                 carry_set_0.CarryDequeueEnqueue(8, 1);
    793                         }
    794                         if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    795                         {
    796                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    797                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    798                                 BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    799                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
    800                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    801                                 if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    802                                 {
    803                                         assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    804                                 }
    805                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    806                                 CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    807                         }
    808                         else
    809                         {
    810                                 carry_set_0.CarryDequeueEnqueue(9, 5);
    811                         }
    812                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    813                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    814                         if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    815                         {
    816                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    817                         }
    818                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    819                         while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)))
    820                         {
    821                                 CarryDeclare(carry_set_1, 13, 0);
    822                                 CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    823                                 BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    824                                 BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    825                                 BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    826                                 BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    827                                 if (bitblock::any(PI_Cursor))
    828                                 {
    829                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    830                                         PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    831                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    832                                         BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    833                                         BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    834                                         BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    835                                         PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    836                                         if (bitblock::any(PI_error))
    837                                         {
    838                                                 assert_0_error("Error in PI syntax", PI_error);
    839                                         }
    840                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    841                                         PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 4);
    842                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    843                                         CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
    844                                 }
    845                                 if (bitblock::any(CD_Cursor))
    846                                 {
    847                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    848                                         CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 5);
    849                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    850                                         CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
    851                                 }
    852                                 if (bitblock::any(Ct_Cursor))
    853                                 {
    854                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    855                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    856                                         BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    857                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
    858                                         Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    859                                         if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    860                                         {
    861                                                 assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
    862                                         }
    863                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
    864                                         CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    865                                 }
    866                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    867                                 ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    868                                 if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    869                                 {
    870                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    871                                 }
    872                                 CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 12);
    873                                 LocalCarryCombine(carry_set_0, carry_set_1, 3, 13);
    874                         }
    875                 }
    876                 else
    877                 {
    878                         carry_set_0.CarryDequeueEnqueue(3, 13);
    879                 }
    880                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    881                 marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    882                 marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
    883                 marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
    884         }
    885        
    886         CarryDeclare(carry_set_0, 17, 2);
    887 };
    888  
    889 struct Parse_tags
    890 {
    891         Parse_tags()
     90        void do_final_block()
    89291        {
    89392               
    894         }
    895          
    896         IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts)
    897         {
    898                 BitBlock EqExpected = simd<1>::constant<0>();
    899                 BitBlock AttListEnd = simd<1>::constant<0>();
    900                 BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
    901                 BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
    902                 BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
    903                 tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    904                 tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    905                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    906                 BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    907                 tag_Callouts.AttName_starts = simd<1>::constant<0>();
    908                 tag_Callouts.AttName_ends = simd<1>::constant<0>();
    909                 tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    910                 tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    911                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    912                 {
    913                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    914                         AttListEnd = simd_and(AfterWS, AttListDelim);
    915                         BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
    916                         if (bitblock::any(simd_or(AttNameStart, carry_set_0.CarryRange(2, 7))))
    917                         {
    918                                 ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    919                                 tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    920                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    921                                 tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    922                                 if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    923                                 {
    924                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    925                                 }
    926                                 else
    927                                 {
    928                                         EqExpected = AttNameFollow;
    929                                         carry_set_0.CarryDequeueEnqueue(3, 1);
    930                                 }
    931                                 ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    932                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    933                                 tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    934                                 BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    935                                 BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    936                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carry_set_0.GetCarry(5), 5);
    937                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carry_set_0.GetCarry(6), 6);
    938                                 BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    939                                 ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    940                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    941                                 tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    942                                 if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    943                                 {
    944                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    945                                         AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    946                                         AttNameStart = simd_andc(AfterWS, AttListDelim);
    947                                 }
    948                                 else
    949                                 {
    950                                         AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    951                                         AttNameStart = simd_andc(AttValFollow, AttListDelim);
    952                                         carry_set_0.CarryDequeueEnqueue(8, 1);
    953                                 }
    954                                 ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    955                                 while (bitblock::any(AttNameStart))
    956                                 {
    957                                         CarryDeclare(carry_set_1, 7, 0);
    958                                         ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    959                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    960                                         BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    961                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    962                                         if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    963                                         {
    964                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    965                                         }
    966                                         else
    967                                         {
    968                                                 EqExpected = AttNameFollow;
    969                                         }
    970                                         ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    971                                         BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    972                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    973                                         BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    974                                         BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    975                                         BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), 3);
    976                                         BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), 4);
    977                                         BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    978                                         ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    979                                         BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    980                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    981                                         if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    982                                         {
    983                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    984                                                 AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    985                                                 AttNameStart = simd_andc(AfterWS, AttListDelim);
    986                                         }
    987                                         else
    988                                         {
    989                                                 AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    990                                                 AttNameStart = simd_andc(AttValFollow, AttListDelim);
    991                                         }
    992                                         ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    993                                         LocalCarryCombine(carry_set_0, carry_set_1, 2, 7);
    994                                 }
    995                         }
    996                         else
    997                         {
    998                                 carry_set_0.CarryDequeueEnqueue(2, 7);
    999                         }
    1000                 }
    1001                 else
    1002                 {
    1003                         AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
    1004                         ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
    1005                         carry_set_0.CarryDequeueEnqueue(1, 8);
    1006                 }
    1007                 BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1008                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    1009                 ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1010                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    1011                 if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    1012                 {
    1013                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    1014                 }
    1015                 else
    1016                 {
    1017                         carry_set_0.CarryDequeueEnqueue(11, 1);
    1018                 }
    1019                 ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
    1020                 if (bitblock::any(ParseError))
    1021                 {
    1022                         assert_0_error("Tag parsing error found", ParseError);
    1023                 }
    1024                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    1025                 carry_set_0.CarryAdjust(13);
    1026         }
    1027        
    1028         void do_final_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts, BitBlock & EOF_mask)
    1029         {
    1030                 BitBlock EqExpected = simd<1>::constant<0>();
    1031                 BitBlock AttListEnd = simd<1>::constant<0>();
    1032                 BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
    1033                 BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
    1034                 BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
    1035                 tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    1036                 tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    1037                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    1038                 BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    1039                 tag_Callouts.AttName_starts = simd<1>::constant<0>();
    1040                 tag_Callouts.AttName_ends = simd<1>::constant<0>();
    1041                 tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    1042                 tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1043                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    1044                 {
    1045                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    1046                         AttListEnd = simd_and(AfterWS, AttListDelim);
    1047                         BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
    1048                         if (bitblock::any(simd_or(simd_and(AttNameStart, EOF_mask), carry_set_0.CarryRange(2, 7))))
    1049                         {
    1050                                 ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1051                                 tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1052                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    1053                                 tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1054                                 if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    1055                                 {
    1056                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    1057                                 }
    1058                                 else
    1059                                 {
    1060                                         EqExpected = AttNameFollow;
    1061                                         carry_set_0.CarryDequeueEnqueue(3, 1);
    1062                                 }
    1063                                 ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1064                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    1065                                 tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1066                                 BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1067                                 BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1068                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_set_0.GetCarry(5), 5);
    1069                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_set_0.GetCarry(6), 6);
    1070                                 BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1071                                 ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1072                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    1073                                 tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1074                                 if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    1075                                 {
    1076                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    1077                                         AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1078                                         AttNameStart = simd_andc(AfterWS, AttListDelim);
    1079                                 }
    1080                                 else
    1081                                 {
    1082                                         AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    1083                                         AttNameStart = simd_andc(AttValFollow, AttListDelim);
    1084                                         carry_set_0.CarryDequeueEnqueue(8, 1);
    1085                                 }
    1086                                 ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    1087                                 while (bitblock::any(simd_and(AttNameStart, EOF_mask)))
    1088                                 {
    1089                                         CarryDeclare(carry_set_1, 7, 0);
    1090                                         ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    1091                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1092                                         BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    1093                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1094                                         if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    1095                                         {
    1096                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    1097                                         }
    1098                                         else
    1099                                         {
    1100                                                 EqExpected = AttNameFollow;
    1101                                         }
    1102                                         ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1103                                         BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    1104                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    1105                                         BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    1106                                         BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1107                                         BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), 3);
    1108                                         BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), 4);
    1109                                         BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    1110                                         ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1111                                         BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    1112                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1113                                         if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    1114                                         {
    1115                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    1116                                                 AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    1117                                                 AttNameStart = simd_andc(AfterWS, AttListDelim);
    1118                                         }
    1119                                         else
    1120                                         {
    1121                                                 AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    1122                                                 AttNameStart = simd_andc(AttValFollow, AttListDelim);
    1123                                         }
    1124                                         ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    1125                                         LocalCarryCombine(carry_set_0, carry_set_1, 2, 7);
    1126                                 }
    1127                         }
    1128                         else
    1129                         {
    1130                                 carry_set_0.CarryDequeueEnqueue(2, 7);
    1131                         }
    1132                 }
    1133                 else
    1134                 {
    1135                         AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
    1136                         ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
    1137                         carry_set_0.CarryDequeueEnqueue(1, 8);
    1138                 }
    1139                 BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1140                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    1141                 ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1142                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    1143                 if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    1144                 {
    1145                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    1146                 }
    1147                 else
    1148                 {
    1149                         carry_set_0.CarryDequeueEnqueue(11, 1);
    1150                 }
    1151                 ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
    1152                 if (bitblock::any(ParseError))
    1153                 {
    1154                         assert_0_error("Tag parsing error found", ParseError);
    1155                 }
    1156                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    1157         }
    1158        
    1159         CarryDeclare(carry_set_0, 13, 0);
    1160 };
    1161  
    1162 struct Parse_refs
    1163 {
    1164         Parse_refs()
    1165         {
    1166                
    1167         }
    1168          
    1169         IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts)
    1170         {
    1171                 ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    1172                 ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    1173                 ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    1174                 ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    1175                 ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    1176                 ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    1177                 BitBlock ref_error = simd<1>::constant<0>();
    1178                 if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    1179                 {
    1180                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
    1181                         BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    1182                         ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1183                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
    1184                         BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    1185                         ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1186                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
    1187                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
    1188                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
    1189                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
    1190                         BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    1191                         BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
    1192                         BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    1193                         BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
    1194                         if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3)))
    1195                         {
    1196                                 assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
    1197                         }
    1198                 }
    1199                 else
    1200                 {
    1201                         carry_set_0.CarryDequeueEnqueue(0, 6);
    1202                 }
    1203                 carry_set_0.CarryAdjust(6);
    1204         }
    1205        
    1206         void do_final_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts, BitBlock & EOF_mask)
    1207         {
    1208                 ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    1209                 ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    1210                 ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    1211                 ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    1212                 ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    1213                 ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    1214                 BitBlock ref_error = simd<1>::constant<0>();
    1215                 if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    1216                 {
    1217                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
    1218                         BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    1219                         ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1220                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
    1221                         BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    1222                         ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1223                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
    1224                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
    1225                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
    1226                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
    1227                         BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    1228                         BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
    1229                         BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    1230                         BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
    1231                         if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3)))
    1232                         {
    1233                                 assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
    1234                         }
    1235                 }
    1236                 else
    1237                 {
    1238                         carry_set_0.CarryDequeueEnqueue(0, 6);
    1239                 }
    1240         }
    1241        
    1242         CarryDeclare(carry_set_0, 6, 0);
    1243 };
    1244  
    1245 struct Validate_xml_names
    1246 {
    1247         Validate_xml_names()
    1248         {
    1249                
    1250         }
    1251          
    1252         IDISA_INLINE void do_block(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)
    1253         {
    1254                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
    1255                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
    1256                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
    1257                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
    1258                 BitBlock qname_stream = simd_or(ElemNames, AttNames);
    1259                 BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    1260                 BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1261                 BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
    1262                 BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
    1263                 BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1264                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
    1265                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
    1266                 BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1267                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
    1268                 BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    1269                 if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
    1270                 {
    1271                         assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
    1272                 }
    1273                 check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
    1274                 check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    1275                 carry_set_0.CarryAdjust(9);
    1276         }
    1277        
    1278         void do_final_block(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, BitBlock & EOF_mask)
    1279         {
    1280                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
    1281                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
    1282                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
    1283                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
    1284                 BitBlock qname_stream = simd_or(ElemNames, AttNames);
    1285                 BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    1286                 BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1287                 BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
    1288                 BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
    1289                 BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1290                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
    1291                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
    1292                 BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1293                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
    1294                 BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    1295                 if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
    1296                 {
    1297                         assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
    1298                 }
    1299                 check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
    1300                 check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    1301         }
    1302        
    1303         CarryDeclare(carry_set_0, 9, 0);
    1304 };
    1305  
    1306 struct Do_check_streams
    1307 {
    1308         Do_check_streams()
    1309         {
    1310                
    1311         }
    1312          
    1313         IDISA_INLINE void do_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams)
    1314         {
    1315                 if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans)))
    1316                 {
    1317                         assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
    1318                 }
    1319                 check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
    1320                 check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
    1321                 check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
    1322         }
    1323        
    1324         void do_final_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
    1325         {
    1326                 if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans)))
    1327                 {
    1328                         assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
    1329                 }
    1330                 check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
    1331                 check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
    1332                 check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
    133393        }
    133494       
  • proto/pabloj/trunk/runConfigurations/compilePabloS.launch

    r2988 r3004  
    33<stringAttribute key="bad_container_name" value="/proto/pabloj/runConfigurations"/>
    44<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
    5 <listEntry value="/pabloj/src/applicationGenerator/PabloJ.java"/>
     5<listEntry value="/pabloj/src/application/PabloJ.java"/>
    66</listAttribute>
    77<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
    88<listEntry value="1"/>
    99</listAttribute>
    10 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="applicationGenerator.PabloJ"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${project_loc}/input/test/pabloS/proto/parabix2_pablo.pablos"/>
     10<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="application.PabloJ"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-s ${project_loc}/input/test/pabloS/proto/parabix2_pablo.pablos"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pabloj/trunk/src/application/config/Configuration.java

    r2998 r3004  
    2424        // Options
    2525        public String pabloSFile;
    26         public Boolean isPabloSSource;
     26        public boolean isPabloSSource;
    2727       
    2828        public String pabloBFile;
    29         public Boolean isPabloBSource;
     29        public boolean isPabloBSource;
    3030       
    3131        public String templateDirectory;
  • proto/pabloj/trunk/src/application/generators/AbstractTemplateContentsGenerator.java

    r2998 r3004  
    77package application.generators;
    88
    9 import compilers.pabloB.codeGenerator.visitors.Unparser;
     9import compilers.pabloB.codeGenerator.visitors.AbstractUnparser;
    1010
    11 abstract public class TemplateContentsGenerator {
     11abstract public class AbstractTemplateContentsGenerator {
    1212   
    1313        protected pabloB.ast.ProgramNode programNode;
    14         protected Unparser unparser;
     14        protected AbstractUnparser unparser;
    1515    protected String outputDirectory;
    1616        protected String templateFilePath;
    1717        protected String targetFilePath;
    1818               
    19         public TemplateContentsGenerator(pabloB.ast.ProgramNode programNode,
    20                                                                                 Unparser unparser,
     19        public AbstractTemplateContentsGenerator(pabloB.ast.ProgramNode programNode,
     20                                                                                AbstractUnparser unparser,
    2121                                                                                String outputDirectory,
    2222                                                                                String templateFilePath,
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r2998 r3004  
    2525import application.helpers.FileUtil;
    2626
    27 import compilers.pabloB.codeGenerator.visitors.CPPUnparser;
     27import compilers.pabloB.codeGenerator.idisa.IDISABuiltin2CPP;
    2828import compilers.pabloB.codeGenerator.visitors.Unparser;
     29import compilers.pabloB.codeGenerator.visitors.AbstractUnparser;
    2930import compilers.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
    30 import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
     31import compilers.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
    3132import compilers.pabloB.symbols.SymbolTable;
    3233import compilers.pabloS.lang.*;
     
    5152        public void generate() throws ASTGeneratorException {
    5253
    53                 SymbolTable symbolTable                         = new SymbolTable();   
     54                SymbolTable symbolTable                                 = new SymbolTable();   
    5455               
    5556                // Transformation configurations to support multiple backends
    56                 PabloSBuiltins2Lang builtins2Lang               = null;
    57                 CarrySetBuiltins2Lang carrySet2Lang     = null;
    58                 Unparser unparser                                               = null;
     57                AbstractPabloSBuiltins2Lang builtins2Lang               = null;
     58                AbstractCarrySetBuiltins2Lang carrySet2Lang     = null;
     59                AbstractUnparser unparser                                               = null;
    5960               
    6061                if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
    6162                        //builtins2Lang = new Builtins2C();
    6263                        //carrySet2Lang = new CarrySet2C();
    63                         //unparser = new CUnparser();
    64                 } else { // default C++
     64                        //unparser        = new Unparser(new IDISABuiltins2C());
     65                } else if(applicationConfiguration.targetLang.contentEquals(Configuration.CPPLANG)) {
    6566                        builtins2Lang = new PabloSBuiltins2CPP();
    6667                        carrySet2Lang = new CarrySetBuiltins2CPP();
    67                         unparser          = new CPPUnparser(symbolTable);
    68                 }               
     68                        unparser          = new Unparser(new IDISABuiltin2CPP());
     69                } /*else if(applicationConfiguration.targetLang.contentEquals(Configuration.LLVM)) {  // default C++
     70                        builtins2Lang = new PabloSBuiltins2CPP();
     71                        carrySet2Lang = new CarrySetBuiltins2CPP();
     72                        unparser          = new Unparser(new IDISABuiltins2LLVM());
     73                } */
    6974
    7075                // Parse
  • proto/pabloj/trunk/src/application/generators/HeaderTemplateContentsGenerator.java

    r2998 r3004  
    1515import application.templating.Template;
    1616import compilers.pabloB.ast.Accessors;
    17 import compilers.pabloB.codeGenerator.visitors.Unparser;
     17import compilers.pabloB.codeGenerator.visitors.AbstractUnparser;
    1818
    1919import java.io.File;
     
    2222import java.util.List;
    2323
    24 public class HeaderTemplateContentsGenerator extends TemplateContentsGenerator {
     24public class HeaderTemplateContentsGenerator extends AbstractTemplateContentsGenerator {
    2525   
    2626        public HeaderTemplateContentsGenerator( ProgramNode programNode,
    27                                                                                         Unparser unparser,
     27                                                                                        AbstractUnparser unparser,
    2828                                                                                        String outputDirectory,
    2929                                                                                        String templateFilePath,
  • proto/pabloj/trunk/src/compilers/pabloB/ast/Accessors.java

    r2984 r3004  
    252252
    253253        ////////////////////////////////////////////////////////////////////////////
    254         // Stream Type
     254        // Field Width
    255255        ////////////////////////////////////////////////////////////////////////////
    256256        public static String fieldWidthLexeme(FieldWidthNode node) {           
     
    259259
    260260        ////////////////////////////////////////////////////////////////////////////
     261        // BitField Type
     262        ////////////////////////////////////////////////////////////////////////////   
     263        public static String bitFieldLexeme(BitFieldTypeNode node) {           
     264                return node.getToken().getLexeme();
     265        }       
     266
     267        ////////////////////////////////////////////////////////////////////////////
     268        // BitBlock Type
     269        ////////////////////////////////////////////////////////////////////////////   
     270        public static String bitBlockLexeme(BitBlockTypeNode node) {           
     271                return node.getToken().getLexeme();
     272        }       
     273
     274        ////////////////////////////////////////////////////////////////////////////
     275        // Stream Type
     276        ////////////////////////////////////////////////////////////////////////////   
     277        public static String streamLexeme(StreamTypeNode node) {               
     278                return "BitBlock"; // TODO - remove
     279        }       
     280       
     281        ////////////////////////////////////////////////////////////////////////////
    261282        // Void Type
    262283        ////////////////////////////////////////////////////////////////////////////   
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/helpers/CodeStore.java

    r2952 r3004  
    9797                }
    9898        }
     99
     100        public void addAll(List<CodeStore> others, int relativeIndent) {
     101                for(CodeStore other : others) {
     102                        addAll(other,0);
     103                }
     104        }       
    99105       
    100106        public String toStringIndented(int startingIndent) {
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/helpers/UnparserUtil.java

    r2952 r3004  
    3737        }       
    3838       
     39        public static <T> String makeDelimitedList(List<T> list, String delimeter) {
     40                StringBuilder result = new StringBuilder();
     41                Iterator<T> iter = list.iterator();
     42                while (iter.hasNext()) {
     43                        result.append(iter.next());
     44                        if (iter.hasNext()) {
     45                                result.append(delimeter);
     46                        }
     47                }
     48                return result.toString();
     49        }       
     50       
    3951}
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/visitors/AbstractUnparser.java

    r2983 r3004  
    4747import pabloB.ast.ASTVisitor.Default;
    4848import compilers.pabloB.codeGenerator.helpers.CodeStore;
    49 import compilers.pabloB.symbols.SymbolTable;
     49import compilers.pabloB.codeGenerator.idisa.AbstractIDISABuiltin2Lang;
    5050
    51 abstract public class Unparser extends Default<CodeStore> {
     51abstract public class AbstractUnparser extends Default<CodeStore> {
    5252       
    5353        abstract public String getCode(ASTNode node);           
    5454        abstract public String getCode(ASTNode node, int indent);       
    5555       
    56         protected SymbolTable symbolTable; // TODO - refactor / remove
    57        
    58         protected SymbolTable getSymbolTable() { // TODO - refactor / remove
    59                 return symbolTable;
    60         }
    61        
    62         protected void setSymbolTable(SymbolTable symbolTable) { // TODO - refactor / remove
    63                 this.symbolTable = symbolTable;
    64         }
    65 
     56        protected AbstractIDISABuiltin2Lang idisaBuiltins2Lang;
    6657}
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/visitors/Unparser.java

    r2984 r3004  
    3838import pabloB.ast.*;
    3939
     40import java.util.ArrayList;
    4041import java.util.Iterator;
    4142import java.util.List;
     
    4445import compilers.pabloB.codeGenerator.helpers.CodeStore;
    4546import compilers.pabloB.codeGenerator.helpers.UnparserUtil;
    46 import compilers.pabloB.symbols.SymbolTable;
    47 
    48 public class CPPUnparser extends Unparser {
     47import compilers.pabloB.codeGenerator.idisa.AbstractIDISABuiltin2Lang;
     48import compilers.pabloB.codeGenerator.idisa.SIMDBuiltinGenerator;
     49import compilers.pabloB.lang.idisa.IDISABuiltin;
     50import compilers.pabloB.lang.types.PrimitiveType;
     51
     52import static compilers.pabloB.lang.types.PrimitiveType.BITBLOCK;
     53import static compilers.pabloB.lang.types.PrimitiveType.BITFIELD;
     54
     55public class Unparser extends AbstractUnparser {
    4956
    5057        private String stateIdentifier = null;
     
    5259        //////////////////////////////////////////////////////////////
    5360        // constructor and helpers     
    54         public CPPUnparser(SymbolTable symbolTable) {
    55                 super.setSymbolTable(symbolTable);
     61        public Unparser(AbstractIDISABuiltin2Lang idisaBuiltins2Lang) {
     62                this.idisaBuiltins2Lang = idisaBuiltins2Lang;
    5663        }
    5764
     
    150157       
    151158        public CodeStore visitLeave(StateIdentifierNode node, List<CodeStore> childResults) {           
    152                 // synthetic attribute
    153                 stateIdentifier = Accessors.stateName(node);
     159               
     160                stateIdentifier = Accessors.stateName(node); // synthetic attribute
    154161               
    155162                CodeStore code = new CodeStore();
     
    252259                return code;
    253260        }
    254 
    255         // Function call statement 
    256         public CodeStore visitLeave(FuncCallNode node, List<CodeStore> childResults) {
    257                 CodeStore code = new CodeStore();
    258                
    259                 StringBuilder resultVar = new StringBuilder();
    260                
    261                 resultVar.append(childResults.get(0).getResultVarName());
    262                 resultVar.append("(");
    263                 resultVar.append(childResults.get(1).getResultVarName());
    264                 resultVar.append(")");
    265                
    266                 code.setResultVarName(resultVar.toString());            // Function invocation as an expression
    267                
    268                 code.addFormattedLine("%s;", resultVar.toString()); // Function invocation as a statement
    269                
    270                 return code;
    271         }       
    272        
    273         public CodeStore visitLeave(FuncCallArgListNode node, List<CodeStore> childResults) {
    274                 CodeStore code = new CodeStore();
    275                 Iterator<CodeStore> iter = childResults.iterator();
    276                 code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));
    277                 return code;
    278         }
    279                
    280         // if statement
     261                               
    281262        public CodeStore visitLeave(IfStmtNode node, List<CodeStore> childResults) {
    282263                CodeStore code = new CodeStore();
     
    297278        }
    298279       
    299         // while statement
    300280        public CodeStore visitLeave(WhileStmtNode node, List<CodeStore> childResults) {
    301281                CodeStore code = new CodeStore();
     
    309289        }       
    310290       
    311         // return statement
    312291        public CodeStore visitLeave(ReturnStmtNode node, List<CodeStore> childResults) {
    313292                CodeStore code = new CodeStore();
     
    317296        }
    318297                               
    319         // variable declarations
    320298        public CodeStore visitLeave(LocalVarDeclNode node, List<CodeStore> childResults) {
    321299       
     
    344322        }       
    345323       
    346 //      public CodeStore visitLeave(AssignStmtNode node, List<CodeStore> childResults) {
    347 //              CodeStore code = new CodeStore();
    348 //              code.setResultVarName(Accessors.AssignOperator(node));
    349 //              return code;
    350 //      }
    351 
    352         // block Stmts
    353324        public CodeStore visitLeave(BlockStmtNode node, List<CodeStore> childResults) {
    354325                CodeStore code = new CodeStore();
     
    368339        // Expressions
    369340        ////////////////////////////////////////////////////////////////////////////
    370        
    371         // BinaryOperator - Deprecated
    372         /*
    373         public CodeStore visitLeave(BinaryOperatorNode node, List<CodeStore> childResults) {
    374                 CodeStore code = new CodeStore();
    375                 CodeStore lhs = childResults.get(0);
    376                 CodeStore rhs = childResults.get(1);
    377                 String lhsCode = lhs.getResultVarName();
    378                 String rhsCode = rhs.getResultVarName();       
    379                
    380                 StringBuffer resultVar = new StringBuffer();
    381                
    382                 if(!Accessors.isTerminal(Accessors.lhs(node))) {
    383                         lhsCode = bracketExpressionCode(lhsCode);
    384                 }
    385                 resultVar.append(lhsCode);
    386                
    387                 resultVar.append(" ");
    388                 resultVar.append(Accessors.operatorLexeme(node));
    389                 resultVar.append(" ");
    390                
    391                 if(!Accessors.isTerminal(Accessors.rhs(node))) {
    392                         rhsCode = bracketExpressionCode(rhsCode);
    393                 }
    394                 resultVar.append(rhsCode);
    395                
    396                 code.setResultVarName(resultVar.toString());
    397                
    398                 return code;
    399         }
    400         */
    401 
    402         ////////////////////////////////////////////////////////////////////////////
    403         // UnaryOperator - Deprecated
    404         ////////////////////////////////////////////////////////////////////////////
    405         /*
    406         public CodeStore visitLeave(UnaryOperatorNode node, List<CodeStore> childResults) {
    407                 CodeStore code = new CodeStore();
    408                 CodeStore child = childResults.get(0);
    409                 String childCode = child.getResultVarName();
    410                        
    411                 StringBuffer resultVar = new StringBuffer();
    412                 resultVar.append(Accessors.operatorLexeme(node));
    413                
    414                 if(!Accessors.isTerminal(Accessors.operand(node))) {
    415                         childCode = bracketExpressionCode(childCode);
    416                 }
    417                 resultVar.append(childCode);
    418                                
    419                 code.setResultVarName(resultVar.toString());
    420                 return code;
    421         }       
    422         */
    423        
    424         private String bracketExpressionCode(String code) {
    425                 StringBuffer buffer = new StringBuffer();
    426                 buffer.append("(");
    427                 buffer.append(code);
    428                 buffer.append(")");
    429                 return buffer.toString();
     341         
     342        public CodeStore visitLeave(FuncCallNode node, List<CodeStore> childResults) {
     343                CodeStore code = new CodeStore();
     344               
     345                StringBuilder resultVar = new StringBuilder();
     346               
     347                resultVar.append(childResults.get(0).getResultVarName());
     348                resultVar.append("(");
     349                resultVar.append(childResults.get(1).getResultVarName());
     350                resultVar.append(")");
     351               
     352                code.setResultVarName(resultVar.toString());            // Function invocation as an expression
     353               
     354                code.addFormattedLine("%s;", resultVar.toString()); // Function invocation as a statement
     355               
     356                return code;
     357        }       
     358       
     359        public CodeStore visitLeave(FuncCallArgListNode node, List<CodeStore> childResults) {
     360                CodeStore code = new CodeStore();
     361                Iterator<CodeStore> iter = childResults.iterator();
     362                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));
     363                return code;
     364        }       
     365
     366        public CodeStore visitLeave(IdisaFuncCallNode node, List<CodeStore> childResults) {
     367                CodeStore code = new CodeStore();
     368               
     369                StringBuilder resultVar = new StringBuilder();
     370               
     371                String operationName    = childResults.get(0).getResultVarName();
     372                String fieldWidth               = childResults.get(1).getResultVarName();
     373               
     374                Iterator<CodeStore> iter = childResults.listIterator(2);
     375                ArrayList<String> temp = new ArrayList<String>();
     376
     377                while (iter.hasNext()) {
     378                        temp.add(iter.next().getResultVarName());
     379                }       
     380                String [] arguments = temp.toArray(new String [temp.size()]);
     381               
     382                IDISABuiltin idisaBuiltin = IDISABuiltin.fromString(operationName);
     383                assert idisaBuiltin != null : "Unknown IDISA Operation: " + operationName;
     384                assert idisaBuiltin.hasSignature(Integer.valueOf(fieldWidth)) : "Unknown IDISA signature.";
     385               
     386                // AbstractIDISABuiltinGenerator
     387                SIMDBuiltinGenerator idisaBuiltinsGenerator
     388                        = (SIMDBuiltinGenerator) idisaBuiltin.getSignature(Integer.valueOf(fieldWidth)).getIDISABuiltinsGenerator();
     389               
     390               
     391                String idisaFuncCallString = idisaBuiltinsGenerator.makeIDISAFuncCall(idisaBuiltins2Lang, operationName, fieldWidth, arguments);
     392               
     393               
     394               
     395                code.setResultVarName(idisaFuncCallString);             // Function invocation as an expression
     396                code.addFormattedLine("%s;", idisaFuncCallString);      // Function invocation as a statement
     397               
     398                return code;
    430399        }               
    431400       
    432         ////////////////////////////////////////////////////////////////////////////
    433         // StringConstant
    434         ////////////////////////////////////////////////////////////////////////////
    435401        public CodeStore visitLeave(StringConstantNode node, List<CodeStore> childResults) {
    436402                CodeStore code = new CodeStore();
     
    439405        }       
    440406       
    441         ////////////////////////////////////////////////////////////////////////////
    442         // IntegerConstant
    443         ////////////////////////////////////////////////////////////////////////////
    444407        public CodeStore visitLeave(IntegerConstantNode node, List<CodeStore> childResults) {
    445408                CodeStore code = new CodeStore();
     
    448411        }
    449412       
    450         ////////////////////////////////////////////////////////////////////////////
    451         // StreamConstant
    452         ////////////////////////////////////////////////////////////////////////////
    453413        public CodeStore visitLeave(StreamConstantNode node, List<CodeStore> childResults) {
    454         CodeStore code = new CodeStore();
    455         code.setResultVarName(Accessors.streamConstantLexeme(node));
    456         return code;
    457         }
    458        
     414                CodeStore code = new CodeStore();
     415                code.setResultVarName(Accessors.streamConstantLexeme(node));
     416                return code;
     417        }
    459418       
    460419        ////////////////////////////////////////////////////////////////////////////
     
    462421        ////////////////////////////////////////////////////////////////////////////
    463422       
    464         ////////////////////////////////////////////////////////////////////////////
    465         // Stream Structures
    466         ////////////////////////////////////////////////////////////////////////////
    467         // Struct Type - used both as a variable and as sequence of code lines
    468         //
     423        // Stream Structures are used both as a variable and as sequence of code lines
    469424        public CodeStore visitLeave(StructTypeNode node, List<CodeStore> childResults) {
    470425
     
    503458        }
    504459       
    505         // Struct Body
    506460        public CodeStore visitLeave(StructTypeBodyNode node, List<CodeStore> childResults) {
    507461                CodeStore code = new CodeStore();
     
    517471        }
    518472       
    519         // Struct Member
    520473        public CodeStore visitLeave(StructMemberNode node, List<CodeStore> childResults) { // a line of code
    521474                CodeStore code = new CodeStore();
     
    525478                return code;
    526479        }
    527                
    528         // Type
    529         //public CodeStore visitLeave(TypeNode node, List<CodeStore> childResults) {
    530         //      return concatenatedChildrenCode(new CodeStore(), childResults, false);
    531         //}
    532        
    533         // Stream
     480
     481        // TODO - remove non-PabloB type, move type to PabloS2PabloB transformation
    534482        public CodeStore visitLeave(StreamTypeNode node, List<CodeStore> childResults) {
    535483                CodeStore code = new CodeStore();
    536 
    537                 // TODO - Hook for 2^k field width types.
    538                 // code.setResultVarName(Accessors.streamTypeName(node));
    539                
    540                 code.setResultVarName("BitBlock");
    541                
    542                 // TODO - Hook for 2^k field width types.
    543                 /*
    544                 if(Accessors.hasFieldWidth(node)) {
    545                         CodeStore fieldWidth;
    546                         fieldWidth = childResults.get(0);
    547                         code.setResultVarName(code.getResultVarName() + "<" + fieldWidth.getResultVarName() + ">");
    548                 }               
    549                 */             
    550                
     484                code.setResultVarName(Accessors.streamLexeme(node));
    551485                return code;
    552486        }               
    553        
    554         // Field Width
     487                 
     488        public CodeStore visitLeave(BitBlockTypeNode node, List<CodeStore> childResults) {
     489                CodeStore code = new CodeStore();
     490                code.setResultVarName(Accessors.bitBlockLexeme(node));
     491                return code;
     492        }               
     493 
     494        public CodeStore visitLeave(BitFieldTypeNode node, List<CodeStore> childResults) {
     495                CodeStore code = new CodeStore();
     496                code.setResultVarName(Accessors.bitFieldLexeme(node));
     497                return code;
     498        }               
     499       
    555500        public CodeStore visitLeave(FieldWidthNode node, List<CodeStore> childResults) {
    556501                CodeStore code = new CodeStore();
     
    559504        }       
    560505
    561         // Void
    562506        public CodeStore visitLeave(VoidTypeNode node, List<CodeStore> childResults) {
    563507                CodeStore code = new CodeStore();
     
    566510        }               
    567511       
    568         // Compound Identifiers
    569512        public CodeStore visitLeave(CompoundIdentifierNode node, List<CodeStore> childResults) {
    570513                CodeStore code = new CodeStore();
     
    574517        }
    575518       
    576         // Identifiers
    577519        public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) {               
    578520                CodeStore code = new CodeStore();
     
    580522                return code;
    581523        }
    582        
    583524}
  • proto/pabloj/trunk/src/compilers/pabloB/lang/AbstractPabloBBuiltins2Lang.java

    r2983 r3004  
    11package compilers.pabloB.lang;
    22
    3 public abstract class PabloBBuiltins2Lang {
     3public abstract class AbstractPabloBBuiltins2Lang {
    44        public abstract String getCode(PabloBBuiltins builtin);
    55}
  • proto/pabloj/trunk/src/compilers/pabloB/lang/PabloBBuiltins.java

    r2971 r3004  
     1/*
     2 * PabloB builtins.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
     6
    17package compilers.pabloB.lang;
    28
  • proto/pabloj/trunk/src/compilers/pabloB/lang/carrySet/AbstractCarrySetBuiltins2Lang.java

    r2990 r3004  
    77package compilers.pabloB.lang.carrySet;
    88
    9 public abstract class CarrySetBuiltins2Lang {
     9public abstract class AbstractCarrySetBuiltins2Lang {
    1010       
    1111        public abstract String getCode(CarrySetBuiltins op);
  • proto/pabloj/trunk/src/compilers/pabloB/lang/carrySet/CarrySetBuiltins2CPP.java

    r2992 r3004  
    1010import java.util.Map;
    1111
    12 public class CarrySetBuiltins2CPP extends CarrySetBuiltins2Lang {
     12public class CarrySetBuiltins2CPP extends AbstractCarrySetBuiltins2Lang {
    1313       
    1414        private static Map<CarrySetBuiltins, String> carry2CPPCode;
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/IDISABuiltin.java

    r2983 r3004  
    1111package compilers.pabloB.lang.idisa;
    1212
    13 public enum IDISASIMDBuiltins {
     13import java.util.ArrayList;
     14import java.util.HashMap;
     15import java.util.Map;
     16
     17import compilers.pabloB.codeGenerator.idisa.AbstractIDISABuiltinGenerator;
     18import compilers.pabloB.codeGenerator.idisa.SIMDBuiltinGenerator;
     19import compilers.pabloB.lang.types.Type;
     20
     21import static compilers.pabloB.lang.types.PrimitiveType.INTEGERCONSTANT;
     22import static compilers.pabloB.lang.types.PrimitiveType.BITBLOCK;
     23import static compilers.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
     24
     25public enum IDISABuiltin {
     26
     27        SIMD_CONSTANT(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), INTEGERCONSTANT)),
    1428       
    15         ADD("add",1,2),
    16         SUB("sub",1,2),
    17         MUL("mul",1,2),
    18         EQ("eq",1,2),
    19         GT("gt",1,2),
    20         UGT("ugt",1,2),
    21         LT("lt",1,2),
    22         ULT("ult",1,2),
    23         MAX("max",1,2),
    24         UMAX("umax",1,2),
    25         MIN("min",1,2),
    26         UMIN("umin",1,2),
    27         SLL("sll",1,2),
    28         SRL("srl",1,2),
    29         SRA("sra",1,2),
     29        // SIMD unary operations
    3030       
    31         CONSTANT("constant",1,0);
     31        // SIMD binary operations
     32        SIMD_ADD(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),     
     33        SIMD_SUB(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     34        SIMD_MUL(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     35        SIMD_EQ(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     36        SIMD_GT(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     37        SIMD_UGT(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     38        SIMD_LT(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     39        SIMD_ULT(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     40        SIMD_MAX(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     41        SIMD_UMAX(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     42        SIMD_MIN(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     43        SIMD_UMIN(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     44        SIMD_SLL(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     45        SIMD_SRL(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK)),
     46        SIMD_SRA(makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(), BITBLOCK, BITBLOCK, BITBLOCK));
    3247       
    33         private String name;
    34         private int fieldWidth;
    35         private int argCount;
    3648       
    37         private IDISASIMDBuiltins(String name, int fieldWidth, int argCount) {
    38                 this.name = name;
    39                 this.fieldWidth = fieldWidth;
    40                 this.argCount = argCount;
     49        // SIMD ternary operations
     50       
     51       
     52        private static final Map<String, IDISABuiltin> operationName2IDISABuilinMap = new HashMap<String, IDISABuiltin>();
     53           
     54        static {
     55                for(IDISABuiltin idisaBuiltin : values()) {
     56                        operationName2IDISABuilinMap.put(idisaBuiltin.toString(), idisaBuiltin);
     57                }
     58    }
     59       
     60    public static IDISABuiltin fromString(String operationName) {
     61        return operationName2IDISABuilinMap.get(operationName);
     62    }
     63   
     64        private IDISAFunctionSignature [] signatures;
     65       
     66        private IDISABuiltin(IDISAFunctionSignature ...signatures) {
     67                this.signatures = signatures;
     68        }
     69
     70       
     71        @Override
     72        public String toString() {
     73                return this.name().toLowerCase().replaceFirst("_", ".");
    4174        }
    4275       
    43         private static final String SIMD = "simd";
    44        
    45         public String Name(String fieldWidth) {
    46                 return (SIMD + "<" + fieldWidth + ">::" + name);
     76        public boolean hasCompileTimeConstantArgument() {
     77                return false;
     78        }
     79
     80        public boolean hasSignature(int fieldWidth) {
     81                return !getSignature(fieldWidth).isNull();
    4782        }
    4883       
    49         public String ConstantName(String fieldWidth, String constantValue) {
    50                 return Name(fieldWidth) + "<" + constantValue + ">"; 
     84        public IDISAFunctionSignature getSignature(int fieldWidth) {
     85
     86                for(IDISAFunctionSignature signature : this.signatures) {
     87                        if(signature.matches(fieldWidth)) {
     88                                return signature;
     89                        }
     90                }
     91               
     92                return IDISAFunctionSignature.nullInstance();
    5193        }
    5294       
    53         public int getFieldWidth() { return fieldWidth; }
    54         public int argCount() { return argCount; }
     95       
     96        public boolean hasSignature(int fieldWidth, Type ... types) {
     97                return getSignature(fieldWidth,types).isNull();
     98        }
     99       
     100        public IDISAFunctionSignature getSignature(int fieldWidth, Type ... types) {
     101
     102                for(IDISAFunctionSignature signature : this.signatures) {
     103                        if(signature.matches(fieldWidth,types)) {
     104                                return signature;
     105                        }
     106                }
    55107               
     108                return IDISAFunctionSignature.nullInstance();
     109        }
     110       
     111       
     112        /**
     113         * Makes IDISA function signatures from 2^0 to power-of-2 upper bound field width and constant arguments.
     114         */
     115        private static IDISAFunctionSignature [] makeAllSimpleSignatures (int upperBound, AbstractIDISABuiltinGenerator idisaBuiltinsGenerator, Type ...types) {
     116                return (IDISAFunctionSignature []) makeRangeOfSimpleSignatures(1, upperBound, idisaBuiltinsGenerator,types);
     117        }
     118       
     119        /**
     120         * Makes IDISA function signatures from power-of-2 lower bound to power-of-2 upper bound field width and constant arguments.
     121         */
     122        private static IDISAFunctionSignature [] makeRangeOfSimpleSignatures (int lowerBound, int upperBound, AbstractIDISABuiltinGenerator idisaBuiltinsGenerator, Type ...types) {
     123               
     124                ArrayList<IDISAFunctionSignature> signatures = new ArrayList<IDISAFunctionSignature>();
     125                       
     126                for(int fw=lowerBound;fw<=upperBound;fw*=2) {
     127                        IDISAFunctionSignature signature = new IDISAFunctionSignature(idisaBuiltinsGenerator,fw,types);
     128                        signatures.add(signature);
     129                }
     130               
     131               
     132                return (IDISAFunctionSignature []) signatures.toArray(new IDISAFunctionSignature[signatures.size()]);
     133               
     134        }
     135       
    56136}
    57137
     138/*
     139
     1401. Define IDISA builtins.
     1412. Define FunctionSignature as an interface. 'getSignature' returns a new signature, this signature can be used to build the
     142function signatures hash for recognition of calls.
     1433. A 'matcher' object will serve to match function signatures.
     1444. IDISABuiltins2Lang will translate the majority of IDISA builtins but 'special cases' will call out to helpers based on type.
     145 
     146So, PabloS creates an simd.constant<1>(0) IDISA function call with compound id, fw, arg_list. In this case the first argument is
     147a constant integer (a primitive).
     148
     149IDISA Function Call looks up the function call.
     150
     151It finds the type 'CONSTANT1',
     152It
     153(1) calls the IDISA2CPP generator with the value 'CONSTANT1' and the node to make the string or
     154(2) 
     155 
     156*/
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/IDISASIMDBitwiseBuiltins.java

    r2971 r3004  
    11/*
     2 * Deprecated - Will migrate to new IDISA builtins.
     3 *
    24 * IDISA SIMD bitwise builtins.
    35 *
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/IDISASIMDBuiltins.java

    r2972 r3004  
    11/*
     2 * Deprecated - Will migrate to new IDISA builtins.
     3 *
    24 * IDISA SIMD builtins.
    35 *
  • proto/pabloj/trunk/src/compilers/pabloB/semanticAnalyzer/Transformer.java

    r2971 r3004  
    1818        //private SymbolTable symbolTable;
    1919       
    20         private PabloBBuiltins2Lang builtins2Lang;
    21         private CarrySetBuiltins2Lang carrySet2Lang;
     20        private AbstractPabloBBuiltins2Lang builtins2Lang;
     21        private AbstractCarrySetBuiltins2Lang carrySet2Lang;
    2222       
    2323        //////////////////////////////////////////////////////////////
     
    5555        }
    5656
    57         public PabloBBuiltins2Lang getBuiltins2Lang() {
     57        public AbstractPabloBBuiltins2Lang getBuiltins2Lang() {
    5858                return this.builtins2Lang;
    5959        }
    6060
    61         public void setBuiltins2Lang(PabloBBuiltins2Lang builtins2Lang) {
     61        public void setBuiltins2Lang(AbstractPabloBBuiltins2Lang builtins2Lang) {
    6262                this.builtins2Lang = builtins2Lang;
    6363        }
    6464
    65         public CarrySetBuiltins2Lang getCarrySet2Lang() {
     65        public AbstractCarrySetBuiltins2Lang getCarrySet2Lang() {
    6666                return carrySet2Lang;
    6767        }
    6868
    69         public void setCarrySet2Lang(CarrySetBuiltins2Lang carrySet2Lang) {
     69        public void setCarrySet2Lang(AbstractCarrySetBuiltins2Lang carrySet2Lang) {
    7070                this.carrySet2Lang = carrySet2Lang;
    7171        }
  • proto/pabloj/trunk/src/compilers/pabloB/symbols/AbstractBinding.java

    r2983 r3004  
    11package compilers.pabloB.symbols;
    22
    3 abstract public class Binding {
     3abstract public class AbstractBinding {
    44//      private Type type;
    55//      private boolean mutable;
  • proto/pabloj/trunk/src/compilers/pabloB/symbols/AbstractSymbol.java

    r2983 r3004  
    11package compilers.pabloB.symbols;
    22
    3 public abstract class Symbol {}
     3public abstract class AbstractSymbol {}
  • proto/pabloj/trunk/src/compilers/pabloB/symbols/CarryInfoSetSymbol.java

    r2952 r3004  
    1414import java.util.ArrayList;
    1515
    16 public class CarryInfoSetSymbol extends Symbol {
     16public class CarryInfoSetSymbol extends AbstractSymbol {
    1717
    1818        private ArrayList<Integer> carry1 = null;
  • proto/pabloj/trunk/src/compilers/pabloB/symbols/SymbolTable.java

    r2952 r3004  
    77public class SymbolTable {
    88
    9         private Map<String, Symbol> symbolTable;
     9        private Map<String, AbstractSymbol> symbolTable;
    1010       
    1111        public SymbolTable() {
    12                 symbolTable = new LinkedHashMap<String, Symbol>();
     12                symbolTable = new LinkedHashMap<String, AbstractSymbol>();
    1313        }
    1414       
    15         public void put(String node, Symbol symbol) {
     15        public void put(String node, AbstractSymbol symbol) {
    1616                symbolTable.put(node, symbol);
    1717        }
    1818       
    19         public Symbol get(String node) {
     19        public AbstractSymbol get(String node) {
    2020                return symbolTable.get(node);
    2121        }
  • proto/pabloj/trunk/src/compilers/pabloS/ast/Generators.java

    r2977 r3004  
    225225        }
    226226       
    227         public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     227        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
    228228                List<ASTNode> args = new ArrayList<ASTNode>();
    229229                args.add(node);
     
    232232        }
    233233
    234         public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     234        public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
    235235                List<ASTNode> args = new ArrayList<ASTNode>();
    236236                args.add(node);
     
    239239        }       
    240240
    241         public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     241        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
    242242                List<ASTNode> args = new ArrayList<ASTNode>();
    243243                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
     
    246246        }               
    247247       
    248         public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     248        public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
    249249                List<ASTNode> args = new ArrayList<ASTNode>();
    250250                args.add(node);
     
    252252        }               
    253253       
    254         public static ParameterNode makeEOFMaskParameter(PabloSBuiltins2Lang builtins2Lang, Token locationToken) {
     254        public static ParameterNode makeEOFMaskParameter(AbstractPabloSBuiltins2Lang builtins2Lang, Token locationToken) {
    255255               
    256256                Token parameterNodeToken = Generators.makeLextantToken(Lextant.STREAM, locationToken);
  • proto/pabloj/trunk/src/compilers/pabloS/lang/AbstractPabloSBuiltins2Lang.java

    r2983 r3004  
    11package compilers.pabloS.lang;
    22
    3 public abstract class PabloSBuiltins2Lang {
     3public abstract class AbstractPabloSBuiltins2Lang {
    44        public abstract String getCode(PabloSBuiltins builtin);
    55}
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltins2CPP.java

    r2972 r3004  
    1515import java.util.Map;
    1616
    17 import compilers.pabloB.lang.idisa.IDISASIMDBuiltins;
    18 
    19 public class PabloSBuiltins2CPP extends PabloSBuiltins2Lang {
     17public class PabloSBuiltins2CPP extends AbstractPabloSBuiltins2Lang {
    2018
    2119        private static Map<PabloSBuiltins, String> pabloS2CPPCode;
  • proto/pabloj/trunk/src/compilers/pabloS/lang/signatures/FunctionSignature.java

    r2978 r3004  
    11package compilers.pabloS.lang.signatures;
    22
    3 import java.util.ArrayList;
    43import java.util.List;
    5 
    64import compilers.pabloS.lang.types.PrimitiveType;
    75import compilers.pabloS.lang.types.Type;
    8 
    9 
    106
    117// immutable
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/Transformer.java

    r2971 r3004  
    2323        //private SymbolTable symbolTable;
    2424       
    25         private compilers.pabloS.lang.PabloSBuiltins2Lang builtins2Lang;
    26         private compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang carrySet2Lang;
     25        private compilers.pabloS.lang.AbstractPabloSBuiltins2Lang builtins2Lang;
     26        private compilers.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang carrySet2Lang;
    2727        private boolean finalBlockMode;
    2828       
     
    110110        }
    111111
    112         public PabloSBuiltins2Lang getBuiltins2Lang() {
     112        public AbstractPabloSBuiltins2Lang getBuiltins2Lang() {
    113113                return this.builtins2Lang;
    114114        }
    115115
    116         public void setBuiltins2Lang(PabloSBuiltins2Lang builtins2Lang) {
     116        public void setBuiltins2Lang(AbstractPabloSBuiltins2Lang builtins2Lang) {
    117117                this.builtins2Lang = builtins2Lang;
    118118        }
    119119
    120         public compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang getCarrySet2Lang() {
     120        public compilers.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang getCarrySet2Lang() {
    121121                return carrySet2Lang;
    122122        }
    123123
    124         public void setCarrySet2Lang(compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang carrySet2Lang) {
     124        public void setCarrySet2Lang(compilers.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang carrySet2Lang) {
    125125                this.carrySet2Lang = carrySet2Lang;
    126126        }
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AssertBitBlockAlignStmtsXFormer.java

    r2971 r3004  
    1414import compilers.pabloS.ast.Generators;
    1515import compilers.pabloS.lang.PabloSBuiltins;
    16 import compilers.pabloS.lang.PabloSBuiltins2Lang;
     16import compilers.pabloS.lang.AbstractPabloSBuiltins2Lang;
    1717
    1818public class AssertBitBlockAlignStmtsXFormer {
    1919        private ASTNode ASTree;
    2020       
    21         private PabloSBuiltins2Lang builtins2Lang;
     21        private AbstractPabloSBuiltins2Lang builtins2Lang;
    2222       
    23         public AssertBitBlockAlignStmtsXFormer(ASTNode ASTree, PabloSBuiltins2Lang builtins2Lang) {
     23        public AssertBitBlockAlignStmtsXFormer(ASTNode ASTree, AbstractPabloSBuiltins2Lang builtins2Lang) {
    2424                this.ASTree = ASTree;
    2525                this.builtins2Lang = builtins2Lang;
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AssertZeroXFormer.java

    r2971 r3004  
    1313import compilers.pabloS.ast.Generators;
    1414import compilers.pabloS.lang.PabloSBuiltins;
    15 import compilers.pabloS.lang.PabloSBuiltins2Lang;
     15import compilers.pabloS.lang.AbstractPabloSBuiltins2Lang;
    1616import compilers.pabloS.lang.PabloSBuiltinsUtil;
    1717
    1818public class AssertZeroXFormer {
    1919        private ASTNode ASTree;
    20         private PabloSBuiltins2Lang builtins2Lang;
     20        private AbstractPabloSBuiltins2Lang builtins2Lang;
    2121
    22         public AssertZeroXFormer(ASTNode ASTree, PabloSBuiltins2Lang builtins2Lang) {
     22        public AssertZeroXFormer(ASTNode ASTree, AbstractPabloSBuiltins2Lang builtins2Lang) {
    2323                this.ASTree = ASTree;
    2424                this.builtins2Lang = builtins2Lang;
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/Bitwise2IDISAXFormer.java

    r2972 r3004  
    112112                public void visitLeave(IfStmtNode node) {
    113113                        ASTNode ifTest = Accessors.ifTest(node);                       
    114                         String FuncName = IDISABitBlockBuiltins.ANY.IDISALexeme();
     114                        String FuncName = IDISABitBlockBuiltins.ANY.IDISALexeme(); // TODO Update to IDISA syntax
    115115                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest});
    116116                        node.replaceChild(ifTest, FuncCallNode);
     
    125125                                                                                                                               
    126126                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
    127                                         IDISABitBlockBuiltins.ANY.IDISALexeme(),
     127                                        IDISABitBlockBuiltins.ANY.IDISALexeme(), // TODO Update to IDISA syntax
    128128                                        node.getToken(),
    129129                                        new ASTNode [] {whileTest});                           
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryInfoSetVisitor.java

    r2971 r3004  
    55 */
    66package compilers.pabloS.semanticAnalyzer.visitors;
    7 
    8 import java.util.List;
    97
    108import compilers.pabloB.symbols.CarryInfoSetSymbol;
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2990 r3004  
    99
    1010import compilers.pabloB.lang.carrySet.CarrySetBuiltins;
    11 import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
     11import compilers.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
    1212import compilers.pabloB.lang.idisa.IDISASIMDBuiltins;
    1313import compilers.pabloS.ast.Accessors;
     
    6868               
    6969        private ASTNode ASTTree;       
    70         private PabloSBuiltins2Lang builtins2Lang;
    71         private CarrySetBuiltins2Lang carrySet2Lang;
     70        private AbstractPabloSBuiltins2Lang builtins2Lang;
     71        private AbstractCarrySetBuiltins2Lang carrySet2Lang;
    7272       
    7373        private int carrySetDepth;
    7474        private String carrySetIdentifier;             
    7575       
    76     public CarryIntroXFormer(ASTNode node, PabloSBuiltins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {
     76    public CarryIntroXFormer(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang, AbstractCarrySetBuiltins2Lang carrySet2Lang) {
    7777        this.ASTTree = node;
    7878        this.builtins2Lang = builtins2Lang;
     
    9090    public void XForm(boolean finalBlockMode, int carrySetDepth) {
    9191        setCarrySetDepth(carrySetDepth);           
    92         setCarrySetIdentifier(CarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
     92        setCarrySetIdentifier(AbstractCarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
    9393
    9494        XFormer visitor = new XFormer();
     
    9999    public void XForm(boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
    100100        setCarrySetDepth(carrySetDepth);           
    101         setCarrySetIdentifier(CarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
     101        setCarrySetIdentifier(AbstractCarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
    102102       
    103103        XFormer visitor = new XFormer();
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/DumpAssignStmtsXFormer.java

    r2971 r3004  
    1414import compilers.pabloS.ast.Generators;
    1515import compilers.pabloS.lang.PabloSBuiltins;
    16 import compilers.pabloS.lang.PabloSBuiltins2Lang;
     16import compilers.pabloS.lang.AbstractPabloSBuiltins2Lang;
    1717
    1818public class DumpAssignStmtsXFormer {
    1919        private ASTNode ASTree;
    20         private PabloSBuiltins2Lang builtins2Lang;
     20        private AbstractPabloSBuiltins2Lang builtins2Lang;
    2121       
    22         public DumpAssignStmtsXFormer(ASTNode ASTree, PabloSBuiltins2Lang builtins2Lang) {
     22        public DumpAssignStmtsXFormer(ASTNode ASTree, AbstractPabloSBuiltins2Lang builtins2Lang) {
    2323                this.ASTree = ASTree;
    2424                this.builtins2Lang = builtins2Lang;
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/InitStreamDefaultsXFormer.java

    r2972 r3004  
    1212
    1313import pabloS.ast.*;
    14 import pabloS.lexicalAnalyzer.Lextant;
    15 import pabloS.tokens.Token;
    1614
    17 import compilers.pabloB.lang.idisa.IDISABitBlockBuiltins;
    1815import compilers.pabloB.lang.idisa.IDISASIMDBuiltins;
    1916import compilers.pabloS.ast.Accessors;
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r2988 r3004  
    1313import compilers.pabloB.ast.Generators;
    1414import compilers.pabloB.lang.carrySet.CarrySetBuiltins;
    15 import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
     15import compilers.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
    1616import compilers.pabloB.symbols.CarryInfoSetSymbol;
    1717import compilers.pabloB.symbols.SymbolTable;
     
    3535
    3636       
    37         private CarrySetBuiltins2Lang carrySet2Lang;
     37        private AbstractCarrySetBuiltins2Lang carrySet2Lang;
    3838       
    3939        /*
     
    4444         */
    4545 
    46     public PabloS2PabloBXFormer(compilers.pabloB.symbols.SymbolTable pabloSSymbolTable, CarrySetBuiltins2Lang carrySet2Lang) {
     46    public PabloS2PabloBXFormer(compilers.pabloB.symbols.SymbolTable pabloSSymbolTable, AbstractCarrySetBuiltins2Lang carrySet2Lang) {
    4747        this.decoratedASTTree = null;
    4848        this.optDecoratedASTTree = null;
     
    119119                                               
    120120                                                        FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    121                                                                 new String [] {CarrySetBuiltins2Lang.CARRYSETBASENAME,
     121                                                                new String [] {AbstractCarrySetBuiltins2Lang.CARRYSETBASENAME,
    122122                                                                                                carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
    123123                                                                                                locationToken,
     
    125125                                               
    126126                                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    127                                                                         new String [] {CarrySetBuiltins2Lang.CARRYSETBASENAME,
     127                                                                        new String [] {AbstractCarrySetBuiltins2Lang.CARRYSETBASENAME,
    128128                                                                                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
    129129                                                                                                        locationToken,
     
    131131                                                       
    132132                                                        FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    133                                                                         new String [] {CarrySetBuiltins2Lang.CARRYSETBASENAME,
     133                                                                        new String [] {AbstractCarrySetBuiltins2Lang.CARRYSETBASENAME,
    134134                                                                                                        carrySet2Lang.getCode(CarrySetBuiltins.SETCARRY)},
    135135                                                                                                        locationToken,
  • proto/pabloj/trunk/src/pabloB/ast/ASTNode.java

    r2981 r3004  
    1212import pabloB.tokens.Token;
    1313
    14 public class ASTNode {
     14
     15
     16public class ASTNode  {
    1517        public static final ASTNode NO_PARENT = null;
    1618        public static final int NO_TAG = -1;
     
    1820        List<ASTNode>   children;
    1921        ASTNode parent;
     22       
    2023        Token token;
    21         int productionTag = NO_TAG;
    22 
     24        int productionTag;
    2325        boolean simplifiable;
    24 
     26       
     27       
    2528       
    2629        public ASTNode(Token token) {
     30                initChildren();
     31                this.parent = NO_PARENT;
     32       
    2733                this.token = token;
    28                 this.parent = NO_PARENT;
     34                this.productionTag = NO_TAG;
    2935                this.simplifiable = false;
    30                 initChildren();
    3136        }
    3237        // "detached" copy constructor.  Copies all info except tree info (parent and children)
    3338        public ASTNode(ASTNode node) {
     39                initChildren();
     40                this.parent = NO_PARENT;
     41                 
    3442                this.token = node.token;
     43                this.productionTag = node.productionTag;
     44                this.simplifiable = node.simplifiable;
     45               
     46
    3547        }
    3648       
    3749        public ASTNode deepCopy() {
    38                 ASTNode parent = new ASTNode(this.getToken());
     50                ASTNode parent = new ASTNode(this);
    3951               
    4052                for(ASTNode child: this.getChildren()) {
     
    5870// attributes
    5971
     72       
     73        public void setProductionTag(int tag) {
     74                productionTag = tag;
     75        }
     76        public int getProductionTag() {
     77                return productionTag;
     78        }
     79       
    6080        public void setSimplifiable(boolean value) {
    6181                simplifiable = value;
     
    6484                return simplifiable;
    6585        }
    66         public void setProductionTag(int tag) {
    67                 productionTag = tag;
    68         }
    69         public int getProductionTag() {
    70                 return productionTag;
    71         }
    72        
    73        
     86
     87
     88
     89
    7490////////////////////////////////////////////////////////////////////////////////////
    7591// dealing with children and parent
     
    191207         */
    192208        public String attributeString() {
    193                 return "";
     209                String result = "";
     210
     211                if(result.isEmpty()) return result;
     212                int length = result.length();
     213                return result.substring(0, length-2);   
    194214        }
    195215       
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r3001 r3004  
    4040        public ASTNode visit(IdentifierNode node);
    4141
    42         public ASTNode visit(IdisaCallArgListNode node);
    43 
    44         public ASTNode visit(IdisaCallNode node);
     42        public ASTNode visit(IdisaFuncCallNode node);
    4543
    4644        public ASTNode visit(IfStmtNode node);
     
    159157                }
    160158
    161                 public ASTNode visit(IdisaCallArgListNode node) {
    162                         return defaultVisit(node);
    163                 }
    164 
    165                 public ASTNode visit(IdisaCallNode node) {
     159                public ASTNode visit(IdisaFuncCallNode node) {
    166160                        return defaultVisit(node);
    167161                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r3001 r3004  
    5656        public T visitLeave(IdentifierNode node, List<T> childResults);
    5757
    58         public void visitEnter(IdisaCallArgListNode node);
    59         public T visitLeave(IdisaCallArgListNode node, List<T> childResults);
    60 
    61         public void visitEnter(IdisaCallNode node);
    62         public T visitLeave(IdisaCallNode node, List<T> childResults);
     58        public void visitEnter(IdisaFuncCallNode node);
     59        public T visitLeave(IdisaFuncCallNode node, List<T> childResults);
    6360
    6461        public void visitEnter(IfStmtNode node);
     
    256253                }
    257254
    258                 public void visitEnter(IdisaCallArgListNode node) {
    259                         defaultVisitEnter(node);
    260                 }
    261                 public T visitLeave(IdisaCallArgListNode node, List<T> childResults) {
    262                         return defaultVisitLeave(node);
    263                 }
    264 
    265                 public void visitEnter(IdisaCallNode node) {
    266                         defaultVisitEnter(node);
    267                 }
    268                 public T visitLeave(IdisaCallNode node, List<T> childResults) {
     255                public void visitEnter(IdisaFuncCallNode node) {
     256                        defaultVisitEnter(node);
     257                }
     258                public T visitLeave(IdisaFuncCallNode node, List<T> childResults) {
    269259                        return defaultVisitLeave(node);
    270260                }
  • proto/pabloj/trunk/src/pabloB/ast/AssignNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class AssignNode extends ASTNode  {
    13        
     15
     16
    1417        public AssignNode(Token token) {
    1518                super(token);
    1619        }
    17         public AssignNode(ASTNode node) {
     20        public AssignNode(AssignNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public AssignNode deepCopy() {
    22                 AssignNode parent = new AssignNode(this.getToken());
     26                AssignNode parent = new AssignNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/AssignOperatorNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class AssignOperatorNode extends ASTNode  {
    13        
     15
     16
    1417        public AssignOperatorNode(Token token) {
    1518                super(token);
    1619        }
    17         public AssignOperatorNode(ASTNode node) {
     20        public AssignOperatorNode(AssignOperatorNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public AssignOperatorNode deepCopy() {
    22                 AssignOperatorNode parent = new AssignOperatorNode(this.getToken());
     26                AssignOperatorNode parent = new AssignOperatorNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/BitBlockTypeNode.java

    r2984 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class BitBlockTypeNode extends ASTNode  {
    13        
     15
     16
    1417        public BitBlockTypeNode(Token token) {
    1518                super(token);
    1619        }
    17         public BitBlockTypeNode(ASTNode node) {
     20        public BitBlockTypeNode(BitBlockTypeNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public BitBlockTypeNode deepCopy() {
    22                 BitBlockTypeNode parent = new BitBlockTypeNode(this.getToken());
     26                BitBlockTypeNode parent = new BitBlockTypeNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/BitFieldTypeNode.java

    r3001 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class BitFieldTypeNode extends ASTNode  {
    13        
     15
     16
    1417        public BitFieldTypeNode(Token token) {
    1518                super(token);
    1619        }
    17         public BitFieldTypeNode(ASTNode node) {
     20        public BitFieldTypeNode(BitFieldTypeNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public BitFieldTypeNode deepCopy() {
    22                 BitFieldTypeNode parent = new BitFieldTypeNode(this.getToken());
     26                BitFieldTypeNode parent = new BitFieldTypeNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/BlockStmtNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class BlockStmtNode extends ASTNode  {
    13        
     15
     16
    1417        public BlockStmtNode(Token token) {
    1518                super(token);
    1619        }
    17         public BlockStmtNode(ASTNode node) {
     20        public BlockStmtNode(BlockStmtNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public BlockStmtNode deepCopy() {
    22                 BlockStmtNode parent = new BlockStmtNode(this.getToken());
     26                BlockStmtNode parent = new BlockStmtNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/CompoundIdentifierNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class CompoundIdentifierNode extends ASTNode  {
    13        
     15
     16
    1417        public CompoundIdentifierNode(Token token) {
    1518                super(token);
    1619        }
    17         public CompoundIdentifierNode(ASTNode node) {
     20        public CompoundIdentifierNode(CompoundIdentifierNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public CompoundIdentifierNode deepCopy() {
    22                 CompoundIdentifierNode parent = new CompoundIdentifierNode(this.getToken());
     26                CompoundIdentifierNode parent = new CompoundIdentifierNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/EpsilonNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class EpsilonNode extends ASTNode  {
    13        
     15
     16
    1417        public EpsilonNode(Token token) {
    1518                super(token);
    1619        }
    17         public EpsilonNode(ASTNode node) {
     20        public EpsilonNode(EpsilonNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public EpsilonNode deepCopy() {
    22                 EpsilonNode parent = new EpsilonNode(this.getToken());
     26                EpsilonNode parent = new EpsilonNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/ErrorNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class ErrorNode extends ASTNode  {
    13        
     15
     16
    1417        public ErrorNode(Token token) {
    1518                super(token);
    1619        }
    17         public ErrorNode(ASTNode node) {
     20        public ErrorNode(ErrorNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public ErrorNode deepCopy() {
    22                 ErrorNode parent = new ErrorNode(this.getToken());
     26                ErrorNode parent = new ErrorNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/FieldWidthNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class FieldWidthNode extends ASTNode  {
    13        
     15
     16
    1417        public FieldWidthNode(Token token) {
    1518                super(token);
    1619        }
    17         public FieldWidthNode(ASTNode node) {
     20        public FieldWidthNode(FieldWidthNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public FieldWidthNode deepCopy() {
    22                 FieldWidthNode parent = new FieldWidthNode(this.getToken());
     26                FieldWidthNode parent = new FieldWidthNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/FuncCallArgListNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class FuncCallArgListNode extends ASTNode  {
    13        
     15
     16
    1417        public FuncCallArgListNode(Token token) {
    1518                super(token);
    1619        }
    17         public FuncCallArgListNode(ASTNode node) {
     20        public FuncCallArgListNode(FuncCallArgListNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public FuncCallArgListNode deepCopy() {
    22                 FuncCallArgListNode parent = new FuncCallArgListNode(this.getToken());
     26                FuncCallArgListNode parent = new FuncCallArgListNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/FuncCallNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class FuncCallNode extends ASTNode  {
    13        
     15
     16
    1417        public FuncCallNode(Token token) {
    1518                super(token);
    1619        }
    17         public FuncCallNode(ASTNode node) {
     20        public FuncCallNode(FuncCallNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public FuncCallNode deepCopy() {
    22                 FuncCallNode parent = new FuncCallNode(this.getToken());
     26                FuncCallNode parent = new FuncCallNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/FuncCallOrAssignStmtNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class FuncCallOrAssignStmtNode extends ASTNode  {
    13        
     15
     16
    1417        public FuncCallOrAssignStmtNode(Token token) {
    1518                super(token);
    1619        }
    17         public FuncCallOrAssignStmtNode(ASTNode node) {
     20        public FuncCallOrAssignStmtNode(FuncCallOrAssignStmtNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public FuncCallOrAssignStmtNode deepCopy() {
    22                 FuncCallOrAssignStmtNode parent = new FuncCallOrAssignStmtNode(this.getToken());
     26                FuncCallOrAssignStmtNode parent = new FuncCallOrAssignStmtNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/FuncDefNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class FuncDefNode extends ASTNode  {
    13        
     15
     16
    1417        public FuncDefNode(Token token) {
    1518                super(token);
    1619        }
    17         public FuncDefNode(ASTNode node) {
     20        public FuncDefNode(FuncDefNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public FuncDefNode deepCopy() {
    22                 FuncDefNode parent = new FuncDefNode(this.getToken());
     26                FuncDefNode parent = new FuncDefNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/IdentifierNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class IdentifierNode extends ASTNode  {
    13        
     15
     16
    1417        public IdentifierNode(Token token) {
    1518                super(token);
    1619        }
    17         public IdentifierNode(ASTNode node) {
     20        public IdentifierNode(IdentifierNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public IdentifierNode deepCopy() {
    22                 IdentifierNode parent = new IdentifierNode(this.getToken());
     26                IdentifierNode parent = new IdentifierNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/IfStmtNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class IfStmtNode extends ASTNode  {
    13        
     15
     16
    1417        public IfStmtNode(Token token) {
    1518                super(token);
    1619        }
    17         public IfStmtNode(ASTNode node) {
     20        public IfStmtNode(IfStmtNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public IfStmtNode deepCopy() {
    22                 IfStmtNode parent = new IfStmtNode(this.getToken());
     26                IfStmtNode parent = new IfStmtNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/InitBlockNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class InitBlockNode extends ASTNode  {
    13        
     15
     16
    1417        public InitBlockNode(Token token) {
    1518                super(token);
    1619        }
    17         public InitBlockNode(ASTNode node) {
     20        public InitBlockNode(InitBlockNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public InitBlockNode deepCopy() {
    22                 InitBlockNode parent = new InitBlockNode(this.getToken());
     26                InitBlockNode parent = new InitBlockNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/InitDefNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class InitDefNode extends ASTNode  {
    13        
     15
     16
    1417        public InitDefNode(Token token) {
    1518                super(token);
    1619        }
    17         public InitDefNode(ASTNode node) {
     20        public InitDefNode(InitDefNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public InitDefNode deepCopy() {
    22                 InitDefNode parent = new InitDefNode(this.getToken());
     26                InitDefNode parent = new InitDefNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/IntValuedNodeType.java

    r2981 r3004  
    66
    77package pabloB.ast;
     8
     9
    810
    911public interface IntValuedNodeType  {
  • proto/pabloj/trunk/src/pabloB/ast/IntegerConstantNode.java

    r2981 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class IntegerConstantNode extends ASTNode implements IntValuedNodeType {
    13        
     15        private int value = 0;
     16
     17
    1418        public IntegerConstantNode(Token token) {
    1519                super(token);
    1620        }
    17         public IntegerConstantNode(ASTNode node) {
     21        public IntegerConstantNode(IntegerConstantNode node) {
    1822                super(node);
     23                this.value = node.value;
     24
    1925        }
    2026       
    2127        public IntegerConstantNode deepCopy() {
    22                 IntegerConstantNode parent = new IntegerConstantNode(this.getToken());
     28                IntegerConstantNode parent = new IntegerConstantNode(this);
    2329               
    2430                for(ASTNode child: this.getChildren()) {
     
    3238       
    3339        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     40        // attribute accessors
    3541
    36         private int value = 0;
    37        
    3842        public int getValue() {
    3943                return value;
     
    5054        @Override
    5155        public String attributeString() {
    52                 String result = "";
     56                String result = super.attributeString();
     57                if(!result.isEmpty()) {
     58                        result += ", ";
     59                }
    5360                result += "value = " + value + ", ";
    5461
  • proto/pabloj/trunk/src/pabloB/ast/KernelDefNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class KernelDefNode extends ASTNode  {
    13        
     15
     16
    1417        public KernelDefNode(Token token) {
    1518                super(token);
    1619        }
    17         public KernelDefNode(ASTNode node) {
     20        public KernelDefNode(KernelDefNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public KernelDefNode deepCopy() {
    22                 KernelDefNode parent = new KernelDefNode(this.getToken());
     26                KernelDefNode parent = new KernelDefNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/LocalVarDeclNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class LocalVarDeclNode extends ASTNode  {
    13        
     15
     16
    1417        public LocalVarDeclNode(Token token) {
    1518                super(token);
    1619        }
    17         public LocalVarDeclNode(ASTNode node) {
     20        public LocalVarDeclNode(LocalVarDeclNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public LocalVarDeclNode deepCopy() {
    22                 LocalVarDeclNode parent = new LocalVarDeclNode(this.getToken());
     26                LocalVarDeclNode parent = new LocalVarDeclNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/ParameterListNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class ParameterListNode extends ASTNode  {
    13        
     15
     16
    1417        public ParameterListNode(Token token) {
    1518                super(token);
    1619        }
    17         public ParameterListNode(ASTNode node) {
     20        public ParameterListNode(ParameterListNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public ParameterListNode deepCopy() {
    22                 ParameterListNode parent = new ParameterListNode(this.getToken());
     26                ParameterListNode parent = new ParameterListNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/ParameterNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class ParameterNode extends ASTNode  {
    13        
     15
     16
    1417        public ParameterNode(Token token) {
    1518                super(token);
    1619        }
    17         public ParameterNode(ASTNode node) {
     20        public ParameterNode(ParameterNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public ParameterNode deepCopy() {
    22                 ParameterNode parent = new ParameterNode(this.getToken());
     26                ParameterNode parent = new ParameterNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/ProgramNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class ProgramNode extends ASTNode  {
    13        
     15
     16
    1417        public ProgramNode(Token token) {
    1518                super(token);
    1619        }
    17         public ProgramNode(ASTNode node) {
     20        public ProgramNode(ProgramNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public ProgramNode deepCopy() {
    22                 ProgramNode parent = new ProgramNode(this.getToken());
     26                ProgramNode parent = new ProgramNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/ReturnStmtNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class ReturnStmtNode extends ASTNode  {
    13        
     15
     16
    1417        public ReturnStmtNode(Token token) {
    1518                super(token);
    1619        }
    17         public ReturnStmtNode(ASTNode node) {
     20        public ReturnStmtNode(ReturnStmtNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public ReturnStmtNode deepCopy() {
    22                 ReturnStmtNode parent = new ReturnStmtNode(this.getToken());
     26                ReturnStmtNode parent = new ReturnStmtNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r3001 r3004  
    4141        public void visit(IdentifierNode node);
    4242
    43         public void visit(IdisaCallArgListNode node);
    44 
    45         public void visit(IdisaCallNode node);
     43        public void visit(IdisaFuncCallNode node);
    4644
    4745        public void visit(IfStmtNode node);
     
    160158                }
    161159
    162                 public void visit(IdisaCallArgListNode node) {
    163                         defaultVisit(node);
    164                 }
    165 
    166                 public void visit(IdisaCallNode node) {
     160                public void visit(IdisaFuncCallNode node) {
    167161                        defaultVisit(node);
    168162                }
  • proto/pabloj/trunk/src/pabloB/ast/StateIdentifierNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StateIdentifierNode extends ASTNode  {
    13        
     15
     16
    1417        public StateIdentifierNode(Token token) {
    1518                super(token);
    1619        }
    17         public StateIdentifierNode(ASTNode node) {
     20        public StateIdentifierNode(StateIdentifierNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public StateIdentifierNode deepCopy() {
    22                 StateIdentifierNode parent = new StateIdentifierNode(this.getToken());
     26                StateIdentifierNode parent = new StateIdentifierNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/StateInitListNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StateInitListNode extends ASTNode  {
    13        
     15
     16
    1417        public StateInitListNode(Token token) {
    1518                super(token);
    1619        }
    17         public StateInitListNode(ASTNode node) {
     20        public StateInitListNode(StateInitListNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public StateInitListNode deepCopy() {
    22                 StateInitListNode parent = new StateInitListNode(this.getToken());
     26                StateInitListNode parent = new StateInitListNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/StateInitStmtNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StateInitStmtNode extends ASTNode  {
    13        
     15
     16
    1417        public StateInitStmtNode(Token token) {
    1518                super(token);
    1619        }
    17         public StateInitStmtNode(ASTNode node) {
     20        public StateInitStmtNode(StateInitStmtNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public StateInitStmtNode deepCopy() {
    22                 StateInitStmtNode parent = new StateInitStmtNode(this.getToken());
     26                StateInitStmtNode parent = new StateInitStmtNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/StateSizeNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StateSizeNode extends ASTNode  {
    13        
     15
     16
    1417        public StateSizeNode(Token token) {
    1518                super(token);
    1619        }
    17         public StateSizeNode(ASTNode node) {
     20        public StateSizeNode(StateSizeNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public StateSizeNode deepCopy() {
    22                 StateSizeNode parent = new StateSizeNode(this.getToken());
     26                StateSizeNode parent = new StateSizeNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/StateValueNode.java

    r2917 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StateValueNode extends ASTNode  {
    13        
     15
     16
    1417        public StateValueNode(Token token) {
    1518                super(token);
    1619        }
    17         public StateValueNode(ASTNode node) {
     20        public StateValueNode(StateValueNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public StateValueNode deepCopy() {
    22                 StateValueNode parent = new StateValueNode(this.getToken());
     26                StateValueNode parent = new StateValueNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/StreamConstantNode.java

    r2981 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StreamConstantNode extends ASTNode implements IntValuedNodeType {
    13        
     15        private int value = 0;
     16
     17
    1418        public StreamConstantNode(Token token) {
    1519                super(token);
    1620        }
    17         public StreamConstantNode(ASTNode node) {
     21        public StreamConstantNode(StreamConstantNode node) {
    1822                super(node);
     23                this.value = node.value;
     24
    1925        }
    2026       
    2127        public StreamConstantNode deepCopy() {
    22                 StreamConstantNode parent = new StreamConstantNode(this.getToken());
     28                StreamConstantNode parent = new StreamConstantNode(this);
    2329               
    2430                for(ASTNode child: this.getChildren()) {
     
    3238       
    3339        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     40        // attribute accessors
    3541
    36         private int value = 0;
    37        
    3842        public int getValue() {
    3943                return value;
     
    5054        @Override
    5155        public String attributeString() {
    52                 String result = "";
     56                String result = super.attributeString();
     57                if(!result.isEmpty()) {
     58                        result += ", ";
     59                }
    5360                result += "value = " + value + ", ";
    5461
  • proto/pabloj/trunk/src/pabloB/ast/StreamTypeNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StreamTypeNode extends ASTNode  {
    13        
     15
     16
    1417        public StreamTypeNode(Token token) {
    1518                super(token);
    1619        }
    17         public StreamTypeNode(ASTNode node) {
     20        public StreamTypeNode(StreamTypeNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public StreamTypeNode deepCopy() {
    22                 StreamTypeNode parent = new StreamTypeNode(this.getToken());
     26                StreamTypeNode parent = new StreamTypeNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740
    3841       
     
    4245        @Override
    4346        public String attributeString() {
    44                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    4551
    4652                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloB/ast/StringConstantNode.java

    r2834 r3004  
    1010import java.util.List;
    1111
     12
     13
    1214public class StringConstantNode extends ASTNode  {
    13        
     15
     16
    1417        public StringConstantNode(Token token) {
    1518                super(token);
    1619        }
    17         public StringConstantNode(ASTNode node) {
     20        public StringConstantNode(StringConstantNode node) {
    1821                super(node);
     22
    1923        }
    2024       
    2125        public StringConstantNode deepCopy() {
    22                 StringConstantNode parent = new StringConstantNode(this.getToken());
     26                StringConstantNode parent = new StringConstantNode(this);
    2327               
    2428                for(ASTNode child: this.getChildren()) {
     
    3236       
    3337        ////////////////////////////////////////////////////////////
    34         // attributes and their accessors
     38        // attribute accessors
    3539
    36        
    3740