Changeset 2809


Ignore:
Timestamp:
Jan 17, 2013, 6:19:47 PM (6 years ago)
Author:
ksherdy
Message:

Added state support. Additional work required. Added carry_flip support.

Location:
proto/pablo
Files:
6 added
34 edited

Legend:

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

    r2804 r2809  
    3232        STRUCT,
    3333        VOID,
    34        
     34        INIT,
     35               
    3536        IF,
    3637        ELSE,
     
    5253        LROUND          "(",
    5354        RROUND          ")",
     55       
     56        LSQUARE         "[",
     57        RSQUARE         "]",
     58       
    5459        COMMA           ",",
    5560        TERMINATOR  ";",
     
    7378
    7479grammar {
    75         program         -> (typeDecl | kernelDef) *;
     80        program         -> (typeDecl | kernelDef) * ;
    7681
    7782        //
     
    9499        // s t r e a m   s t r u c t   d e c l a r a t i o n s                                                 
    95100        //
    96         kernelDef                       ->      KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
     101        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? RCURLY TERMINATOR? ;
    97102       
    98103        kernelName                      #-> identifier ;
    99104       
    100         funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR?;
     105        // s t a t e   i n i t
     106        //
     107        initDef                         ->  INIT initBlock TERMINATOR? ;
     108       
     109        initBlock                       #-> LCURLY stateInitStmt* RCURLY;
     110       
     111        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR? ;
     112       
     113        stateIdentifier         ->  IDENTIFIER ;
     114               
     115        stateSize                       ->  integerConstant ;
     116       
     117        //stateInitList         ->      integerConstant (COMMA integerConstant)* ;
     118       
     119        stateInitList           ->      streamType (COMMA streamType)* ;
     120       
     121        // k e r n e l   f u n c t i o n s
     122        //
     123        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
    101124       
    102125        returnType                      #-> type ;      // Note: Strictly not required.
    103126       
    104         parameterList           ->      parameter (COMMA parameter)*;
     127        parameterList           ->      parameter (COMMA parameter)* ;
    105128                                                                                                               
    106129        funcName                        #-> identifier ;
     
    113136       
    114137        optFuncDef                      #-> funcDef ;
    115                                
    116         // kernel state         // kernelState -> '[' ']'
    117        
    118         //
    119         // f u n c t i o n - l e v e l 
    120         //
    121        
     138 
     139               
    122140        //
    123141        // s t a t e m e n t s
     
    139157        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
    140158                       
    141         returnStmt                              -> RETURN (expr)? TERMINATOR;
     159        returnStmt                              -> RETURN (expr)? TERMINATOR ;
    142160                       
    143         localVarDecl                    -> VAR type VarName (assignOperator^! expr) ?;
    144                
    145         VarName                                 #-> identifier;
     161        localVarDecl                    -> VAR type VarName (assignOperator^! expr) ? ;
     162               
     163        VarName                                 #-> identifier ;
    146164
    147165        blockStmt                               -> LCURLY stmt* RCURLY ;
     
    166184                                            | integerConstant ;
    167185                                           
    168         integerConstant                 -> INTEGER_CONST {@value = @@value;} ; // map to a 32 bit integer
     186        integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
    169187       
    170188        stringConstant                  -> STRING | SQ_STRING ;
    171189       
    172         compoundIdentifier              #-> identifier (DOT^ identifier)*;
     190        compoundIdentifier              #-> identifier (DOT^ identifier)* ;
    173191                                                       
    174192        identifier                              -> IDENTIFIER ;
     
    178196        //
    179197
     198        //
    180199        // p r i m i t i v e s
    181200        //
    182         // s t r e a m
    183201
    184202        type                    #->  streamType | structType | void | identifier ; // | tupleType;
     
    186204        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
    187205                                       
    188         fieldWidth              ->  INTEGER_CONST ;     
     206        fieldWidth              ->  integerConstant ;   
    189207       
    190208        streamTypeName  #->     identifier ;                           
    191209               
     210        //     
     211        // c o m p o s i t e s
     212        //     
    192213        // s t r u c t 
    193214               
  • proto/pablo/input/grammar/scatter/pabloS.scatter

    r2804 r2809  
    187187        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
    188188                                       
    189         fieldWidth              ->  INTEGER_CONST ;     
     189        fieldWidth              ->  integerConstant ;   
    190190       
    191191        streamTypeName  #->     identifier ;                           
  • proto/pablo/input/test/pabloB/kernelDef/kernelDel1.pablob

    r2766 r2809  
    33kernel BasisBits
    44{
     5        init
     6        {
     7                carry1[1] = {0};
     8                carryN[1] = {1};
     9        }
    510
    611        function void do_block ()
    712        {
    8        
     13                a.a = call();
    914        }
    1015
     
    1520
    1621}       
    17        
  • proto/pablo/notes

    r2804 r2809  
     1Pablo vs. PabloJ Implementation Differences
     2
     3(1) Explicit local variable declarations with explicit types.
     4
     5e.g. bitblock s; s = simd::constant<1>(0);
     6
     7(2) Current PabloB grammar does not support boolean OR.
     8
     9Work around. Added PabloJCarryTest runtime check that returns a type BitBlock.
     10Wrapped 'if' / 'while' conditions within bitblock::any() IDISA call.
     11
     12(3) TODO - Avoid carry object creation in Kernel w/o carries.
     13
     14(4) BitBlock EOF_mask --> const BitBlock mask
     15
     16(5) 
     17
     18PabloB - PabloB language implementation / design
     19
     20(1) 'static' initialization section vs. 'kernel' constructor
     21
     22(2) integer types uint8, uint16, uint32, uint64, uint128, uint256
     23  - if integer types are restricted 'sections' of stream then no apparent need exists for signed integers
     24
     25C++ Code Generation Strategy
     26
     27(1) sythetic variable, scope, identifiers, tree compression, etc...
     28
    129PabloJ - Pablo language implementation.
    230
  • proto/pablo/output/cpplang/pablo_definitions.hpp

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

    r2804 r2809  
    99
    1010import compiler.codeGenerator.visitors.CPPUnparser;
     11
    1112import compiler.codeGenerator.visitors.Unparser;
    1213import compiler.lang.pabloS.*;
     
    8788               
    8889                // PabloS to PabloB transformation
    89                 PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(symbolTable);
     90                PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(symbolTable, carrySet2Lang);
    9091                pabloB.ast.ASTNode pabloBASTTree = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    9192               
  • proto/pablo/src/applicationGenerator/templates/CPP/pablo_definitions.template

    r2804 r2809  
    1313#define PABLO_DEFINITIONS_HPP
    1414
     15// Stream struct and function headers and definitions
     16
     17#include "../lib/simd-lib/bitblock.hpp"
     18#include "../lib/simd-lib/carryQ.hpp"
     19#include "../lib/simd-lib/pabloSupport.hpp"
     20
    1521#define LocalCarryDeclare(name, count)\
    1622CarryArray<count, 0> name;\
     
    1824#define assert_0_error(errkind, errstrm)
    1925
    20 #include <pablo/simd-lib/carryQ.hpp>
    21 #include <pablo/simd-lib/bitblock.hpp>
     26BitBlock EOF_mask = simd<1>::constant<1>();
    2227
    23 BitBlock EOF_mask = simd<1>::constant<1>();
     28// XMLWF application headers and definitions
     29/*
     30#include <stdio.h>
     31#include <stdlib.h>
     32#include <errno.h>
     33#include <sys/types.h>
     34#include <sys/stat.h>
     35
     36#include "../lib/simd-lib/s2p.hpp"
     37#include "../lib/simd-lib/buffer.hpp"
     38#include "../lib/simd-lib/bitblock_iterator.hpp"
     39#include "../lib/simd-lib/perflib/perfsec.h"
     40
     41#include <xmldecl.h>
     42#include <namechars.h>
     43#include <LineColTracker.hpp>
     44#include <XMLTestSuiteError.h>
     45
     46// Define the mappings for pablo.assert_0(strm, errkind) statements which
     47// compile to the the form assert_0_error(errkind, strm)
     48#include <ErrorTracker.h>
     49
     50ErrorTracker error_tracker;
     51#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
     52*/
    2453
    2554// namespace pablo
    2655// {
    27 
    2856###@global ###
    29 
    3057// } // pablo namespace
    3158
  • proto/pablo/src/compiler/ast/pabloB/Accessors.java

    r2796 r2809  
    5050        ////////////////////////////////////////////////////////////////////////////
    5151       
     52        ////////////////////////////////////////////////////////////////////////////
     53        // Initialization
     54        ////////////////////////////////////////////////////////////////////////////           
     55        public static String integerConstantLexeme(StateSizeNode node) {
     56                return node.child(0).getToken().getLexeme();
     57        }                               
     58       
     59        ////////////////////////////////////////////////////////////////////////////
     60        // Functions
     61        ////////////////////////////////////////////////////////////////////////////                   
    5262        public static FuncDefNode funcDefNode(KernelDefNode node) {
    5363                return (FuncDefNode) node.child(1);
     
    6878        public static String kernelName(KernelDefNode node) {
    6979                return Accessors.name(node.child(0));
     80        }
     81
     82        ////////////////////////////////////////////////////////////////////////////
     83        // Function Definition helpers
     84        ////////////////////////////////////////////////////////////////////////////
     85        public static InitBlockNode initBlockNode(InitDefNode node) {
     86                return (InitBlockNode) node.child(0);
    7087        }
    7188       
     
    117134        }               
    118135       
    119         public static String assignOperator(LocalVarDeclNode node) {
     136        public static String assignOperatorLexeme(LocalVarDeclNode node) {
    120137                return node.getToken().getLexeme();
    121138        }       
     
    140157        }       
    141158
    142         public static String assignOperator(AssignNode node) {
     159        public static String assignOperatorLexeme(AssignNode node) {
    143160                return node.getToken().getLexeme();
    144161        }
     
    147164        // Integer Constant
    148165        ////////////////////////////////////////////////////////////////////////////           
    149         public static String integerConstant(IntegerConstantNode node) {
     166        public static String integerConstantLexeme(IntegerConstantNode node) {
    150167                return node.getToken().getLexeme();
    151168        }                       
     
    154171        // String Constant
    155172        ////////////////////////////////////////////////////////////////////////////           
    156         public static String stringConstant(StringConstantNode node) {
     173        public static String stringConstantLexeme(StringConstantNode node) {
    157174                return node.getToken().getLexeme();
    158175        }               
     
    184201                return node.getToken().getLexeme();
    185202        }
     203
     204        public static String stateName(ASTNode node) {
     205                assert node instanceof StateIdentifierNode;
     206                return node.getToken().getLexeme();
     207        }
    186208       
    187209        ////////////////////////////////////////////////////////////////////////////
     
    192214        }
    193215
    194         public static String operator(UnaryOperatorNode node) {
     216        public static String operatorLexeme(UnaryOperatorNode node) {
    195217                return node.getToken().getLexeme();
    196218        }
     
    207229        }
    208230       
    209         public static String operator(BinaryOperatorNode node) {
     231        public static String operatorLexeme(BinaryOperatorNode node) {
    210232                return node.getToken().getLexeme();
    211233        }               
     
    246268        // Stream Type helpers
    247269        ////////////////////////////////////////////////////////////////////////////
    248         public static String fieldWidthValue(FieldWidthNode node) {             
    249                 return node.getToken().getLexeme();
     270        public static String fieldWidthLexeme(FieldWidthNode node) {           
     271                return node.child(0).getToken().getLexeme();
    250272        }       
    251273
     
    253275        // Void Type
    254276        ////////////////////////////////////////////////////////////////////////////   
    255         public static String voidValue(VoidNode node) {         
    256                 return node.getToken().getLexeme();
     277        public static String voidLexeme(VoidNode node) {               
     278                return node.getToken().getLexeme();
     279        }       
     280       
     281        ////////////////////////////////////////////////////////////////////////////
     282        // FuncCallNode helpers
     283        ////////////////////////////////////////////////////////////////////////////
     284        public static ASTNode funcCallIdentifier(FuncCallNode node) {
     285                return node.child(0);
     286        }
     287
     288        public static ASTNode funcCallArgsListNode(FuncCallNode node) {
     289                return node.child(1);
    257290        }       
    258291
  • proto/pablo/src/compiler/ast/pabloB/Generators.java

    r2767 r2809  
    11package compiler.ast.pabloB;
    22
     3import java.util.ArrayList;
     4import java.util.List;
     5
     6import compiler.ast.pabloB.Accessors;
     7
     8
    39import pabloB.ast.*;
    4 import pabloB.lexicalAnalyzer.*;
     10//import pabloB.lexicalAnalyzer.*;
     11import pabloB.tokens.IntConstantToken;
    512import pabloB.tokens.LextantToken;
    613import pabloB.tokens.Token;
     
    815import pabloB.lexicalAnalyzer.LexicalType;
    916import pabloB.tokens.IdentifierToken;
     17import pabloB.ast.ASTNode;
     18import pabloB.ast.CompoundIdentifierNode;
     19import pabloB.ast.FuncCallArgListNode;
     20import pabloB.ast.FuncCallNode;
     21import pabloB.lexicalAnalyzer.Lextant;
    1022
    1123public class Generators {
     
    2638                return new IdentifierNode(newToken);
    2739        }       
     40
     41        private static Token makeIntegerConstantToken(int n,
     42                        Token locationToken) {
     43                return  IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
     44        }               
     45       
     46        public static IntegerConstantNode makeIntegerConstantNode(int n, Token locationToken) {
     47                IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(n,
     48                                locationToken));
     49                integerConstantNode.setValue(n);
     50            return integerConstantNode;
     51        }
    2852       
    2953        public static LextantToken makeLextantToken(Lextant lextant, Token locationToken) {
     
    3155        }       
    3256               
    33         public static KernelDefNode makeKernelDef(String identifier,
     57        public static InitDefNode makeInitDefNode (Token locationToken) {
     58               
     59                LextantToken initDefToken = Generators.makeLextantToken(Lextant.KERNEL, locationToken);
     60                InitDefNode initDefNode = new InitDefNode(initDefToken);
     61               
     62                LextantToken initBlockToken = Generators.makeLextantToken(Lextant.LCURLY, locationToken);;
     63                InitBlockNode initBlockNode = new InitBlockNode(initBlockToken);
     64               
     65                initDefNode.appendChild(initBlockNode);
     66               
     67                return initDefNode;
     68        }
     69
     70        public static StateIdentifierNode makeStateIdentifierNode(String identifier, Token locationToken) {
     71                IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
     72                return new StateIdentifierNode(newToken);
     73        }               
     74       
     75        public static StateInitStmtNode makeStateInitStmtNode(String identifier, Integer [] values, Token locationToken) {
     76               
     77                StateIdentifierNode identifierNode = Generators.makeStateIdentifierNode(identifier, locationToken);
     78                IntegerConstantNode stateSize = Generators.makeIntegerConstantNode(values.length, locationToken);
     79               
     80                StateInitListNode stateInitListNode = new StateInitListNode(Generators.makeIntegerConstantToken(values[0].intValue(), locationToken));
     81                IntegerConstantNode n0 = Generators.makeIntegerConstantNode(values[0].intValue(), locationToken);
     82                stateInitListNode.appendChild(n0);
     83               
     84                for(int i = 1; i < values.length; i++) {
     85                        IntegerConstantNode n = Generators.makeIntegerConstantNode(values[i].intValue(), locationToken);
     86                        stateInitListNode.appendChild(n);
     87                }
     88                               
     89                StateInitStmtNode initStmtNode = new StateInitStmtNode(identifierNode.getToken());
     90               
     91                initStmtNode.appendChild(identifierNode);
     92                initStmtNode.appendChild(stateSize);
     93                initStmtNode.appendChild(stateInitListNode);
     94               
     95                return initStmtNode;
     96               
     97        }
     98       
     99        public static KernelDefNode makeKernelDef(String identifier,
     100                                                                                                InitDefNode initDefNode,
    34101                                                                                                FuncDefNode funcDefNode,
    35102                                                                                                FuncDefNode optFuncDefNode,
     
    41108               
    42109                kernelDefNode.appendChild(identifierNode);
     110                kernelDefNode.appendChild(initDefNode);
    43111                kernelDefNode.appendChild(funcDefNode.deepCopy());
    44112                kernelDefNode.appendChild(optFuncDefNode.deepCopy());
     
    131199        }
    132200       
     201        private static void addFuncCallsArgs(FuncCallNode node, List<ASTNode> args) {
     202               
     203                if(args.size() > 0) {
     204                        for(ASTNode child: args) {
     205                                Accessors.funcCallArgsListNode(node).appendChild(child);
     206                        }
     207                        Accessors.funcCallArgsListNode(node).setToken(args.get(0).getToken());
     208                }               
     209        }
     210
     211        public static FuncCallNode makeFuncCallNode(CompoundIdentifierNode compoundIdentifierNode, Token locationToken, ASTNode[] args) {
     212
     213                FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locationToken);
     214                List<ASTNode> list = new ArrayList<ASTNode>();
     215                for(ASTNode arg: args) {
     216                        list.add(arg);
     217                }
     218                Generators.addFuncCallsArgs(node, list);               
     219                return node;
     220        }
     221       
     222        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode[] args) {
     223       
     224                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     225                List<ASTNode> list = new ArrayList<ASTNode>();
     226                for(ASTNode arg: args) {
     227                        list.add(arg);
     228                }
     229                Generators.addFuncCallsArgs(node, list);
     230                return node;
     231        }
     232       
     233        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
     234               
     235                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
     236                return Generators.makeFuncCallNode(identifierNode, locationToken);
     237        }
     238       
     239        public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Token locationToken) {
     240                Token dotToken = Generators.makeLextantToken(Lextant.DOT, locationToken);
     241                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
     242                for (String identifier : identifiers) {
     243                        IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);
     244                        CompoundIdentifierNode.appendChild(identifierNode);
     245                }
     246                return CompoundIdentifierNode;
     247        }
     248       
     249        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
     250                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
     251
     252                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
     253                FuncCallNode FuncCallNode = new FuncCallNode(token);
     254                FuncCallNode.appendChild(identifier);
     255                FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
     256
     257                return FuncCallNode;
     258        }               
     259       
     260        public static AssignNode makeAssignEqualNode(String [] identifiers, ASTNode rhs, Token locationToken) {
     261               
     262                Token assignEqualToken = Generators.makeLextantToken(Lextant.ASSIGN, locationToken);
     263                AssignNode assignEqualNode = new AssignNode(assignEqualToken);
     264               
     265                CompoundIdentifierNode lhs = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
     266               
     267                assignEqualNode.appendChild(lhs);
     268                assignEqualNode.appendChild(rhs);
     269               
     270                return assignEqualNode;
     271        }
     272       
    133273}
  • proto/pablo/src/compiler/ast/pabloS/Accessors.java

    r2804 r2809  
    8383        }       
    8484
    85         public static String assignOperator(AssignNode node) {
     85        public static String assignOperatorLexeme(AssignNode node) {
    8686                return node.getToken().getLexeme();
    8787        }
     
    9191        ////////////////////////////////////////////////////////////////////////////                           
    9292
    93         public static String assignOperator(FuncCallNode node) {
     93        public static String assignOperatorLexeme(FuncCallNode node) {
    9494                return node.getToken().getLexeme();
    9595        }       
     
    108108        }               
    109109       
    110         public static String assignOperator(LocalVarDeclNode node) {
     110        public static String assignOperatorLexeme(LocalVarDeclNode node) {
    111111                return node.getToken().getLexeme();
    112112        }       
     
    127127        }
    128128
    129         public static String operator(UnaryOperatorNode node) {
     129        public static String operatorLexeme(UnaryOperatorNode node) {
    130130                return node.getToken().getLexeme();
    131131        }
     
    142142        }
    143143       
    144         public static String operator(BinaryOperatorNode node) {
     144        public static String operatorLexeme(BinaryOperatorNode node) {
    145145                return node.getToken().getLexeme();
    146146        }               
     
    149149        // Integer Constant
    150150        ////////////////////////////////////////////////////////////////////////////           
    151         public static String integerConstant(IntegerConstantNode node) {
     151        public static String integerConstantLexeme(IntegerConstantNode node) {
    152152                return node.getToken().getLexeme();
    153153        }                       
     
    156156        // String Constant
    157157        ////////////////////////////////////////////////////////////////////////////           
    158         public static String stringConstant(StringConstantNode node) {
     158        public static String stringConstantLexeme(StringConstantNode node) {
    159159                return node.getToken().getLexeme();
    160160        }                       
     
    339339        // Stream Type helpers
    340340        ////////////////////////////////////////////////////////////////////////////
    341         public static String fieldWidthValue(FieldWidthNode node) {             
     341        public static String fieldWidthLexeme(FieldWidthNode node) {           
    342342                return node.getToken().getLexeme();
    343343        }       
     
    346346        // Void Type
    347347        ////////////////////////////////////////////////////////////////////////////   
    348         public static String voidValue(VoidNode node) {         
     348        public static String voidValueLexeme(VoidNode node) {           
    349349                return node.getToken().getLexeme();
    350350        }       
  • proto/pablo/src/compiler/ast/pabloS/Generators.java

    r2804 r2809  
    260260        }
    261261       
     262        /*
    262263        public static void appendEOFMaskParameter(FuncDefNode node, Builtins2Lang builtins2Lang) {
    263264               
     
    265266                        // parameter list
    266267                }
    267                
    268268                // append
    269                
    270         }
     269        }
     270        */
    271271       
    272272        // Helper
  • proto/pablo/src/compiler/codeGenerator/helpers/CodeFragments.java

    r2775 r2809  
    44import compiler.lang.pabloS.Builtins2Lang;
    55import compiler.transformer.visitors.*;
    6 
    7 import pabloS.ast.*;
    86
    97public class CodeFragments {
  • proto/pablo/src/compiler/codeGenerator/helpers/CodeStore.java

    r2775 r2809  
    2121        private String resultVarName = "codeStoreNoVar";
    2222
     23        public void prepentToFirst(String line) {
     24                if (code.isEmpty()) {
     25                        addLine(line);
     26                } else {
     27                        CodeLine codeLine = code.get(0);
     28                        codeLine.line = line + codeLine.line;
     29                }
     30        }       
     31       
    2332        public void appendToLast(String line) {
    2433                if (code.isEmpty()) {
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2804 r2809  
     1//
     2// Transforms PabloB AST to C++ code.
     3//
     4 
    15package compiler.codeGenerator.visitors;
    26
     
    913import compiler.codeGenerator.helpers.CodeStore;
    1014import compiler.codeGenerator.helpers.UnparserUtil;
    11 import compiler.lang.carry.CarrySetBuiltins;
    1215import compiler.lang.carry.CarrySetBuiltins2CPP;
    1316import compiler.symbols.CarryInfoSetSymbol;
    1417import compiler.symbols.SymbolTable;
    1518
    16 //
    17 // Transforms PabloB AST to C++ code.
    18 //
    19 
    20 // CPP stream struct target.
     19// CPP stream struct target
    2120/*
    2221struct $name
     
    2625*/
    2726 
    28 // CPP stream function target.
     27// CPP stream function target
    2928/*             
    3029struct $name
    3130{
    32   @name() {}
     31  $name() {
     32    ...
     33  };   
     34
    3335  IDISA_INLINE $ReturnType do_block($parameters)
    3436  {
     
    4345*/
    4446
     47
    4548public class CPPUnparser extends Unparser {
    4649
    4750        private CarrySetBuiltins2CPP carrySetBuiltins2CPP;
     51       
     52        // synthetic attributes
     53        private String stateIdentifier = null;
    4854       
    4955        //////////////////////////////////////////////////////////////
     
    7581       
    7682        @SuppressWarnings("static-access")
     83       
    7784        public CodeStore visitLeave(KernelDefNode node, List<CodeStore> childResults) {
    7885                CodeStore code = new CodeStore();
     
    8087                String kernelName = childResults.get(0).getResultVarName();
    8188               
    82                 CodeStore funcDefCodeStore = childResults.get(1);
    83                
     89                CodeStore initDef = childResults.get(1);
     90               
     91                CodeStore funcDefCodeStore = childResults.get(2);
     92               
     93                code.addFormattedLine("struct %s ", kernelName);
     94                code.addLine("{");
     95               
     96                code.indentedFormattedLine("%s()", kernelName);
     97                code.addAll(initDef, 0);
     98               
     99                funcDefCodeStore.prepentToFirst("IDISA_INLINE ");
     100               
     101                code.addAll(funcDefCodeStore, 0);
     102               
     103                if(Accessors.hasOptFuncDef(node)) {
     104                        CodeStore optFuncDefCodeStore = childResults.get(3);
     105                        code.addAll(optFuncDefCodeStore, 0);
     106                }
     107               
     108                String formatString = new String();
     109               
     110                // TODO -       Kludgy. Fix. See 'notes'.
    84111                CarryInfoSetSymbol carryInfoSet = (CarryInfoSetSymbol) symbolTable.get(kernelName);
    85                
    86                 code.addFormattedLine("struct %s ", kernelName);
    87                 code.addLine("{");
    88                
    89                 code.addAll(funcDefCodeStore, 1);
    90                
    91                 if(Accessors.hasOptFuncDef(node)) {
    92                         CodeStore optFuncDefCodeStore = childResults.get(2);
    93                         code.addAll(optFuncDefCodeStore, 0);
    94                 }
    95                
    96                 String formatString = new String();
    97                
    98                 // TODO -       Kludgy approach. See 'notes'.
     112                int carry1Count = carryInfoSet.getCarry1Count();
     113                int carryNCount = carryInfoSet.getCarryNCount();
     114                if( carry1Count > 0 || carryNCount > 0 )
     115                {
    99116                formatString = carrySetBuiltins2CPP.CARRYSETDECLAREFORMATSTRING;
    100117                formatString += ";";
    101                 code.addFormattedLine(formatString, carryInfoSet.getCarryCount(), carryInfoSet.getAdvanceNCount(), carrySetBuiltins2CPP.CARRYQIDENTIFIER);
     118                code.addFormattedLine(formatString,
     119                                carry1Count,
     120                                carryNCount,
     121                                carrySetBuiltins2CPP.CARRYQNAME);
     122               
     123                }
    102124               
    103125                code.dedentedLine("};");
     126               
     127                code.addLine(" "); // a blank line
    104128                       
    105129                return code;
    106130        }
     131
     132        ////////////////////////////////////////////////////////////////////////////
     133        // Kernel Initialization
     134        ////////////////////////////////////////////////////////////////////////////
     135        public CodeStore visitLeave(InitDefNode node, List<CodeStore> childResults) {
     136                CodeStore code = new CodeStore();
     137               
     138                // add strings // visit enter is needed here
     139               
     140                CodeStore initBlockCodeStore = childResults.get(0);
     141               
     142                code.addLine("{");
     143                code.addAll(initBlockCodeStore, 1);
     144                code.dedentedLine("};");               
     145               
     146                code.addLine(" "); // a blank line
     147               
     148                return code;
     149        }       
     150
     151        public CodeStore visitLeave(InitBlockNode node, List<CodeStore> childResults) {
     152                CodeStore code = new CodeStore();
     153               
     154                // add strings
     155                if (childResults.isEmpty()) {
     156                        code.addLine(""); // empty if / while
     157                }
     158               
     159                for (CodeStore child: childResults) {
     160                        code.addAll(child, 0);
     161                }               
     162               
     163                return code;
     164        }
     165       
     166        public CodeStore visitLeave(StateIdentifierNode node, List<CodeStore> childResults) {           
     167                // synthetic attribute
     168                stateIdentifier = Accessors.stateName(node);
     169               
     170                CodeStore code = new CodeStore();
     171                code.setResultVarName(stateIdentifier);         
     172                return code;
     173        }
     174       
     175        public CodeStore visitLeave(StateInitStmtNode node, List<CodeStore> childResults) {
     176               
     177                CodeStore code = new CodeStore();
     178               
     179                String st = childResults.get(0).getResultVarName();
     180               
     181                String stateSize = childResults.get(1).getResultVarName();
     182                CodeStore stateInitListCodeStore = childResults.get(2);
     183
     184                /*
     185                code.addFormattedLine("for(int i=0; i<%s; i++)", stateSize);
     186                code.addLine("{");
     187                code.addAll(stateInitListCodeStore, 0);
     188                code.dedentedLine("}");
     189                code.addLine("");
     190                */
     191                               
     192                return code;
     193        }       
     194       
     195        public CodeStore visitLeave(StateInitListNode node, List<CodeStore> childResults) {
     196               
     197                CodeStore code = new CodeStore();
     198               
     199                /*
     200                for(int i=0; i<childResults.size(); i++) {
     201                        code.addFormattedLine("%s[%s]=%s;", stateIdentifier, Integer.toString(i), childResults.get(i).getResultVarName(), 0);
     202                }
     203                */
     204               
     205                return code;
     206        }
     207       
     208        public CodeStore visitLeave(StateSizeNode node, List<CodeStore> childResults) {
     209                CodeStore code = new CodeStore();
     210                code.setResultVarName(Accessors.integerConstantLexeme(node));
     211                return code;
     212        }       
    107213       
    108214        ////////////////////////////////////////////////////////////////////////////
     
    125231                }
    126232               
    127                 code.addFormattedLine("IDISA_INLINE %s %s(%s)", returnType, funcName, parameters);
     233                code.addFormattedLine("%s %s(%s)", returnType, funcName, parameters);
    128234                code.addLine("{");
    129235                code.addAll(blockStmtCodeStore, 1);
    130236                code.dedentedLine("}");
     237                code.addLine("");
    131238                               
    132239                return code;
     
    161268                CodeStore rhs = childResults.get(1);
    162269                code.addFormattedLine("%s %s %s;", lhs.getResultVarName()
    163                                                                                  , Accessors.assignOperator(node)
     270                                                                                 , Accessors.assignOperatorLexeme(node)
    164271                                                                                 , rhs.getResultVarName());
    165272               
     
    195302        public CodeStore visitLeave(IfStmtNode node, List<CodeStore> childResults) {
    196303                CodeStore code = new CodeStore();
    197                 CodeStore ifTest                        = childResults.get(0);
     304                CodeStore ifTest                = childResults.get(0);
    198305                CodeStore ifBlockStmt   = childResults.get(1);
    199306                code.addFormattedLine("if (%s)", ifTest.getResultVarName());
     
    246353                                                                type.getResultVarName(),
    247354                                                                identifier.getResultVarName(),
    248                                                                 Accessors.assignOperator(node),
     355                                                                Accessors.assignOperatorLexeme(node),
    249356                                                                expression.getResultVarName());
    250357                } else {
     
    299406               
    300407                resultVar.append(" ");
    301                 resultVar.append(Accessors.operator(node));
     408                resultVar.append(Accessors.operatorLexeme(node));
    302409                resultVar.append(" ");
    303410               
     
    321428                       
    322429                StringBuffer resultVar = new StringBuffer();
    323                 resultVar.append(Accessors.operator(node));
     430                resultVar.append(Accessors.operatorLexeme(node));
    324431               
    325432                if(!Accessors.isTerminal(Accessors.operand(node))) {
     
    345452        public CodeStore visitLeave(StringConstantNode node, List<CodeStore> childResults) {
    346453                CodeStore code = new CodeStore();
    347                 code.setResultVarName(Accessors.stringConstant(node));
     454                code.setResultVarName(Accessors.stringConstantLexeme(node));
    348455                return code;
    349456        }       
     
    354461        public CodeStore visitLeave(IntegerConstantNode node, List<CodeStore> childResults) {
    355462                CodeStore code = new CodeStore();
    356                 code.setResultVarName(Accessors.integerConstant(node));
     463                code.setResultVarName(Accessors.integerConstantLexeme(node));
    357464                return code;
    358465        }
     
    398505                code.dedentedLine("};");
    399506
     507                code.addLine(" "); // a blank line
     508               
    400509                return code;
    401510               
     
    455564        public CodeStore visitLeave(FieldWidthNode node, List<CodeStore> childResults) {
    456565                CodeStore code = new CodeStore();
    457                 code.setResultVarName(Accessors.fieldWidthValue(node));         
     566                code.setResultVarName(Accessors.fieldWidthLexeme(node));               
    458567                return code;
    459568        }       
     
    462571        public CodeStore visitLeave(VoidNode node, List<CodeStore> childResults) {
    463572                CodeStore code = new CodeStore();
    464                 code.setResultVarName(Accessors.voidValue(node));
     573                code.setResultVarName(Accessors.voidLexeme(node));
    465574                return code;
    466575        }               
     
    475584       
    476585        // Identifiers
    477         public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) {
    478                 CodeStore code = new CodeStore();
    479                 code.setResultVarName(Accessors.name(node));
     586        public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) {                
     587                CodeStore code = new CodeStore();
     588                code.setResultVarName(Accessors.name(node));           
    480589                return code;
    481590        }
  • proto/pablo/src/compiler/codeGenerator/visitors/Unparser.java

    r2775 r2809  
     1//
     2// Description:
     3//
     4//- Objects -
     5//
     6// CodeStore            - a list of 'CodeLine' objects, a 'resultVariable'
     7// ResultVariable       - a code value (String), not a complete code line, rather a code line fragment
     8// CodeLine             - a code line (String), a complete line and with relative indent information
     9//
     10// Unparser<CodeStore> subclasses Default<CodeStore> and Default<T> implements Visitor<T>
     11//
     12//        For each ASTNode type, Unparser<CodeStore> overrides,
     13//
     14//        CodeStore visitLeave(ASTNode node, List<CodeStore> childResults);
     15//
     16//        i.e. each node's call to visitLeave takes as input the CodeStore from each of each child
     17//        as a list and returns a single CodeStore object based on visitLeave method of that node
     18//
     19//
     20// Unparser<CodeStore> provides 'getCode(ASTNode node)';
     21// 'getCode(ASTNode node)' returns the string that is translation of substree 'node'
     22//
     23//
     24// - Bottom-Up AST to Target Language String Translation -
     25//
     26// (a) Each Unparser<CodeStore> visitLeave override creates a CodeStore object 'code' and returns that object.
     27//
     28// (b) AST nodes that translate to code line fragments call 'code.setResultVarName("some-value")' to pass
     29//  information up the tree, e.g. AST terminal nodes
     30//
     31// (c) AST nodes that construct code line(s) assemble child line fragments via 'childResults.get(i).getResultVarName()'
     32//  wherein 'i' references to the CodeStore of the 'ith' child
     33//
     34//  or
     35//
     36//  append the code lines of the 'ith' child via code.addAll(childResults.get(i))
     37//
     38
    139package compiler.codeGenerator.visitors;
    2 
    340
    441import pabloB.ast.ASTNode;
     
    643import compiler.codeGenerator.helpers.CodeStore;
    744import compiler.symbols.SymbolTable;
     45
    846
    947abstract public class Unparser extends Default<CodeStore> {
  • proto/pablo/src/compiler/lang/carry/CarryInfoSet.java

    r2775 r2809  
    11package compiler.lang.carry;
     2
     3// Individual state arrays
    24
    35public class CarryInfoSet {
    46
     7        public static final String CARRY1STATENAME      = "carry1";
     8        public static final String CARRYNSTATENAME      = "carryN";
     9       
    510        private int CarryCount;
    611        private int CarryNCount;
  • proto/pablo/src/compiler/lang/carry/CarrySetBuiltins.java

    r2804 r2809  
     1// Various Carry Set 'macro' definitions - deprecated.
     2
    13package compiler.lang.carry;
    24
     
    911        CARRYQADJUST(2),
    1012        CARRYFLIP(2),
    11         CARRYDEQUEUEENQUEUE(2),
    12         VALUEOF(1);
     13        CARRYDEQUEUEENQUEUE(2);
     14        //VALUEOF(1);
    1315                       
    1416        private final int argCount;
  • proto/pablo/src/compiler/lang/carry/CarrySetBuiltins2CPP.java

    r2804 r2809  
    99       
    1010    static {
    11    
    12         CARRYSETDECLAREFORMATSTRING = "CarryArray<%s,%s> %s";
     11
     12        // Format strings
     13        CARRYSETDECLAREFORMATSTRING = "CarryArray<%s,%s> %s";
     14       
    1315       
    1416        carry2CPPCode = new HashMap<CarrySetBuiltins, String>();
    1517       
     18        // Translate to builtin calls
    1619        carry2CPPCode.put(CarrySetBuiltins.LOCALCARRYDECLARE, "LocalCarryDeclare");
    1720        carry2CPPCode.put(CarrySetBuiltins.CARRYTEST,"PabloJCarryTest");
     
    2023        carry2CPPCode.put(CarrySetBuiltins.CARRYCOMBINE,"CarryCombine");
    2124        carry2CPPCode.put(CarrySetBuiltins.CARRYQADJUST,"CarryQ_Adjust");
     25        carry2CPPCode.put(CarrySetBuiltins.CARRYDEQUEUEENQUEUE,"CarryDequeueEnqueue");
    2226        carry2CPPCode.put(CarrySetBuiltins.CARRYFLIP,"carry_flip");
    23         carry2CPPCode.put(CarrySetBuiltins.CARRYDEQUEUEENQUEUE,"CarryDequeueEnqueue");
    24         carry2CPPCode.put(CarrySetBuiltins.VALUEOF,"cq[%s]");
     27       
     28        //carry2CPPCode.put(CarrySetBuiltins.VALUEOF,"cq[%s]");
    2529       
    2630        for(CarrySetBuiltins op : CarrySetBuiltins.values()) {
  • proto/pablo/src/compiler/lang/carry/CarrySetBuiltins2Lang.java

    r2804 r2809  
    44        public abstract String getCode(CarrySetBuiltins op);
    55       
    6         public static String CARRYQIDENTIFIER = "carryQ";
    7         public static String LOCALCARRYQIDENTIFIER = "subcarryQ";
    8         public static String CARRYSETDECLAREFORMATSTRING = null;
    9 
     6        public static final String CARRYQNAME                                   = "carryQ";
     7        public static final String LOCALCARRYQNAME                              = "subcarryQ";
     8        public static final String LOCALCARRYQARRAYNAME                 = "cq";
     9        public static   String CARRYSETDECLAREFORMATSTRING                      = null;
     10       
    1011}
  • proto/pablo/src/compiler/lang/pabloS/BuiltinsUtil.java

    r2767 r2809  
    11package compiler.lang.pabloS;
     2
     3import java.util.List;
    24
    35import compiler.ast.pabloS.Accessors;
     
    79public class BuiltinsUtil {
    810   
    9     public static String BUILTIN_PACKAGE_NAME = "pablo";
     11    public static final String BUILTIN_PACKAGE_NAME = "pablo";
    1012       
    1113    public static boolean isAdvance(ASTNode node) {
     
    7779    }
    7880   
    79        
     81        public static String carryNValue(FuncCallNode node) {
     82                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     83                String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
     84                return value;
     85        }
    8086   
    8187    /** Returns true if the node represents a call to the
  • proto/pablo/src/compiler/symbols/CarryInfoSetSymbol.java

    r2775 r2809  
    11package compiler.symbols;
     2
     3import java.util.ArrayList;
    24
    35public class CarryInfoSetSymbol extends Symbol {
    46
    5         private int carryCount;
    6         private int advanceNCount;
     7        private ArrayList<Integer> carry1 = null;
     8        private ArrayList<Integer> carryN = null;
    79       
    8         public int getCarryCount() {
    9                 return carryCount;
     10        public CarryInfoSetSymbol () {
     11                carry1 = new ArrayList<Integer>();
     12                carryN = new ArrayList<Integer>();
    1013        }
    1114       
    12         public void setCarryCount(int carryCount) {
    13                 this.carryCount = carryCount;
     15        public int getCarry1Count() {
     16                return carry1.size();
    1417        }
     18
     19        public int getCarryNCount() {
     20                return carryN.size();
     21        }       
    1522       
    16         public int getAdvanceNCount() {
    17                 return advanceNCount;
     23        public void addCarry1(Integer value) {
     24                carry1.add(value);
    1825        }
    19        
    20         public void setAdvanceNCount(int advanceNCount) {
    21                 this.advanceNCount = advanceNCount;
     26
     27        public void addCarryN(Integer value) {
     28                carryN.add(value);
     29        }       
     30
     31        public Integer [] getCarry1Array() {
     32                return (Integer [])carry1.toArray(new Integer [carry1.size()]);
    2233        }
    23        
     34
     35        public Integer [] getCarryNArray() {
     36                return (Integer [])carryN.toArray(new Integer [carryN.size()]);
     37        }
     38
    2439}
  • proto/pablo/src/compiler/transformer/visitors/AssertZeroXFormer.java

    r2796 r2809  
    5050                                assert (node.getParent() instanceof BlockStmtNode);
    5151
     52                                ASTNode errorStream = Accessors.funcCallArgsListNode(node).child(0);
    5253                                ASTNode errorCode = Accessors.funcCallArgsListNode(node).child(1);
    53                                 ASTNode errorStream = Accessors.funcCallArgsListNode(node).child(0);
    5454                               
    5555                                assert errorCode instanceof StringConstantNode;
     
    6666                                                = Generators.makeFuncCallNode(builtins2Lang.getCode(Builtins.ASSERTZERO),
    6767                                                                                                                                node.getToken(),                               
    68                                                                                                                                 new ASTNode [] {errorStream.deepCopy(), errorCode.deepCopy()});
     68                                                                                                                                new ASTNode [] {errorCode.deepCopy(), errorStream.deepCopy()});
    6969                               
    7070                               
  • proto/pablo/src/compiler/transformer/visitors/CarryInfoSetVisitor.java

    r2775 r2809  
    11package compiler.transformer.visitors;
    22
    3 // Carry information set data at the stream function level. // temporary impl
     3//
     4// Populates Symbol Table with carry information set information.
     5//
     6
     7import java.util.List;
    48
    59import compiler.ast.pabloS.Accessors;
     10import compiler.lang.pabloS.Builtins;
     11import compiler.lang.pabloS.BuiltinsUtil;
    612import compiler.symbols.CarryInfoSetSymbol;
    713import compiler.symbols.SymbolTable;
     
    2329    }   
    2430       
    25         private  class Visitor extends VoidVisitor.Default {
     31        private class Visitor extends VoidVisitor.Default {
     32               
     33                String key = null;
    2634               
    2735                public void visitEnter(FuncDefNode node) {
     36                        key = Accessors.funcName(node);                 
     37                        CarryInfoSetSymbol symbol = new CarryInfoSetSymbol();
     38                        symbolTable.put(key, symbol);
     39                }       
     40               
     41                public void visitLeave(FuncCallNode node) {
    2842                       
    29                         int carryCount = (new CarryCounterVisitor(node)).count();
    30                         int advanceNCount = (new AdvanceNCounterVisitor(node)).count();
     43                        if(BuiltinsUtil.isCarryOne(node)) {
     44                                if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
     45                                        ((CarryInfoSetSymbol)symbolTable.get(key)).addCarry1(1);
     46                                } else {
     47                                        ((CarryInfoSetSymbol)symbolTable.get(key)).addCarry1(0);
     48                                }
     49                        }
    3150                       
    32                         CarryInfoSetSymbol symbol = new CarryInfoSetSymbol();
    33                         symbol.setCarryCount(carryCount);
    34                         symbol.setAdvanceNCount(advanceNCount);
    35                         symbolTable.put(Accessors.funcName(node), symbol);
     51                        if(BuiltinsUtil.isCarryN(node)) {
     52                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     53                                String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
     54                                ((CarryInfoSetSymbol)symbolTable.get(key)).addCarryN(Integer.parseInt(value));
     55                        }
    3656                       
    37                 }       
     57                }
     58
    3859        }
    3960}
  • proto/pablo/src/compiler/transformer/visitors/CarryIntroXFormer.java

    r2804 r2809  
    123123                        this.ciMode = true;                                                                                                     
    124124                        //this.coMode = coMode;
    125                         this.carrySetIdentifier = carrySet2Lang.CARRYQIDENTIFIER;       
     125                        this.carrySetIdentifier = carrySet2Lang.CARRYQNAME;     
    126126                }
    127127
     
    170170                       
    171171                        if(carryCount > 0) { 
    172                                                                
     172                               
    173173                                IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    174174                               
    175175                                @SuppressWarnings("static-access")
    176176                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    177                                                 new String [] {carrySet2Lang.CARRYQIDENTIFIER, carrySet2Lang.getCode(CarrySetBuiltins.CARRYQADJUST)},
     177                                                new String [] {carrySet2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYQADJUST)},
    178178                                                node.getToken(),
    179179                                                new ASTNode [] {carryCountNode});
     
    461461                               
    462462                                ASTNode formatValue = Accessors.funcCallArg(node, 1);
    463                                 String value = Accessors.integerConstant((IntegerConstantNode)formatValue);
     463                                String value = Accessors.integerConstantLexeme((IntegerConstantNode)formatValue);
    464464                               
    465465                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     
    611611                        IntegerConstantNode carryCountNode      =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    612612                       
    613                         StringConstantNode localCarryName       = Generators.makeStringConstantNode(CarrySetBuiltins2Lang.LOCALCARRYQIDENTIFIER, node.getToken());
     613                        StringConstantNode localCarryId                         
     614                                        = Generators.makeStringConstantNode(CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME, node.getToken());
     615                       
     616                        StringConstantNode localCarryQArrayQName       
     617                                        = Generators.makeStringConstantNode(CarrySetBuiltins2Lang.LOCALCARRYQNAME, node.getToken());
    614618                       
    615619
     
    631635                        WhileStmtNode innerWhile = node.deepCopy();
    632636                        CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtins2Lang, carrySet2Lang);
    633                         xFormer.XForm(finalBlockMode, false, CarrySetBuiltins2Lang.LOCALCARRYQIDENTIFIER);
     637                        xFormer.XForm(finalBlockMode, false, CarrySetBuiltins2Lang.LOCALCARRYQNAME);
    634638                       
    635639                        FuncCallNode localCarryDeclare = (FuncCallNode) Generators.makeFuncCallNode(
    636640                                        carrySet2Lang.getCode(CarrySetBuiltins.LOCALCARRYDECLARE),
    637641                                        node.getToken(),
    638                                         new ASTNode [] {localCarryName, carryCountNode});
     642                                        new ASTNode [] {localCarryId, carryCountNode});
    639643
    640644                        Accessors.whileBlockStmt(innerWhile).insertChild(localCarryDeclare);
     
    643647                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE),
    644648                                        node.getToken(),
    645                                         new ASTNode [] {carryBaseNode, carryCountNode});
     649                                        new ASTNode [] {localCarryQArrayQName, carryBaseNode, carryCountNode});
    646650                       
    647651                        Accessors.whileBlockStmt(innerWhile).appendChild(carryCombine);
  • proto/pablo/src/compiler/transformer/visitors/PabloS2PabloBXFormer.java

    r2778 r2809  
    66
    77import compiler.ast.pabloB.Generators;
    8 import compiler.ast.pabloS.Accessors;
     8import compiler.lang.carry.CarryInfoSet;
     9import compiler.lang.carry.CarrySetBuiltins;
     10import compiler.lang.carry.CarrySetBuiltins2Lang;
     11import compiler.lang.pabloS.Builtins2Lang;
     12import compiler.symbols.CarryInfoSetSymbol;
    913import compiler.symbols.SymbolTable;
     14import pabloB.ast.AssignNode;
     15import pabloB.ast.StateInitStmtNode;
     16import pabloB.ast.ASTNode;
     17import pabloB.ast.FuncCallNode;
    1018import pabloS.ast.ASTVisitor.Default;
    1119
     
    2432
    2533       
    26     public PabloS2PabloBXFormer(compiler.symbols.SymbolTable symbolTable) {
     34        private CarrySetBuiltins2Lang carrySet2Lang;
     35       
     36        /*
     37        public PabloS2PabloBXFormer(compiler.symbols.SymbolTable symbolTable) {
    2738        this.decoratedASTTree = null;
    2839        this.optDecoratedASTTree = null;
    29         this.symbolTable = symbolTable;
     40        this.symbolTable = symbolTable;
     41         */
     42 
     43    public PabloS2PabloBXFormer(compiler.symbols.SymbolTable symbolTable, CarrySetBuiltins2Lang carrySet2Lang) {
     44        this.decoratedASTTree = null;
     45        this.optDecoratedASTTree = null;
     46        this.symbolTable = symbolTable;
     47       
     48        this.carrySet2Lang = carrySet2Lang;
    3049    }
    3150
     
    5776
    5877                        pabloB.ast.IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, locationToken);
    59                         optFuncDefNode.replaceChild(optFuncDefNode.child(1), doOptBlockIdentifier);
     78                        optFuncDefNode.replaceChild(optFuncDefNode.child(1), doOptBlockIdentifier);                     
     79                       
     80                        String kernelName = entry.getKey();                     
     81                        CarryInfoSetSymbol carryInfoSetSymbol = (CarryInfoSetSymbol) symbolTable.get(kernelName);
     82                       
     83                       
     84                        pabloB.ast.InitDefNode initDefNode = Generators.makeInitDefNode(locationToken);                 
     85                       
     86                        // Temporary fix
     87                       
     88                        // Add carry_flip call
     89                       
     90                        // delete children
     91                        /*
     92                        if(carryInfoSetSymbol.getCarry1Count() > 0) {
     93                                StateInitStmtNode carry1StateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRY1STATENAME,
     94                                                                                                                carryInfoSetSymbol.getCarry1Array(),
     95                                                                                                                locationToken);                 
     96                                compiler.ast.pabloB.Accessors.initBlockNode(initDefNode).appendChild(carry1StateNode);
     97                        }
     98                       
     99                        if(carryInfoSetSymbol.getCarryNCount() > 0) {
     100                                StateInitStmtNode carryNStateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRYNSTATENAME,
     101                                                                                                                carryInfoSetSymbol.getCarryNArray(),
     102                                                                                                                locationToken);
     103                                compiler.ast.pabloB.Accessors.initBlockNode(initDefNode).appendChild(carryNStateNode);
     104                        }
     105                        */
     106                       
     107                        if(carryInfoSetSymbol.getCarry1Count() > 0) {
     108                                               
     109                        Integer [] carry1Array = carryInfoSetSymbol.getCarry1Array();   
     110                               
     111                        for(int i=0; i < carry1Array.length; i++) {     
     112                               
     113                                if(carry1Array[i] > 0) {
     114                                       
     115                                                String carryFlipArrayExpr = String.format(carrySet2Lang.LOCALCARRYQARRAYNAME + "[%s]", Integer.toString(i));   
     116                                               
     117                                                String[] carryFlipIdentiferArray = new String [] {carrySet2Lang.CARRYQNAME, carryFlipArrayExpr};
     118                                               
     119                                                pabloB.ast.CompoundIdentifierNode carryFlipIdentifierNode
     120                                                                = Generators.makeCompoundIdentifierNode(carryFlipIdentiferArray,
     121                                                                locationToken);
     122                                               
     123                                                FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     124                                                                new String [] {carrySet2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
     125                                                                locationToken,
     126                                                                new ASTNode [] {carryFlipIdentifierNode});
     127                                               
     128                                                AssignNode assignNode = Generators.makeAssignEqualNode(carryFlipIdentiferArray,
     129                                                                carryFlipFuncCall,
     130                                                                locationToken);
     131                                                                                               
     132                                                compiler.ast.pabloB.Accessors.initBlockNode(initDefNode).appendChild(assignNode);                                               
     133                                               
     134                                        }
     135                                }
     136                        }
    60137                       
    61138                        // make kernel node
    62139                        pabloB.ast.KernelDefNode kernelDefNode =
    63                                         Generators.makeKernelDef(entry.getKey(), funcDefNode, optFuncDefNode, locationToken);
    64                        
    65                         // slice kernel node into PabloB tree
     140                                        Generators.makeKernelDef(kernelName,
     141                                                        initDefNode,
     142                                                        funcDefNode,
     143                                                        optFuncDefNode,
     144                                                        locationToken);
     145                                               
     146                        // splice kernel node onto PabloB tree
    66147                        funcDefNode.updateSelf(kernelDefNode);
    67148                }
     
    479560       
    480561                if(node instanceof pabloS.ast.ASTNode) {
    481                         if(Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(target)) {
     562                        if(compiler.ast.pabloS.Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(target)) {
    482563                                return (pabloS.ast.FuncDefNode)node;
    483564                        }
  • proto/pablo/src/pabloB/ast/ASTTransformer.java

    r2749 r2809  
    4040        public ASTNode visit(IfStmtNode node);
    4141
     42        public ASTNode visit(InitBlockNode node);
     43
     44        public ASTNode visit(InitDefNode node);
     45
    4246        public ASTNode visit(IntegerConstantNode node);
    4347
     
    5357
    5458        public ASTNode visit(ReturnStmtNode node);
     59
     60        public ASTNode visit(StateIdentifierNode node);
     61
     62        public ASTNode visit(StateInitListNode node);
     63
     64        public ASTNode visit(StateInitStmtNode node);
     65
     66        public ASTNode visit(StateSizeNode node);
    5567
    5668        public ASTNode visit(StreamTypeNode node);
     
    139151                }
    140152
     153                public ASTNode visit(InitBlockNode node) {
     154                        return defaultVisit(node);
     155                }
     156
     157                public ASTNode visit(InitDefNode node) {
     158                        return defaultVisit(node);
     159                }
     160
    141161                public ASTNode visit(IntegerConstantNode node) {
    142162                        return defaultVisit(node);
     
    164184
    165185                public ASTNode visit(ReturnStmtNode node) {
     186                        return defaultVisit(node);
     187                }
     188
     189                public ASTNode visit(StateIdentifierNode node) {
     190                        return defaultVisit(node);
     191                }
     192
     193                public ASTNode visit(StateInitListNode node) {
     194                        return defaultVisit(node);
     195                }
     196
     197                public ASTNode visit(StateInitStmtNode node) {
     198                        return defaultVisit(node);
     199                }
     200
     201                public ASTNode visit(StateSizeNode node) {
    166202                        return defaultVisit(node);
    167203                }
  • proto/pablo/src/pabloB/ast/ASTVisitor.java

    r2749 r2809  
    5656        public T visitLeave(IfStmtNode node, List<T> childResults);
    5757
     58        public void visitEnter(InitBlockNode node);
     59        public T visitLeave(InitBlockNode node, List<T> childResults);
     60
     61        public void visitEnter(InitDefNode node);
     62        public T visitLeave(InitDefNode node, List<T> childResults);
     63
    5864        public void visitEnter(IntegerConstantNode node);
    5965        public T visitLeave(IntegerConstantNode node, List<T> childResults);
     
    7682        public void visitEnter(ReturnStmtNode node);
    7783        public T visitLeave(ReturnStmtNode node, List<T> childResults);
     84
     85        public void visitEnter(StateIdentifierNode node);
     86        public T visitLeave(StateIdentifierNode node, List<T> childResults);
     87
     88        public void visitEnter(StateInitListNode node);
     89        public T visitLeave(StateInitListNode node, List<T> childResults);
     90
     91        public void visitEnter(StateInitStmtNode node);
     92        public T visitLeave(StateInitStmtNode node, List<T> childResults);
     93
     94        public void visitEnter(StateSizeNode node);
     95        public T visitLeave(StateSizeNode node, List<T> childResults);
    7896
    7997        public void visitEnter(StreamTypeNode node);
     
    226244                }
    227245
     246                public void visitEnter(InitBlockNode node) {
     247                        defaultVisitEnter(node);
     248                }
     249                public T visitLeave(InitBlockNode node, List<T> childResults) {
     250                        return defaultVisitLeave(node);
     251                }
     252
     253                public void visitEnter(InitDefNode node) {
     254                        defaultVisitEnter(node);
     255                }
     256                public T visitLeave(InitDefNode node, List<T> childResults) {
     257                        return defaultVisitLeave(node);
     258                }
     259
    228260                public void visitEnter(IntegerConstantNode node) {
    229261                        defaultVisitEnter(node);
     
    272304                }
    273305                public T visitLeave(ReturnStmtNode node, List<T> childResults) {
     306                        return defaultVisitLeave(node);
     307                }
     308
     309                public void visitEnter(StateIdentifierNode node) {
     310                        defaultVisitEnter(node);
     311                }
     312                public T visitLeave(StateIdentifierNode node, List<T> childResults) {
     313                        return defaultVisitLeave(node);
     314                }
     315
     316                public void visitEnter(StateInitListNode node) {
     317                        defaultVisitEnter(node);
     318                }
     319                public T visitLeave(StateInitListNode node, List<T> childResults) {
     320                        return defaultVisitLeave(node);
     321                }
     322
     323                public void visitEnter(StateInitStmtNode node) {
     324                        defaultVisitEnter(node);
     325                }
     326                public T visitLeave(StateInitStmtNode node, List<T> childResults) {
     327                        return defaultVisitLeave(node);
     328                }
     329
     330                public void visitEnter(StateSizeNode node) {
     331                        defaultVisitEnter(node);
     332                }
     333                public T visitLeave(StateSizeNode node, List<T> childResults) {
    274334                        return defaultVisitLeave(node);
    275335                }
  • proto/pablo/src/pabloB/ast/SimpleVisitor.java

    r2749 r2809  
    4141        public void visit(IfStmtNode node);
    4242
     43        public void visit(InitBlockNode node);
     44
     45        public void visit(InitDefNode node);
     46
    4347        public void visit(IntegerConstantNode node);
    4448
     
    5458
    5559        public void visit(ReturnStmtNode node);
     60
     61        public void visit(StateIdentifierNode node);
     62
     63        public void visit(StateInitListNode node);
     64
     65        public void visit(StateInitStmtNode node);
     66
     67        public void visit(StateSizeNode node);
    5668
    5769        public void visit(StreamTypeNode node);
     
    140152                }
    141153
     154                public void visit(InitBlockNode node) {
     155                        defaultVisit(node);
     156                }
     157
     158                public void visit(InitDefNode node) {
     159                        defaultVisit(node);
     160                }
     161
    142162                public void visit(IntegerConstantNode node) {
    143163                        defaultVisit(node);
     
    165185
    166186                public void visit(ReturnStmtNode node) {
     187                        defaultVisit(node);
     188                }
     189
     190                public void visit(StateIdentifierNode node) {
     191                        defaultVisit(node);
     192                }
     193
     194                public void visit(StateInitListNode node) {
     195                        defaultVisit(node);
     196                }
     197
     198                public void visit(StateInitStmtNode node) {
     199                        defaultVisit(node);
     200                }
     201
     202                public void visit(StateSizeNode node) {
    167203                        defaultVisit(node);
    168204                }
  • proto/pablo/src/pabloB/ast/VoidVisitor.java

    r2749 r2809  
    5454        public void visitLeave(IfStmtNode node);
    5555
     56        public void visitEnter(InitBlockNode node);
     57        public void visitLeave(InitBlockNode node);
     58
     59        public void visitEnter(InitDefNode node);
     60        public void visitLeave(InitDefNode node);
     61
    5662        public void visitEnter(IntegerConstantNode node);
    5763        public void visitLeave(IntegerConstantNode node);
     
    7480        public void visitEnter(ReturnStmtNode node);
    7581        public void visitLeave(ReturnStmtNode node);
     82
     83        public void visitEnter(StateIdentifierNode node);
     84        public void visitLeave(StateIdentifierNode node);
     85
     86        public void visitEnter(StateInitListNode node);
     87        public void visitLeave(StateInitListNode node);
     88
     89        public void visitEnter(StateInitStmtNode node);
     90        public void visitLeave(StateInitStmtNode node);
     91
     92        public void visitEnter(StateSizeNode node);
     93        public void visitLeave(StateSizeNode node);
    7694
    7795        public void visitEnter(StreamTypeNode node);
     
    223241                }
    224242
     243                public void visitEnter(InitBlockNode node) {
     244                        defaultVisitEnter(node);
     245                }
     246                public void visitLeave(InitBlockNode node) {
     247                        defaultVisitLeave(node);
     248                }
     249
     250                public void visitEnter(InitDefNode node) {
     251                        defaultVisitEnter(node);
     252                }
     253                public void visitLeave(InitDefNode node) {
     254                        defaultVisitLeave(node);
     255                }
     256
    225257                public void visitEnter(IntegerConstantNode node) {
    226258                        defaultVisitEnter(node);
     
    269301                }
    270302                public void visitLeave(ReturnStmtNode node) {
     303                        defaultVisitLeave(node);
     304                }
     305
     306                public void visitEnter(StateIdentifierNode node) {
     307                        defaultVisitEnter(node);
     308                }
     309                public void visitLeave(StateIdentifierNode node) {
     310                        defaultVisitLeave(node);
     311                }
     312
     313                public void visitEnter(StateInitListNode node) {
     314                        defaultVisitEnter(node);
     315                }
     316                public void visitLeave(StateInitListNode node) {
     317                        defaultVisitLeave(node);
     318                }
     319
     320                public void visitEnter(StateInitStmtNode node) {
     321                        defaultVisitEnter(node);
     322                }
     323                public void visitLeave(StateInitStmtNode node) {
     324                        defaultVisitLeave(node);
     325                }
     326
     327                public void visitEnter(StateSizeNode node) {
     328                        defaultVisitEnter(node);
     329                }
     330                public void visitLeave(StateSizeNode node) {
    271331                        defaultVisitLeave(node);
    272332                }
  • proto/pablo/src/pabloB/lexicalAnalyzer/Lextant.java

    r2749 r2809  
    2424        AND_ASSIGN("&=", "main"),
    2525        NOT("~", "main"),
     26        RSQUARE("]", "main"),
     27        INIT("init", "main"),
    2628        LANGLE("<", "main"),
    2729        VOID("void", "main"),
     
    3739        FUNCTION("function", "main"),
    3840        LCURLY("{", "main"),
     41        LSQUARE("[", "main"),
    3942        AND("&", "main"),
    4043        RROUND(")", "main"),
  • proto/pablo/src/pabloB/parser/Parser.java

    r2749 r2809  
    108108                expect(Lextant.LCURLY);
    109109                {
     110                        ASTNode child = parseInitDef();
     111                        result.appendChild(child);
     112                        allChildren.add(child);
     113                }
     114                {
    110115                        ASTNode child = parseFuncDef();
    111116                        result.appendChild(child);
     
    149154        }
    150155         
     156        public ASTNode parseInitDef() {
     157                if( !(nowReading.isLextant(Lextant.INIT)) ) {
     158                        return syntaxErrorNode("initDef² [INIT¹]");
     159                }
     160       
     161                boolean allowCompression = true;
     162                ASTNode result = new InitDefNode(nowReading);
     163                result.setProductionTag(5);
     164                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     165                expect(Lextant.INIT);
     166                {
     167                        ASTNode child = parseInitBlock();
     168                        result.appendChild(child);
     169                        allChildren.add(child);
     170                }
     171                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
     172                        expect(Lextant.TERMINATOR);
     173                }
     174                if(allowCompression) {
     175                        return result;
     176                }
     177                return result;
     178        }
     179         
     180        public ASTNode parseInitBlock() {
     181                if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
     182                        return syntaxErrorNode("initBlock² [LCURLY¹]");
     183                }
     184       
     185                boolean allowCompression = true;
     186                ASTNode result = new InitBlockNode(nowReading);
     187                result.setProductionTag(6);
     188                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     189                expect(Lextant.LCURLY);
     190                while( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     191                        {
     192                                ASTNode child = parseStateInitStmt();
     193                                result.appendChild(child);
     194                                allChildren.add(child);
     195                        }
     196                }
     197                expect(Lextant.RCURLY);
     198                if(allowCompression) {
     199                        return compressIfPossible(result);
     200                }
     201                return result;
     202        }
     203         
     204        public ASTNode parseStateInitStmt() {
     205                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     206                        return syntaxErrorNode("stateInitStmt² [IDENTIFIER¹]");
     207                }
     208       
     209                boolean allowCompression = true;
     210                ASTNode result = new StateInitStmtNode(nowReading);
     211                result.setProductionTag(7);
     212                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     213                {
     214                        ASTNode child = parseStateIdentifier();
     215                        result.appendChild(child);
     216                        allChildren.add(child);
     217                }
     218                expect(Lextant.LSQUARE);
     219                {
     220                        ASTNode child = parseStateSize();
     221                        result.appendChild(child);
     222                        allChildren.add(child);
     223                }
     224                expect(Lextant.RSQUARE);
     225                expect(Lextant.ASSIGN);
     226                expect(Lextant.LCURLY);
     227                {
     228                        ASTNode child = parseStateInitList();
     229                        result.appendChild(child);
     230                        allChildren.add(child);
     231                }
     232                expect(Lextant.RCURLY);
     233                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
     234                        expect(Lextant.TERMINATOR);
     235                }
     236                if(allowCompression) {
     237                        return result;
     238                }
     239                return result;
     240        }
     241         
     242        public ASTNode parseStateIdentifier() {
     243                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     244                        return syntaxErrorNode("stateIdentifier² [IDENTIFIER¹]");
     245                }
     246       
     247                boolean allowCompression = true;
     248                ASTNode result = new StateIdentifierNode(nowReading);
     249                result.setProductionTag(8);
     250                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     251                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     252                        return syntaxErrorNode("IDENTIFIER");
     253                }
     254                readToken();
     255                if(allowCompression) {
     256                        return result;
     257                }
     258                return result;
     259        }
     260         
     261        public ASTNode parseStateSize() {
     262                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     263                        return syntaxErrorNode("stateSize² [INTEGER_CONST¹]");
     264                }
     265       
     266                boolean allowCompression = true;
     267                ASTNode result = new StateSizeNode(nowReading);
     268                result.setProductionTag(9);
     269                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     270                {
     271                        ASTNode child = parseIntegerConstant();
     272                        result.appendChild(child);
     273                        allChildren.add(child);
     274                }
     275                if(allowCompression) {
     276                        return result;
     277                }
     278                return result;
     279        }
     280         
     281        public ASTNode parseStateInitList() {
     282                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     283                        return syntaxErrorNode("stateInitList² [INTEGER_CONST¹]");
     284                }
     285       
     286                boolean allowCompression = true;
     287                ASTNode result = new StateInitListNode(nowReading);
     288                result.setProductionTag(10);
     289                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     290                {
     291                        ASTNode child = parseIntegerConstant();
     292                        result.appendChild(child);
     293                        allChildren.add(child);
     294                }
     295                while( nowReading.isLextant(Lextant.COMMA) ) {
     296                        expect(Lextant.COMMA);
     297                        {
     298                                ASTNode child = parseIntegerConstant();
     299                                result.appendChild(child);
     300                                allChildren.add(child);
     301                        }
     302                }
     303                if(allowCompression) {
     304                        return result;
     305                }
     306                return result;
     307        }
     308         
    151309        public ASTNode parseFuncDef() {
    152310                if( !(nowReading.isLextant(Lextant.FUNCTION)) ) {
     
    156314                boolean allowCompression = true;
    157315                ASTNode result = new FuncDefNode(nowReading);
    158                 result.setProductionTag(5);
     316                result.setProductionTag(11);
    159317                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    160318                expect(Lextant.FUNCTION);
    161319                {
    162                         ASTNode child = parseType();
     320                        ASTNode child = parseReturnType();
    163321                        result.appendChild(child);
    164322                        allChildren.add(child);
     
    199357                boolean allowCompression = true;
    200358                ASTNode result = new ASTNode(nowReading);
    201                 result.setProductionTag(6);
     359                result.setProductionTag(12);
    202360                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    203361                {
     
    219377                boolean allowCompression = true;
    220378                ASTNode result = new ParameterListNode(nowReading);
    221                 result.setProductionTag(7);
     379                result.setProductionTag(13);
    222380                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    223381                {
     
    247405                boolean allowCompression = true;
    248406                ASTNode result = new ASTNode(nowReading);
    249                 result.setProductionTag(8);
     407                result.setProductionTag(14);
    250408                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    251409                {
     
    267425                boolean allowCompression = true;
    268426                ASTNode result = new ParameterNode(nowReading);
    269                 result.setProductionTag(9);
     427                result.setProductionTag(15);
    270428                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    271429                {
     
    292450                boolean allowCompression = true;
    293451                ASTNode result = new ASTNode(nowReading);
    294                 result.setProductionTag(10);
     452                result.setProductionTag(16);
    295453                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    296454                {
     
    312470                boolean allowCompression = true;
    313471                ASTNode result = new ASTNode(nowReading);
    314                 result.setProductionTag(11);
     472                result.setProductionTag(17);
    315473                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    316474                {
     
    332490                boolean allowCompression = true;
    333491                ASTNode result = new ASTNode(nowReading);
    334                 result.setProductionTag(12);
     492                result.setProductionTag(18);
    335493                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    336494                {
     
    352510                boolean allowCompression = true;
    353511                ASTNode result = new ASTNode(nowReading);
    354                 result.setProductionTag(13);
     512                result.setProductionTag(19);
    355513                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    356514                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    405563                boolean allowCompression = true;
    406564                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    407                 result.setProductionTag(14);
     565                result.setProductionTag(20);
    408566                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    409567                {
     
    444602                boolean allowCompression = true;
    445603                ASTNode result = new FuncCallNode(nowReading);
    446                 result.setProductionTag(15);
     604                result.setProductionTag(21);
    447605                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    448606                result.setToken(nowReading);
     
    463621                boolean allowCompression = true;
    464622                ASTNode result = new FuncCallArgListNode(nowReading);
    465                 result.setProductionTag(16);
     623                result.setProductionTag(22);
    466624                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    467625                if( nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    493651                boolean allowCompression = true;
    494652                ASTNode result = new AssignOperatorNode(nowReading);
    495                 result.setProductionTag(17);
     653                result.setProductionTag(23);
    496654                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    497655                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    520678                boolean allowCompression = true;
    521679                ASTNode result = new AssignNode(nowReading);
    522                 result.setProductionTag(18);
     680                result.setProductionTag(24);
    523681                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    524682                {
     
    546704                boolean allowCompression = true;
    547705                ASTNode result = new IfStmtNode(nowReading);
    548                 result.setProductionTag(19);
     706                result.setProductionTag(25);
    549707                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    550708                expect(Lextant.IF);
     
    582740                boolean allowCompression = true;
    583741                ASTNode result = new WhileStmtNode(nowReading);
    584                 result.setProductionTag(20);
     742                result.setProductionTag(26);
    585743                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    586744                expect(Lextant.WHILE);
     
    610768                boolean allowCompression = true;
    611769                ASTNode result = new ReturnStmtNode(nowReading);
    612                 result.setProductionTag(21);
     770                result.setProductionTag(27);
    613771                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    614772                expect(Lextant.RETURN);
     
    634792                boolean allowCompression = true;
    635793                ASTNode result = new LocalVarDeclNode(nowReading);
    636                 result.setProductionTag(22);
     794                result.setProductionTag(28);
    637795                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    638796                expect(Lextant.VAR);
     
    673831                boolean allowCompression = true;
    674832                ASTNode result = new ASTNode(nowReading);
    675                 result.setProductionTag(23);
     833                result.setProductionTag(29);
    676834                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    677835                {
     
    693851                boolean allowCompression = true;
    694852                ASTNode result = new BlockStmtNode(nowReading);
    695                 result.setProductionTag(24);
     853                result.setProductionTag(30);
    696854                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    697855                expect(Lextant.LCURLY);
     
    717875                boolean allowCompression = true;
    718876                ASTNode result = new BinaryOperatorNode(nowReading);
    719                 result.setProductionTag(25);
     877                result.setProductionTag(31);
    720878                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    721879                {
     
    752910                boolean allowCompression = true;
    753911                ASTNode result = new BinaryOperatorNode(nowReading);
    754                 result.setProductionTag(26);
     912                result.setProductionTag(32);
    755913                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    756914                {
     
    781939                boolean allowCompression = true;
    782940                ASTNode result = new UnaryOperatorNode(nowReading);
    783                 result.setProductionTag(27);
     941                result.setProductionTag(33);
    784942                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    785943                if( nowReading.isLextant(Lextant.NOT) ) {
     
    807965                boolean allowCompression = true;
    808966                ASTNode result = new ASTNode(nowReading);
    809                 result.setProductionTag(28);
     967                result.setProductionTag(34);
    810968                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    811969                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    8541012                boolean allowCompression = true;
    8551013                ASTNode result = new ASTNode(nowReading);
    856                 result.setProductionTag(29);
     1014                result.setProductionTag(35);
    8571015                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    8581016                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    8831041                boolean allowCompression = true;
    8841042                ASTNode result = new ASTNode(nowReading);
    885                 result.setProductionTag(30);
     1043                result.setProductionTag(36);
    8861044                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    8871045                if( nowReading.isLextant(Lextant.MINUS) ) {
     
    9231081                boolean allowCompression = true;
    9241082                ASTNode result = new IntegerConstantNode(nowReading);
    925                 result.setProductionTag(31);
     1083                result.setProductionTag(37);
    9261084                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    9271085                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    9491107                boolean allowCompression = true;
    9501108                ASTNode result = new StringConstantNode(nowReading);
    951                 result.setProductionTag(32);
     1109                result.setProductionTag(38);
    9521110                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    9531111                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    9761134                boolean allowCompression = true;
    9771135                ASTNode result = new CompoundIdentifierNode(nowReading);
    978                 result.setProductionTag(33);
     1136                result.setProductionTag(39);
    9791137                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    9801138                {
     
    10051163                boolean allowCompression = true;
    10061164                ASTNode result = new IdentifierNode(nowReading);
    1007                 result.setProductionTag(34);
     1165                result.setProductionTag(40);
    10081166                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10091167                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    10241182                boolean allowCompression = true;
    10251183                ASTNode result = new ASTNode(nowReading);
    1026                 result.setProductionTag(35);
     1184                result.setProductionTag(41);
    10271185                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10281186                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    10671225                boolean allowCompression = true;
    10681226                ASTNode result = new StreamTypeNode(nowReading);
    1069                 result.setProductionTag(36);
     1227                result.setProductionTag(42);
    10701228                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10711229                expect(Lextant.STREAM);
     
    10921250                boolean allowCompression = true;
    10931251                ASTNode result = new FieldWidthNode(nowReading);
    1094                 result.setProductionTag(37);
    1095                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1096                 if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    1097                         return syntaxErrorNode("INTEGER_CONST");
    1098                 }
    1099                 readToken();
     1252                result.setProductionTag(43);
     1253                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1254                {
     1255                        ASTNode child = parseIntegerConstant();
     1256                        result.appendChild(child);
     1257                        allChildren.add(child);
     1258                }
    11001259                if(allowCompression) {
    11011260                        return result;
     
    11111270                boolean allowCompression = true;
    11121271                ASTNode result = new ASTNode(nowReading);
    1113                 result.setProductionTag(38);
     1272                result.setProductionTag(44);
    11141273                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11151274                {
     
    11311290                boolean allowCompression = true;
    11321291                ASTNode result = new StructTypeNode(nowReading);
    1133                 result.setProductionTag(39);
     1292                result.setProductionTag(45);
    11341293                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11351294                expect(Lextant.STRUCT);
     
    11591318                boolean allowCompression = true;
    11601319                ASTNode result = new ASTNode(nowReading);
    1161                 result.setProductionTag(40);
     1320                result.setProductionTag(46);
    11621321                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11631322                {
     
    11791338                boolean allowCompression = true;
    11801339                ASTNode result = new StructTypeBodyNode(nowReading);
    1181                 result.setProductionTag(41);
     1340                result.setProductionTag(47);
    11821341                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11831342                expect(Lextant.LCURLY);
     
    12101369                boolean allowCompression = true;
    12111370                ASTNode result = new StructMemberNode(nowReading);
    1212                 result.setProductionTag(42);
     1371                result.setProductionTag(48);
    12131372                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12141373                {
     
    12351394                boolean allowCompression = true;
    12361395                ASTNode result = new ASTNode(nowReading);
    1237                 result.setProductionTag(43);
     1396                result.setProductionTag(49);
    12381397                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12391398                {
     
    12551414                boolean allowCompression = true;
    12561415                ASTNode result = new VoidNode(nowReading);
    1257                 result.setProductionTag(44);
     1416                result.setProductionTag(50);
    12581417                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12591418                expect(Lextant.VOID);
  • proto/pablo/src/pabloB/tokens/LextantToken.java

    r2767 r2809  
    3838                return new LextantToken(location, lexeme, lextant);
    3939        }
    40        
    4140}
  • proto/pablo/src/pabloS/ast/ASTNode.java

    r2796 r2809  
    8181                return parent;
    8282        }
    83         public void setParent(ASTNode parent) {
     83        protected void setParent(ASTNode parent) {
    8484                this.parent = parent;
    8585        }
  • proto/pablo/src/pabloS/parser/Parser.java

    r2749 r2809  
    136136                expect(Lextant.FUNCTION);
    137137                {
    138                         ASTNode child = parseType();
     138                        ASTNode child = parseReturnType();
    139139                        result.appendChild(child);
    140140                        allChildren.add(child);
     
    10301030                result.setProductionTag(34);
    10311031                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1032                 if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    1033                         return syntaxErrorNode("INTEGER_CONST");
    1034                 }
    1035                 readToken();
     1032                {
     1033                        ASTNode child = parseIntegerConstant();
     1034                        result.appendChild(child);
     1035                        allChildren.add(child);
     1036                }
    10361037                if(allowCompression) {
    10371038                        return result;
Note: See TracChangeset for help on using the changeset viewer.