Changeset 3699


Ignore:
Timestamp:
Mar 16, 2014, 3:51:19 PM (4 years ago)
Author:
ksherdy
Message:

Updated PabloJ to s2k.

Location:
proto/pabloj/trunk
Files:
255 added
20 deleted
24 edited
4 moved

Legend:

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

    r3192 r3699  
    1414
    1515================================================================================
    16 PabloS Builtins
     16s2k Builtins
    1717================================================================================
    1818
     
    2020
    21211. Add field width to pablo.operation builtin calls.
    22         e.g. pablo.operation() -> pablos.operation<fw>(...)
     22        e.g. pablo.operation() -> s2k.operation<fw>(...)
    2323
    2424--------------------------------------------------------------------------------
     
    2626--------------------------------------------------------------------------------
    2727
    28 PabloB syntax   --> PabloB Parser --> output (C,C++,LLVM)
     28b2k syntax      --> b2k Parser --> output (C,C++,LLVM)
    2929       
    3030                                                ^
     
    5454       
    5555================================================================================
    56 PabloS Types
     56s2k Types
    5757================================================================================
    5858
     
    6464
    6565================================================================================
    66 PabloS Visitors
    67 ================================================================================
    68 
    69 1. All PabloS conditional expression E are wrapped in BitBlock::any(E) calls.
    70 
    71 ================================================================================
    72 PabloB Memory and Block-at-a-time Processing Model
     66s2k Visitors
     67================================================================================
     68
     691. All s2k conditional expression E are wrapped in BitBlock::any(E) calls.
     70
     71================================================================================
     72b2k Memory and Block-at-a-time Processing Model
    7373================================================================================
    7474
     
    8989e.g. bitblock s; s = simd::constant<1>(0);
    9090
    91 (2) Current PabloB grammar does not support boolean OR.
     91(2) Current b2k grammar does not support boolean OR.
    9292
    9393Work around. Added PabloJCarryTest runtime check that returns a type BitBlock.
     
    100100(5) 
    101101
    102 PabloS - Design and implementation issues.
     102s2k - Design and implementation issues.
    103103
    104104(1) Grammar/Parser/Semantic Analyzer
     
    110110    For example,
    111111   
    112     (a) PabloS grammar permits top-level type declarations of all types.
     112    (a) s2k grammar permits top-level type declarations of all types.
    113113        However, the intention is to restrict to stream struct definitions.
    114114   
    115     (b) PabloS grammar does not enforce def/use for stream structs prior to use in stream function defintions,
    116         i.e. PabloS grammar does not prevent the definition of stream functions prior to stream structs.
     115    (b) s2k grammar does not enforce def/use for stream structs prior to use in stream function defintions,
     116        i.e. s2k grammar does not prevent the definition of stream functions prior to stream structs.
    117117       
    118     (c) PabloS grammar does not prevent the definition of new types within the body of
     118    (c) s2k grammar does not prevent the definition of new types within the body of
    119119        stream functions.   
    120120
     
    122122       
    123123
    124 PabloB - Design and implementation issues.
     124b2k - Design and implementation issues.
    125125
    126126(1) 'static' initialization section vs. 'kernel' constructor
     
    269269        (b) Clone complete AST. Apply AST transformation passes to both ASTs.
    270270        (c) Add both body and final block bodies to a single AST. We accomplish this through
    271             the addition/introduce of both PabloS and PabloB grammars and translate
    272             from PabloS to PabloB.
     271            the addition/introduce of both s2k and b2k grammars and translate
     272            from s2k to b2k.
    273273       
    274274        An additional decision remains as to which point in Pablo AST transformation we clone ASTs.
    275275
    276         Design choice taken (c): Translate from PabloS to PabloB.
     276        Design choice taken (c): Translate from s2k to b2k.
    277277
    27827813. Carry mode (ci/co) and do_block/do_final_block are independent concepts.
     
    371371}
    372372
    373 16. PabloB grammar design issue (together with Carry InfoSet design)
    374 
    375 How do we add stream function level declaration / initialization code to the output?
     37316. b2k grammar design issue (together with Carry InfoSet design)
     374
     375How do we add stream function level declaration / initialisation code to the output?
    376376
    377377Options:
    378378
    379 (a) Add explicit carry info set information to the PabloB function definition representation.
    380 
    381     No, this would burden the programmer at the PabloB level.
     379(a) Add explicit carry info set information to the b2k function definition representation.
     380
     381    No, this would burden the programmer at the b2k level.
    382382    The idea is the we remove carry counting ... from the developer
    383383    but still we need carry count / advn carry count information
     
    385385   
    386386(b) Hold carry info set information in a symbol table external
    387         to both PabloB. Query this data structure during code generation.
     387        to both b2k. Query this data structure during code generation.
    388388   
    389389(a) and (b) are similar in that both options remove explicit carry counting from the programmer.
    390390
    391 We currently translate PabloS to PabloB and PabloS code is used to populate the information
    392 contained in the symbol table used by PabloB.
    393 
    394 We could populate similar symbol table information based on PabloB code alone.
     391We currently translate s2k to b2k and s2k code is used to populate the information
     392contained in the symbol table used by b2k.
     393
     394We could populate similar symbol table information based on b2k code alone.
    395395
    396396More investigation is required here.
     
    400400Fill in this section ...
    401401
    402 18. PabloB needs both bitwise OR as well as boolean OR.
     40218. b2k needs both bitwise OR as well as boolean OR.
    403403
    40440419. Translate to Dotty for AST diagrams.
  • proto/pabloj/trunk/input/grammar/scatter/b2k.scatter

    r3682 r3699  
    22// Tom Shermer, Ken Herdy
    33//
    4 // PabloB - Block-at-a-time IR / language
     4// b2k - Very high-level IR for the expression of block-by-block stream processing.
    55//
    6 // Modified:    02-12-2012      Original definition.
    7 //                      29-03-2013      Added IDISA function call.
    8 //                              06-04-2013      Updated to Scatter with types.
     6// Modified:    02-12-2012      Original definition.
     7//              29-03-2013      Added IDISA function call.
     8//              06-04-2013      Updated to Scatter with types.
    99//
    1010
    1111types {
    12 //      toolchain.pabloS.lang.type.Type,
    13 //      toolchain.pabloS.lang.type.PrimitiveType,
    14 //      toolchain.pabloS.lang.type.StreamType,
     12//    toolchain.s2k.lang.type.Type,
     13//    toolchain.s2k.lang.type.PrimitiveType,
     14//    toolchain.s2k.lang.type.StreamType,
    1515}
    1616
    1717context main {
    18   recognizers {
    19          Whitespace [IGNORE],
    20          Integer [INTEGER_CONST],
    21          Identifier [IDENTIFIER],                       // Java identifiers. Produces Lextant Tokens for keywords.
    22          Comment [IGNORE] "#" "\n",                     // parabix2_pablo debugging only.
    23          Comment [IGNORE] "//" "\n",     
    24          Comment [SQ_STRING] "'" "'",
    25          Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
    26          String [STRING],
    27          Punctuator,
    28          EndOfInput,
    29   }
     18    recognizers {
     19       Whitespace [IGNORE],
     20       Integer [INTEGER_CONST],
     21        Identifier [IDENTIFIER],        // Java identifiers. Produces Lextant Tokens for keywords.
     22        Comment [IGNORE] "#" "\n",      // parabix2_pablo debugging only.
     23        Comment [IGNORE] "//" "\n",
     24       Comment [SQ_STRING] "'" "'",
     25        Comment [IGNORE] "/*" "*/",     // Comment. Comment [STRING] "/*" "*/",
     26       String [STRING],
     27       Punctuator,
     28       EndOfInput,
     29    }
    3030
    31   // t o k e n s
    32   tokens {
    33         INIT,
    34         KERNEL,
    35         FUNCTION,       
    36         STRUCT,
    37         INT,
    38         VOID,
    39         BOOL,
    40         BITFIELD        "BitField",     
    41         BITBLOCK        "BitBlock", // alias for architecture dependent SIMD type
    42         //CODEBLOCK,
    43         IF,
    44         ELSE,
    45         WHILE,
    46         RETURN,
    47         ASSIGN      "=",
    48         LANGLE          "<",
    49         RANGLE          ">",
    50         LCURLY          "{",
    51         RCURLY          "}",
    52         LROUND          "(",
    53         RROUND          ")",
    54         LSQUARE         "[",
    55         RSQUARE         "]",
    56         COMMA           ",",
    57         TERMINATOR  ";",
    58         DOT                     ".",
    59   }
     31    // t o k e n s
     32    tokens {
     33        INIT,
     34        KERNEL,
     35        FUNCTION,   
     36        STRUCT,
     37        INT,
     38        VOID,
     39        BOOL,
     40        BITFIELD    "BitField",
     41        BITBLOCK    "BitBlock", // alias for architecture dependent SIMD type
     42        //CODEBLOCK,
     43        IF,
     44        ELSE,
     45        WHILE,
     46        RETURN,
     47        ASSIGN      "=",
     48        LANGLE      "<",
     49        RANGLE      ">",
     50        LCURLY      "{",
     51        RCURLY      "}",
     52        LROUND      "(",
     53        RROUND      ")",
     54        LSQUARE     "[",
     55        RSQUARE     "]",
     56        COMMA       ",",
     57        TERMINATOR  ";",
     58        DOT         ".",
     59    }
    6060}
    6161
    6262interfaces {
    63          intValued {int value = 0;},     
     63    intValued {int value = 0;},
    6464}
    6565
    6666nodes {
    67         assign {} [assignRest],
    68         funcCall {} [funcCallRest],
    69         idisaFuncCall {} [idisaFuncCallRest],
    70         integerConstant{intValued;} [fieldWidthSpecifier ], // codeBlockWidthSpecifier ],
    71         // primitiveType{} [intType voidType boolType bitBlockType], // TODO - update S2B to handle this
    72         fieldWidthType{int fieldWidth = 1;} [],
    73         // codeBlockWidth{int codeBlockWidth = 128;} [],
     67    assign {} [assignRest],
     68    funcCall {} [funcCallRest],
     69    idisaFuncCall {} [idisaFuncCallRest],
     70    integerConstant{intValued;} [fieldWidthSpecifier ], // codeBlockWidthSpecifier ],
     71    // primitiveType{} [intType voidType boolType bitBlockType], // TODO - update S2B to handle this
     72    fieldWidthType{int fieldWidth = 1;} [],
     73    // codeBlockWidth{int codeBlockWidth = 128;} [],
    7474}
    7575
    7676grammar {
    77        
    78         program         -> (structDecl | kernelDef) * ;
    79            
    80         //
    81         // s t r u c t   d e c l a r a t i o n s 
    82         //
    83         structDecl                      ->  STRUCT structName structDeclBody TERMINATOR? ;
    84         structDeclBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
    85         structMember            ->      structMemberType structMemberName ;
    86         structMemberType        #-> structType | bitBlockType ;
    87         structMemberName        #-> identifier ;
     77   
     78    program     -> (structDecl | kernelDef) * ;
    8879   
    8980    //
    90         // k e r n e l   d e c l a r a t i o n s                                                       
    91         //
    92         kernelDef                         ->    KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // KH: TODO - a temporary hack that appends a CarryDeclare node
    93         kernelName                      #-> identifier ;
    94        
    95         //
    96         // k e r n e l   p r o p e r t i e s 
    97         //
    98         initDef                           #->  INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
    99         kernelProperty  ->  propertyName ASSIGN propertyValue TERMINATOR ;
    100         propertyName            #-> identifier ;
    101         propertyValue           ->      LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
     81    // s t r u c t   d e c l a r a t i o n s 
     82    //
     83    structDecl          ->  STRUCT structName structDeclBody TERMINATOR? ;
     84    structDeclBody      ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
     85    structMember        ->  structMemberType structMemberName ;
     86    structMemberType    #-> structType | bitBlockType ;
     87    structMemberName    #-> identifier ;
    10288
    103         //     
    104         // k e r n e l   f u n c t i o n s
    105         //
    106         funcDef                           ->    FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
    107         returnType                      #-> type ;      // KH: TODO - Not required. Planned move to in/out parameters.
    108         parameterList           ->      parameter (COMMA parameter)* ;
    109         funcName                          #-> identifier ;
    110         parameter                         ->    type parameterName ;
    111         parameterName           #-> identifier ;
    112         basicBlockStmt  #-> blockStmt ;
    113         optFuncDef                      #-> funcDef ;
     89    //
     90    // k e r n e l   d e c l a r a t i o n s
     91    //
     92    kernelDef           ->     KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // KH: TODO - a temporary hack that appends a CarryDeclare node
     93    kernelName          #-> identifier ;
    11494
    115         //
    116         // c o d e   b l o c k  // (32,64,128,256,...)
    117         //
    118         // codeBlock                    ->              CODEBLOCK codeBlockWidthSpecifier!      { @codeBlockWidth = @:value; }
    119         //                                                                                                                                      blockStmt (TERMINATOR)? ;
    120         //                             
    121         // codeBlockWidthSpecifier      #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 128;}) ;
    122                
    123         //
    124         // s t a t e m e n t s
    125         //
    126         stmt                                    #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
    127         funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // KH: TODO Add Semantic Analysis pass to validate expr non-terminal is of function call node type       
    128         idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
    129         assignOperator                  ->      ASSIGN ;                               
    130         assignRest                                ->    assignOperator^! expr ;                         
    131         ifStmt                                      ->  IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                     
    132         whileStmt                                   ->  WHILE LROUND expr RROUND blockStmt ;
    133         returnStmt                                ->    RETURN (expr) ? TERMINATOR ;
    134         varDecl                                   ->    type varName TERMINATOR ;
    135         varName                                     #-> identifier ;
    136         blockStmt                                   ->  LCURLY stmt* RCURLY ;
    137        
    138         //
    139         // e x p r e s s i o n s
    140         //     
    141         expr            #-> LROUND expr RROUND
    142                                         | constant
    143                                         | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
     95    //
     96    // k e r n e l   p r o p e r t i e s 
     97    //
     98    initDef             #-> INIT LCURLY kernelProperty* RCURLY TERMINATOR? ;
     99    kernelProperty      ->  propertyName ASSIGN propertyValue TERMINATOR ;
     100    propertyName        #-> identifier ;
     101    propertyValue       ->  LSQUARE integerConstant (COMMA integerConstant)* RSQUARE ;
    144102
    145         constant                                  #->   stringConstant | integerConstant ; 
    146         integerConstant                 ->              INTEGER_CONST {@value = @@value;} ;
    147         stringConstant                  ->              STRING | SQ_STRING ;   
    148         compoundIdentifier      #->     identifier (DOT^ identifier)* ;
    149         identifier                                ->            IDENTIFIER ;   
    150         funcCallRest                      ->            LROUND^ funcCallArgList RROUND ;
    151         funcCallArgList                 ->              (expr (COMMA expr)*) ? ;       
    152         idisaFuncCallRest               ->              LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
    153         fieldWidth                                ->            integerConstant ; // fieldWidthSpecifier
     103    //
     104    // k e r n e l   f u n c t i o n s
     105    //
     106    funcDef             ->  FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR? ;
     107    returnType          #-> type ; // KH: TODO - Not required. Add in/out parameter specifiers.
     108    parameterList       ->  parameter (COMMA parameter)* ;
     109    funcName            #-> identifier ;
     110    parameter           ->  type parameterName ;
     111    parameterName       #-> identifier ;
     112    basicBlockStmt      #-> blockStmt ;
     113    optFuncDef          #-> funcDef ;
    154114
    155   //   
    156         // t y p e s
    157         //
    158         type                            #-> primitiveType  |
    159                     bitFieldType       |
    160                                                         structType             
    161                                                         ; 
    162        
    163         primitiveType           #->  ( intType | voidType | boolType | bitBlockType ) ;
     115    //
     116    // c o d e   b l o c k     // (32,64,128,256,...)
     117    //
     118    // codeBlock        ->  CODEBLOCK codeBlockWidthSpecifier! 
     119    //                      { @codeBlockWidth = @:value; }
     120    //                      blockStmt (TERMINATOR)? ;
     121    //               
     122    // codeBlockWidthSpecifier  #-> (LANGLE integerConstant RANGLE ) | (epsilon {@value = 128;}) ;
    164123
    165         intType                         ->      INT ;             // { @type = {{PrimitiveType.INTEGER}}; } ;
    166         voidType                          ->  VOID ;                // { @type = {{PrimitiveType.VOID}}; } ;
    167         boolType                          ->  BOOL ;                // { @type = {{PrimitiveType.BOOL}}; } ;
    168         bitBlockType            ->      BITBLOCK ;  // { @type = {{PrimitiveType.BITBLOCK}}; } ;
    169        
    170         bitFieldType            ->      BITFIELD  fieldWidthSpecifier! {        @fieldWidth = @:value;
    171                                                                                                                                   // @type = {{ new BitFieldType(%?) }} , @fieldWidth ;
    172                                                                                                                 } ;
    173                                                                                                                        
    174         fieldWidthSpecifier     #-> (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;       
    175        
    176         structType                      ->      STRUCT structName ;             
    177         structName                      #-> identifier ;                               
    178        
     124    //
     125    // s t a t e m e n t s
     126    //
     127    stmt                    #-> varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
     128    funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // KH: TODO Add Semantic Analysis pass to validate expr non-terminal is of function call node type   
     129    idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
     130    assignOperator          ->  ASSIGN ;                 
     131    assignRest              ->  assignOperator^! expr ;               
     132    ifStmt                  ->  IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;             
     133    whileStmt               ->  WHILE LROUND expr RROUND blockStmt ;
     134    returnStmt              ->  RETURN (expr) ? TERMINATOR ;
     135    varDecl                 ->  type varName TERMINATOR ;
     136    varName                 #-> identifier ;
     137    blockStmt               ->  LCURLY stmt* RCURLY ;
     138
     139    //
     140    // e x p r e s s i o n s
     141    //   
     142    expr            #-> LROUND expr RROUND
     143                    | constant
     144                    | compoundIdentifier ((funcCallRest _promote_) | (idisaFuncCallRest _promote_)) ? ;
     145
     146    constant            #->     stringConstant | integerConstant ;
     147    integerConstant     ->      INTEGER_CONST {@value = @@value;} ;
     148    stringConstant      ->      STRING | SQ_STRING ;
     149    compoundIdentifier  #->     identifier (DOT^ identifier)* ;
     150    identifier          ->      IDENTIFIER ;
     151    funcCallRest        ->      LROUND^ funcCallArgList RROUND ;
     152    funcCallArgList     ->      (expr (COMMA expr)*) ? ;
     153    idisaFuncCallRest   ->      LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
     154    fieldWidth          ->      integerConstant ; // fieldWidthSpecifier
     155
     156    //
     157    // t y p e s
     158    //
     159    type                #-> primitiveType   |
     160                            bitFieldType    |
     161                            structType ;
     162
     163    primitiveType       #->  ( intType | voidType | boolType | bitBlockType ) ;
     164
     165    intType             ->  INT ;       // { @type = {{PrimitiveType.INTEGER}}; } ;
     166    voidType            ->  VOID ;      // { @type = {{PrimitiveType.VOID}}; } ;
     167    boolType            ->  BOOL ;      // { @type = {{PrimitiveType.BOOL}}; } ;
     168    bitBlockType        ->  BITBLOCK ;  // { @type = {{PrimitiveType.BITBLOCK}}; } ;
     169   
     170    bitFieldType        ->  BITFIELD  fieldWidthSpecifier!
     171                                            {   @fieldWidth = @:value;
     172                                            // @type = {{ new BitFieldType(%?) }} , @fieldWidth ;
     173                                            } ;
     174
     175    fieldWidthSpecifier    #-> (LANGLE integerConstant RANGLE )
     176                            | (epsilon {@value = 1;}) ;
     177   
     178    structType              ->  STRUCT structName ;
     179    structName              #-> identifier ;
     180   
    179181}
  • proto/pabloj/trunk/input/grammar/scatter/s2k.scatter

    r3682 r3699  
    1 //
    2 // Tom Shermer, Ken Herdy
    3 //
    41// s2k - A domain specific language for streaming text extraction and transformations.
    52//
    6 // Modified:            2012/09/08 Original definition.
    7 //                                             
     3// Modified:    2012/09/08      Original definition.
     4//
     5//
     6// Tom Shermer, Ken Herdy
     7//
    88
    99types {
    10         toolchain.pabloS.lang.signatures.FunctionSignature,
    11         toolchain.pabloS.lang.type.Type,
    12         toolchain.pabloS.lang.type.PrimitiveType,
    13         toolchain.pabloS.lang.type.StreamType,
    14         toolchain.pabloS.semanticAnalyzer.Binding,
    15         toolchain.pabloS.semanticAnalyzer.SymbolTable,
     10    toolchain.s2k.lang.signatures.FunctionSignature,
     11    toolchain.s2k.lang.type.Type,
     12    toolchain.s2k.lang.type.PrimitiveType,
     13    toolchain.s2k.lang.type.StreamType,
     14    toolchain.s2k.semanticAnalyzer.Binding,
     15    toolchain.s2k.semanticAnalyzer.SymbolTable,
    1616}
    1717
    1818context main {
    1919
    20   recognizers {
    21          Whitespace [IGNORE],
    22          Integer [INTEGER_CONST],
    23          Identifier [IDENTIFIER],                       // Java identifiers, except $ character. Produces Lextant tokens for keywords.
    24          Comment [IGNORE] "#" "\n",                     // Support parabix2_pablo debugging.
    25          Comment [IGNORE] "//" "\n",   
    26          Comment [SQ_STRING] "'" "'",
    27          Comment [IGNORE] "/*" "*/",            // Comment. Comment [STRING] "/*" "*/",
    28          String [STRING],
    29          Punctuator,
    30          EndOfInput,
    31   }
     20    recognizers {
     21       Whitespace [IGNORE],
     22       Integer [INTEGER_CONST],
     23        Identifier [IDENTIFIER],        // Java identifiers, except $ character. Produces Lextant tokens for keywords.
     24        Comment [IGNORE] "#" "\n",      // Support parabix2_pablo debugging.
     25        Comment [IGNORE] "//" "\n",
     26       Comment [SQ_STRING] "'" "'",
     27        Comment [IGNORE] "/*" "*/",     // Comment. Comment [STRING] "/*" "*/",
     28       String [STRING],
     29       Punctuator,
     30       EndOfInput,
     31    }
    3232
    3333  // t o k e n s
    34   tokens {
    35         FUNCTION,       
    36         STREAM,
    37         STRUCT,
    38         VOID,
    39         INT,
    40         IF,
    41         ELSE,
    42         WHILE,
    43         RETURN,
    44         AND             "&",
    45         OR              "|",
    46         NOT             "~",
    47         XOR             "^",
    48         MULTIPLY        "*",
    49         DIVIDE          "/",
    50         ADD                     "+",
    51         SUBTRACT        "-",
    52         ASSIGN      "=",
    53         AND_ASSIGN  "&=",
    54         OR_ASSIGN   "|=",
    55         XOR_ASSIGN  "^=",
    56         MULTIPLY_ASSIGN         "*=",
    57         DIVIDE_ASSIGN           "/=",
    58         ADD_ASSIGN                      "+=",
    59         SUBTRACT_ASSIGN         "-=",
    60         LANGLE          "<",
    61         RANGLE          ">",
    62         LCURLY          "{",
    63         RCURLY          "}",
    64         LROUND          "(",
    65         RROUND          ")",
    66         COMMA           ",",
    67         TERMINATOR  ";",
    68         DOT                     ".",
    69   }
     34    tokens {
     35        FUNCTION,
     36        STREAM,
     37        STRUCT,
     38        VOID,
     39        INT,
     40        IF,
     41        ELSE,
     42        WHILE,
     43        RETURN,
     44        AND           "&",
     45        OR            "|",
     46        NOT           "~",
     47        XOR           "^",
     48        MULTIPLY    "*",
     49        DIVIDE        "/",
     50        ADD            "+",
     51        SUBTRACT    "-",
     52        ASSIGN      "=",
     53        AND_ASSIGN  "&=",
     54        OR_ASSIGN   "|=",
     55        XOR_ASSIGN  "^=",
     56        MULTIPLY_ASSIGN        "*=",
     57        DIVIDE_ASSIGN        "/=",
     58        ADD_ASSIGN            "+=",
     59        SUBTRACT_ASSIGN        "-=",
     60        LANGLE        "<",
     61        RANGLE        ">",
     62        LCURLY        "{",
     63        RCURLY        "}",
     64        LROUND        "(",
     65        RROUND        ")",
     66        COMMA        ",",
     67        TERMINATOR  ";",
     68        DOT            ".",
     69    }
    7070}
    7171
    7272interfaces {
    73          intValued {int value = 0;},
    74          hasSymbolTable {SymbolTable symbolTable = null;},
    75          hasBinding     {Binding binding = null;},
    76          hasFieldWidth  {int fieldWidth = 1;},
    77          hasSignature   {FunctionSignature signature = null;},
     73    intValued      {int value = 0;},
     74    hasSymbolTable {SymbolTable symbolTable = null;},
     75    hasBinding      {Binding binding = null;},
     76    hasFieldWidth   {int fieldWidth = 1;},
     77    hasSignature    {FunctionSignature signature = null;},
    7878}
    7979
    8080nodes {
    81   ASTNode    {Type type = null;}  [assignOperator],
    82   program    {hasSymbolTable;} [],
    83   structDecl {hasSymbolTable;} [],
    84   funcDef    {hasSymbolTable;} [],
    85  
    86   blockStmt  {hasSymbolTable;} [],             
    87  
    88   identifier         {hasBinding;} [],
    89   compoundIdentifier {hasBinding;} [],
    90  
    91   binaryOperator {hasSignature;} [expr expr1 expr3 expr4],
    92   unaryOperator  {hasSignature;} [expr2],       
    93   funcCall       {hasSignature;} [funcCallRest],
    94 
    95 // parameterizedFuncCall {hasSignature;} [idisaFuncCallRest],
    96 
    97   assign         {} [assignRest],
    98  
    99   streamType      {hasFieldWidth;} [],
    100   integerConstant {intValued;}    [fieldWidthSpecifier],
    101  
    102   // primitiveType{} [intType voidType], // TODO - update S2B to handle this
     81    ASTNode                 {Type type = null;}  [assignOperator],
     82    program                 {hasSymbolTable;} [],
     83    structDecl              {hasSymbolTable;} [],
     84    funcDef                 {hasSymbolTable;} [],
     85    blockStmt               {hasSymbolTable;} [],
     86    identifier              {hasBinding;} [],
     87    compoundIdentifier      {hasBinding;} [],
     88    binaryOperator          {hasSignature;} [expr expr1 expr3 expr4],
     89    unaryOperator           {hasSignature;} [expr2],
     90    funcCall                {hasSignature;} [funcCallRest],
     91//  parameterizedFuncCall   {hasSignature;} [idisaFuncCallRest],
     92    assign                  {} [assignRest],
     93    streamType              {hasFieldWidth;} [],
     94    integerConstant         {intValued;}    [fieldWidthSpecifier],
     95//  primitiveType           {} [intType voidType], // TODO - update S2K2B2k to handle this
    10396}
    10497
    10598grammar {
    10699
    107         program         -> (structDecl | funcDef) *;    // ( filterDef )* graph;
    108 
    109         //
    110         // s t r e a m   s t r u c t   d e f i n i t i o n s
    111         //
    112         structDecl                        ->  STRUCT structName structDeclBody TERMINATOR? ;
    113         structDeclBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
    114         structMember              ->    structMemberType structMemberName ;
    115         structMemberType        #-> streamType ;
    116         structMemberName        #-> identifier ;
    117    
    118   //
    119         // s t r e a m   f u n c t i o n   d e f i n i t i o n s
    120         //
    121         funcDef                     -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;                               
    122         returnType                #-> type ;   
    123         parameterList     -> parameter (COMMA parameter)*;
    124         funcName                    #-> identifier ;
    125         parameter                   -> type parameterName ;
    126         parameterName     #-> identifier ;
    127 
    128   //
    129         // s t r e a m   f i l t e r   ( p r o c e d u r e )  d e f i n i t i o n s
    130         //
    131 
    132         //filterDef                             -> FILTER filterName LROUND filterParameterList? RROUND blockStmt TERMINATOR? ;                         
    133         //filterName              #-> identifier ;
    134         //filterParameterList     ->  parameter (COMMA parameter)*;
    135         //filterParameter             ->  filterParameterMode? type filterParameterName ;
    136   //filterParameterMode   -> (IN | OUT | INOUT) ;
    137         //fillterParameterName  #-> identifier ;
    138 
    139         //
    140         // s t a t e m e n t s
    141         //
    142         stmt                                      #->   varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
    143         blockStmt                               ->      LCURLY stmt* RCURLY ;
    144         varDecl                                 ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
    145         varName                                 #-> identifier ; 
    146         funcCallOrAssignStmt    #-> expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call
    147         assignRest                ->    assignOperator^! expr ;
    148         assignOperator  ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
    149                                                                     MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;           
    150         ifStmt                                  ->  IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                                                 
    151         whileStmt                               ->      WHILE LROUND expr RROUND blockStmt ;
    152         returnStmt                      ->      RETURN (expr)? TERMINATOR ;
     100    program     -> (structDecl | funcDef) *;    // ( filterDef )* graph;
     101
     102    //
     103    // s t r e a m   s t r u c t   d e f i n i t i o n s
     104    //
     105    structDecl          ->  STRUCT structName structDeclBody TERMINATOR? ;
     106    structDeclBody      ->  LCURLY (structMember TERMINATOR)+ RCURLY ;
     107    structMember        ->  structMemberType structMemberName ;
     108    structMemberType    #-> streamType ;
     109    structMemberName    #-> identifier ;
     110
     111    //
     112    // s t r e a m   f u n c t i o n   d e f i n i t i o n s
     113    //
     114    funcDef             ->  FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;               
     115    returnType          #-> type ;     
     116    parameterList       -> parameter (COMMA parameter)*;
     117    funcName            #-> identifier ;
     118    parameter           -> type parameterName ;
     119    parameterName       #-> identifier ;
     120
     121    //
     122    // s t r e a m   f i l t e r   ( p r o c e d u r e )  d e f i n i t i o n s
     123    //
     124
     125    //filterDef             -> FILTER filterName LROUND filterParameterList? RROUND blockStmt TERMINATOR? ;               
     126    //filterName            #-> identifier ;
     127    //filterParameterList   ->  parameter (COMMA parameter)*;
     128    //filterParameter       ->  filterParameterMode? type filterParameterName ;
     129    //filterParameterMode   -> (IN | OUT | INOUT) ;
     130    //fillterParameterName  #-> identifier ;
     131
     132    //
     133    // s t a t e m e n t s
     134    //
     135    stmt                        #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt  ;
     136    blockStmt                   ->      LCURLY stmt* RCURLY ;
     137    varDecl                     ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
     138    varName                     #->    identifier ; 
     139    funcCallOrAssignStmt        #->    expr (assignRest _promote_) ? TERMINATOR ; // add SA to validate expr is a function call
     140    assignRest                  ->      assignOperator^! expr ;
     141    assignOperator              ->      ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
     142                                        MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;       
     143    ifStmt                      ->      IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                         
     144    whileStmt                   ->      WHILE LROUND expr RROUND blockStmt ;
     145    returnStmt                  ->      RETURN (expr)? TERMINATOR ;
    153146
    154147  //forStmt       -> FOR LROUND elementName IN expr RROUND blockStmt ; // expr?
     
    158151  //annotationArgList -> (expr (COMMA expr)*) ?   
    159152
    160         //
    161         // e x p r e s s i o n s
    162         //     
    163         expr    #->     expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
    164         expr1   #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
    165         expr2   #-> NOT^^? expr3;                                                                               
    166         expr3   #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
    167         expr4   #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
    168         expr5   #-> LROUND expr RROUND
    169                                         | constant
    170                                         | compoundIdentifier (funcCallRest _promote_) ? ; // | compoundIdentifier ((funcCallRest _promote_) | (parameterizedFuncCallRest _promote_)) ? ;
     153    //
     154    // e x p r e s s i o n s
     155    //   
     156    expr        #->    expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
     157    expr1       #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
     158    expr2       #-> NOT^^? expr3;                                         
     159    expr3       #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
     160    expr4       #-> expr5 ((ADD^ | SUBTRACT^) expr4)? _leftAssoc_ ;
     161    expr5       #-> LROUND expr RROUND
     162                | constant
     163                | compoundIdentifier (funcCallRest _promote_) ? ; // | compoundIdentifier ((funcCallRest _promote_) | (parameterizedFuncCallRest _promote_)) ? ;
    171164
    172165// fieldWidthSpecifier
    173166
    174 //      parameterizedFuncCallRest               ->      LANGLE fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
    175 //      fieldWidth              #-> (LANGLE integer RANGLE ) ; 
    176                                                                                                                                                                                                                                                                        
    177         constant                                    #-> stringConstant | integerConstant ;
    178         integerConstant                 ->      INTEGER_CONST {@value = @@value;} ;
    179         stringConstant                  ->      STRING | SQ_STRING ;   
    180         compoundIdentifier      #-> identifier (DOT^ identifier)?;
    181         identifier                                ->    IDENTIFIER ;
    182   funcCallRest                    ->    LROUND^ funcCallArgList RROUND ;
    183         funcCallArgList                 ->      (expr (COMMA expr)*) ? ;       
    184 
    185   // TODO - idisa function call simd.popcount<>(); -> simd.popcount<128>() + ... + simd.popcount<128>()
    186   //       
    187   //        package.name - if 'esimd' then ...
    188   //   
    189                
    190   //   
    191         // t y p e s
    192         //
    193         type                                #->         primitiveType |
    194                                                                         streamType              |
    195                                                                 structType              ;
    196 
    197         primitiveType           #->     ( intType | voidType ) ;
    198         intType                           ->            INT    { @type = {{PrimitiveType.INTEGER}};  } ;
    199         voidType                          ->            VOID   { @type = {{PrimitiveType.VOID}}; } ;
    200 
    201         streamType                      ->              STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
    202                                                                                                                                 @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
    203                                                                                                                 } ;
    204                                        
    205         fieldWidthSpecifier     #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
    206         structType                      ->              STRUCT structName ;             
    207         structName                      #->     identifier ;                           
    208 
    209   //   
    210         // s t r e a m   g r a p h
    211         //
    212 
    213   // graph              ->  LCURLY filterCall* RCURLY TERMINATOR ? ;  // add varDecl* first impl
    214   // filterCall         ->  filterName LROUND RROUND TERMINATOR ;
    215   // filterCallArgList  ->  (expr (COMMA expr)*) ? ; 
    216 
    217  
    218 
    219   //graph {
    220   //  doProcess(fread("fin"), fwrite("out));
    221   //} 
    222 
    223  
    224 
    225 }
     167//    parameterizedFuncCallRest         ->      LANGLE fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND;
     168//    fieldWidth                        #->     (LANGLE integer RANGLE ) ;   
     169                                                                                                                                   
     170    constant                #-> stringConstant | integerConstant ;
     171    integerConstant         ->     INTEGER_CONST {@value = @@value;} ;
     172    stringConstant          ->     STRING | SQ_STRING ;   
     173    compoundIdentifier      #-> identifier (DOT^ identifier)?;
     174    identifier              ->     IDENTIFIER ;
     175    funcCallRest            ->     LROUND^ funcCallArgList RROUND ;
     176    funcCallArgList         ->     (expr (COMMA expr)*) ? ;     
     177
     178// TODO - idisa function call simd.popcount<>(); -> simd.popcount<128>() + ... + simd.popcount<128>()
     179//
     180//        package.name - if 'esimd' then ...
     181//
     182
     183    //
     184    // t y p e s
     185    //
     186    type                    #->     primitiveType   |
     187                                    streamType      |
     188                                    structType;
     189
     190    primitiveType           #->     ( intType | voidType ) ;
     191    intType                 ->      INT    { @type = {{PrimitiveType.INTEGER}};  } ;
     192    voidType                ->      VOID   { @type = {{PrimitiveType.VOID}}; } ;
     193
     194    streamType              ->      STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
     195                                                                    @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
     196                                                                } ;
     197                   
     198    fieldWidthSpecifier     #->      (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
     199    structType              ->       STRUCT structName ;       
     200    structName              #->      identifier ;               
     201
     202    //
     203    // s t r e a m   g r a p h
     204    //
     205
     206    // graph              ->  LCURLY filterCall* RCURLY TERMINATOR ? ;  // add varDecl* first impl
     207    // filterCall         ->  filterName LROUND RROUND TERMINATOR ;
     208    // filterCallArgList  ->  (expr (COMMA expr)*) ? ; 
     209
     210    //graph {
     211    //  doProcess(fread("fin"), fwrite("out));
     212    //} 
     213
     214}
  • proto/pabloj/trunk/input/test/ReadMe

    r3684 r3699  
    22
    33b2k -   A collection of .b2k test files.
    4                 Manual verification via testPabloBAST launcher set to a top level directory.
     4                Manual verification via b2kAST launcher set to a top level directory.
    55
    66s2k -   A collection of .s2k test files.
    7                 Manual verification via testPabloSAST launcher set to a top level directory.
     7                Manual verification via s2kAST launcher set to a top level directory.
    88                       
    99visitors -      A collection of .s2k files.
  • proto/pabloj/trunk/input/test/b2k/all/all.b2k

    r3684 r3699  
    311311kernel Classify_bytes_Validate_utf8 
    312312{
    313         state
     313        init
    314314        {
    315315         
     
    670670kernel Parse_refs
    671671{
    672         state
     672        init
    673673        {
    674674               
     
    753753kernel Validate_xml_names
    754754{
    755         state
     755        init
    756756        {
    757757               
     
    814814kernel Do_check_streams
    815815{
    816         state
     816        init
    817817        {
    818818               
  • proto/pabloj/trunk/input/test/b2k/proto/parabix2_pablo.b2k

    r3684 r3699  
    131131kernel Classify_bytes_Validate_utf8 
    132132{
    133         state
     133        init
    134134        {
    135135         
     
    490490kernel Parse_refs
    491491{
    492         state
     492        init
    493493        {
    494494               
     
    573573kernel Validate_xml_names
    574574{
    575         state
     575        init
    576576        {
    577577               
     
    634634kernel Do_check_streams
    635635{
    636         state
     636        init
    637637        {
    638638               
  • proto/pabloj/trunk/input/test/s2k/all/all.s2k

    r3697 r3699  
    1 struct bb {
     1struct BasisBits {
     2        stream<1> b1;
     3        stream<1> b2;
     4        stream<1> b3;
     5        stream<1> b4;
     6};
     7struct BasisBits {
     8        stream<1> b1;
     9        stream<1> b2;
     10        stream<1> b3;
     11        stream<1> b4;
     12};
     13
     14function void Foo() {
     15
     16}function void AssignmentExpressions() {       
     17        temp4 = temp;
     18        temp4 &= temp1 | temp2;
     19        temp4 |= temp1 ^ temp2;
     20        temp4 ^= temp1 & temp2;
     21};function void BasicExpressions() {
     22
     23        temp4 = temp;
     24        temp4 = temp1 | temp2;
     25        temp4 = temp1 ^ temp2;
     26        temp4 = temp1 & temp2;
     27        temp4 = temp1 ^ temp2 | temp3;
     28        temp4 = temp1 | temp2 ^ temp3;
     29        temp4 = temp1 & temp2 | temp3;
     30        temp4 = temp1 | temp2 & temp3;
     31        temp4 = temp1 & (temp2 | temp3);
     32        temp4 = (temp1 | temp2) & temp3;
     33//      temp4 = ~temp;
     34       
     35};
     36
     37function void Assignments() {
     38        stream<1> s;
     39        s = 0;
     40};function void Assignments() {
     41        stream<1> s;
     42        stream<1> a;
     43        stream<1> b;
     44        stream<1> c;
     45        //s |= 0;
     46        //s = a | b | c;
     47        s |= a;
     48        s |= a | b;
     49        s |= a | b | c;
     50        s |= a | b | c | d;
     51        // s = s | a | b | c;
     52};function void StreamStructs() {
     53
     54        // records
     55        temp4 = temp1.temp2;
     56        //temp4 = temp1.temp2.temp3;
     57       
     58        temp1.temp2 = temp4;
     59        //temp1.temp2.temp3 = temp4;
     60               
     61};function struct A FunctionExpressions() {
     62         stream<1> a = b.Advance();
     63};
     64function void Function(struct TagCallouts tagCallouts, struct Lex lex) {       
     65
     66        stream<1> starts_accum = 0;
     67        stream<1> ends_accum = 0;       
     68        stream<1> cursor = pablo.ScanToFirst(lex.opener);
     69       
     70        while (cursor) {
     71                starts_accum |= cursor;
     72                cursor = pablo.ScanTo(cursor, lex.marker &~ cursor);
     73                ends_accum |= cursor;
     74                cursor = pablo.ScanTo(cursor, (lex.marker | lex.terminator) &~ cursor);
     75                cursor = cursor & lex.marker;
     76        }
     77};
     78function void While() {
     79                       
     80        stream<1> cursor = 1;
     81       
     82        while (cursor) {
     83          cursor = pablo.Advance(cursor);
     84        }
     85}
     86function void While() {
     87       
     88        stream<1> cursor;
     89       
     90        while (cursor) {
     91                cursor = pablo.Advance(cursor);
     92                cursor = cursor &~ terminator;
     93        }
     94}
     95function void Function() {     
     96        stream<1> cursor1;
     97       
     98        while (cursor1) {
     99                stream<1> cursor2;
     100                while(cursor2) {
     101                        cursor = pablo.Advance(cursor);
     102                        // cursor = cursor &~ terminator;
     103                }
     104        }
     105}
     106function void localDecl() {
     107        struct BasisBits A;
     108        struct BasisBits B;
     109        struct BasisBits C;
     110};function void Assignments() {
     111        stream a;
     112        stream<1> s = a;
     113}function void localDecl() {
     114        stream<1> A;
     115        stream B;
     116}function void localDecl() {
     117
     118        struct BasisBits A;
     119
     120} function void Function() {   
     121       
     122        stream cursor;
     123       
     124        if(cursor & a) {
     125                if(cursor & b) {
     126               
     127                }
     128        }
     129       
     130}
     131function void Function() {     
     132       
     133        stream cursor;
     134       
     135        if(cursor & a) {
     136
     137        } else {
     138
     139        }
     140       
     141}
     142function void Function() {             
     143        stream cursor;
     144        if(cursor) {
     145
     146        }
     147}
     148function void Function() {     
     149       
     150        stream cursor;
     151       
     152        if(cursor & a) {
     153                if(cursor & b) {
     154               
     155                } else {
     156               
     157                }
     158
     159        } else {
     160
     161        }
     162       
     163}
     164
     165
     166struct Basis_bits{
     167    stream bit_0;
     168    stream bit_1;
     169    stream bit_2;
     170    stream bit_3;
     171    stream bit_4;
     172    stream bit_5;
     173    stream bit_6;
     174    stream bit_7;
     175};
     176
     177struct U8{
     178    stream unibyte;
     179    stream prefix;
     180    stream prefix2;
     181    stream prefix3;
     182    stream prefix4;
     183    stream suffix;
     184    stream badprefix;
     185    stream xE0;
     186    stream xED;
     187    stream xF0;
     188    stream xF4;
     189    stream xA0_xBF;
     190    stream x80_x9F;
     191    stream x90_xBF;
     192    stream x80_x8F;
     193    stream xEF;
     194    stream xBF;
     195    stream xBE;
     196    stream scope22;
     197    stream scope32;
     198    stream scope33;
     199    stream scope42;
     200    stream scope43;
     201    stream scope44;
     202    stream xE0_scope;
     203    stream xED_scope;
     204    stream xF0_scope;
     205    stream xF4_scope;
     206    stream xEF_scope;
     207};
     208
     209struct Lex{
     210    stream CR;
     211    stream LF;
     212    stream HT;
     213    stream SP;
     214    stream CRLF;
     215    stream RefStart;
     216    stream Semicolon;
     217    stream Colon;
     218    stream LAngle;
     219    stream RAngle;
     220    stream LBracket;
     221    stream RBracket;
     222    stream Exclam;
     223    stream QMark;
     224    stream Hyphen;
     225    stream Equals;
     226    stream SQuote;
     227    stream DQuote;
     228    stream Slash;
     229    stream Hash;
     230    stream x;
     231    stream ASCII_name_start;
     232    stream ASCII_name_char;
     233    stream NameScan;
     234    stream Digit;
     235    stream Hex;
     236    stream WS;
     237};
     238
     239struct Marker{
     240    stream LAngle_scope;
     241    stream Ref_opener;
     242    stream CD_closer;
     243};
     244
     245struct CtCDPI_Callouts{
     246    stream Ct_starts;
     247    stream Ct_ends;
     248    stream CD_starts;
     249    stream CD_ends;
     250    stream PI_starts;
     251    stream PI_name_starts;
     252    stream PI_name_ends;
     253    stream PI_ends;
     254};
     255
     256struct Ref_Callouts{
     257    stream GenRef_starts;
     258    stream GenRef_ends;
     259    stream DecRef_starts;
     260    stream DecRef_ends;
     261    stream HexRef_starts;
     262    stream HexRef_ends;
     263};
     264
     265struct Tag_Callouts{
     266    stream ElemName_starts;
     267    stream ElemName_ends;
     268    stream AttName_starts;
     269    stream AttName_ends;
     270    stream AttVal_starts;
     271    stream AttVal_ends;
     272    stream AttVal_spans;
     273    stream EmptyTag_marks;
     274    stream EndTag_marks;
     275};
     276
     277struct Check_streams{
     278    stream misc_mask;
     279    stream non_ascii_name_starts;
     280    stream non_ascii_names;
     281    stream tag_marks;
     282    stream name_follows;
     283    stream att_refs;
     284};
     285
     286function void Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
     287    stream temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
     288    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     289    stream temp3 = (temp2 & (~ temp1));
     290    stream temp4 = (basis_bits.bit_5 & (~ basis_bits.bit_4));
     291    stream temp5 = (basis_bits.bit_6 & (~ basis_bits.bit_7));
     292    stream temp6 = (temp4 & temp5);
     293    lex.RefStart = (temp3 & temp6);
     294    stream temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
     295    stream temp8 = (temp7 & (~ temp1));
     296    stream temp9 = (basis_bits.bit_4 & (~ basis_bits.bit_5));
     297    stream temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
     298    stream temp11 = (temp9 & temp10);
     299    lex.Semicolon = (temp8 & temp11);
     300    stream temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
     301    stream temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
     302    stream temp14 = (temp12 & (~ temp13));
     303    lex.LAngle = (temp8 & temp14);
     304    stream temp15 = (temp12 & temp5);
     305    lex.RAngle = (temp8 & temp15);
     306    stream temp16 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
     307    stream temp17 = (basis_bits.bit_3 & (~ basis_bits.bit_2));
     308    stream temp18 = (temp16 & temp17);
     309    lex.LBracket = (temp18 & temp11);
     310    stream temp19 = (basis_bits.bit_7 & (~ basis_bits.bit_6));
     311    stream temp20 = (temp12 & temp19);
     312    lex.RBracket = (temp18 & temp20);
     313    stream temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
     314    stream temp22 = (temp19 & (~ temp21));
     315    lex.Exclam = (temp3 & temp22);
     316    stream temp23 = (temp12 & temp10);
     317    lex.QMark = (temp8 & temp23);
     318    lex.Hyphen = (temp3 & temp20);
     319    lex.Equals = (temp8 & temp20);
     320    stream temp24 = (temp4 & temp10);
     321    lex.SQuote = (temp3 & temp24);
     322    stream temp25 = (temp5 & (~ temp21));
     323    lex.DQuote = (temp3 & temp25);
     324    lex.Slash = (temp3 & temp23);
     325    stream temp26 = (temp10 & (~ temp21));
     326    lex.Hash = (temp3 & temp26);
     327    stream temp27 = (temp16 & temp7);
     328    stream temp28 = (temp9 & (~ temp13));
     329    lex.x = (temp27 & temp28);
     330    stream temp29 = (temp9 & temp5);
     331    lex.Colon = (temp8 & temp29);
     332    stream temp30 = (temp18 & temp23);
     333    stream temp31 = (temp30 | lex.Colon);
     334    stream temp32 = (temp16 & (~ basis_bits.bit_2));
     335    stream temp33 = (basis_bits.bit_5 | temp10);
     336    stream temp34 = (basis_bits.bit_4 & temp33);
     337    stream temp35 = (~ temp34);
     338    stream temp36 = (temp21 | temp13);
     339    stream temp37 = ((basis_bits.bit_3 & temp35) | ((~ basis_bits.bit_3) & temp36));
     340    stream temp38 = (temp32 & temp37);
     341    stream temp39 = (temp31 | temp38);
     342    stream temp40 = (temp16 & basis_bits.bit_2);
     343    stream temp41 = (temp40 & temp37);
     344    lex.ASCII_name_start = (temp39 | temp41);
     345    stream temp42 = (temp30 | lex.Hyphen);
     346    stream temp43 = (temp3 & temp15);
     347    stream temp44 = (temp42 | temp43);
     348    stream temp45 = (temp8 & (~ temp34));
     349    stream temp46 = (temp44 | temp45);
     350    stream temp47 = (temp46 | temp38);
     351    lex.ASCII_name_char = (temp47 | temp41);
     352    lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
     353    stream temp48 = (temp1 | basis_bits.bit_2);
     354    stream x00_x1F = (~ temp48);
     355    stream temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
     356    stream temp50 = (temp1 | temp49);
     357    lex.CR = (temp20 & (~ temp50));
     358    lex.LF = (temp29 & (~ temp50));
     359    stream temp51 = (temp9 & temp19);
     360    lex.HT = (temp51 & (~ temp50));
     361    lex.SP = (temp3 & (~ temp36));
     362    stream temp52 = (temp20 | temp29);
     363    stream temp53 = (temp52 | temp51);
     364    stream temp54 = (temp53 & (~ temp50));
     365    lex.WS = (temp54 | lex.SP);
     366    stream temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
     367    stream temp56 = (basis_bits.bit_4 & temp55);
     368    lex.Digit = (temp8 & (~ temp56));
     369    stream temp57 = (temp16 & (~ temp49));
     370    stream temp58 = (temp57 & (~ basis_bits.bit_4));
     371    stream temp59 = (~ temp10);
     372    stream temp60 = ((basis_bits.bit_5 & temp59) | ((~ basis_bits.bit_5) & temp13));
     373    stream temp61 = (temp58 & temp60);
     374    stream temp62 = (lex.Digit | temp61);
     375    stream temp63 = (temp16 & temp2);
     376    stream temp64 = (temp63 & (~ basis_bits.bit_4));
     377    stream temp65 = (temp64 & temp60);
     378    lex.Hex = (temp62 | temp65);
     379    stream lex_error = (x00_x1F & (~ lex.WS));
     380    pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
     381    u8.unibyte = (~ basis_bits.bit_0);
     382    u8.suffix = pablo.Mask(1,0);
     383    stream u8_error = pablo.Mask(1,0);
     384    stream u8_FFFE_FFFF = pablo.Mask(1,0);
     385    stream u8anyscope = pablo.Mask(1,0);
     386    if (basis_bits.bit_0) {
     387        u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     388        u8.prefix2 = (u8.prefix & (~ basis_bits.bit_2));
     389        u8.prefix3 = (u8.prefix & temp2);
     390        u8.prefix4 = (u8.prefix & temp7);
     391        u8.suffix = (basis_bits.bit_0 & (~ basis_bits.bit_1));
     392        stream temp66 = (u8.prefix & (~ temp49));
     393        stream temp67 = (temp21 | basis_bits.bit_6);
     394        stream temp68 = (temp66 & (~ temp67));
     395        stream temp69 = (basis_bits.bit_5 & temp13);
     396        stream temp70 = (basis_bits.bit_4 | temp69);
     397        stream temp71 = (u8.prefix4 & temp70);
     398        u8.badprefix = (temp68 | temp71);
     399        u8_error = u8.badprefix;
     400        u8.scope22 = pablo.Advance(u8.prefix2);
     401        u8anyscope = u8.scope22;
     402        if ((u8.prefix3 | u8.prefix4)) {
     403            stream xE0 = (u8.prefix3 & (~ temp36));
     404            stream xED = (u8.prefix3 & temp20);
     405            stream xF0 = (u8.prefix4 & (~ temp36));
     406            stream temp72 = (temp4 & (~ temp13));
     407            stream xF4 = (u8.prefix4 & temp72);
     408            u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
     409            u8.x80_x9F = (u8.suffix & (~ basis_bits.bit_2));
     410            u8.x90_xBF = (u8.suffix & temp49);
     411            u8.x80_x8F = (u8.suffix & (~ temp49));
     412            stream xEF = (u8.prefix3 & temp23);
     413            stream temp73 = (u8.suffix & temp7);
     414            u8.xBF = (temp73 & temp23);
     415            u8.xBE = (temp73 & temp15);
     416            u8.scope32 = pablo.Advance(u8.prefix3);
     417            u8.scope33 = pablo.Advance(u8.scope32);
     418            u8.scope42 = pablo.Advance(u8.prefix4);
     419            u8.scope43 = pablo.Advance(u8.scope42);
     420            u8.scope44 = pablo.Advance(u8.scope43);
     421            stream E0_F0_scope = pablo.Advance((xE0 | xF0));
     422            stream ED_F4_scope = pablo.Advance((xED | xF4));
     423            u8.xE0_scope = (u8.scope32 & E0_F0_scope);
     424            u8.xED_scope = (u8.scope32 & ED_F4_scope);
     425            u8.xF0_scope = (u8.scope42 & E0_F0_scope);
     426            u8.xF4_scope = (u8.scope42 & ED_F4_scope);
     427            u8.xEF_scope = pablo.Advance(xEF);
     428            stream u8lastscope = ((u8.scope22 | u8.scope33) | u8.scope44);
     429            u8anyscope = (((u8lastscope | u8.scope32) | u8.scope42) | u8.scope43);
     430            stream u8error1 = (u8.xE0_scope & u8.x80_x9F);
     431            stream u8error2 = (u8.xED_scope & u8.xA0_xBF);
     432            stream u8error3 = (u8.xF0_scope & u8.x80_x8F);
     433            stream u8error4 = (u8.xF4_scope & u8.x90_xBF);
     434            u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
     435            stream EF_BF_pending = pablo.Advance((u8.xEF_scope & u8.xBF));
     436            u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
     437        }
     438        stream u8mismatch = (u8anyscope ^ u8.suffix);
     439        pablo.assert_0(((u8_error | u8mismatch) | u8_FFFE_FFFF), "UTF-8 error found");
     440    }
     441}
     442
     443function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
     444    ctCDPI_Callouts.Ct_starts = pablo.Mask(1,0);
     445    ctCDPI_Callouts.Ct_ends = pablo.Mask(1,0);
     446    ctCDPI_Callouts.CD_starts = pablo.Mask(1,0);
     447    ctCDPI_Callouts.CD_ends = pablo.Mask(1,0);
     448    ctCDPI_Callouts.PI_starts = pablo.Mask(1,0);
     449    ctCDPI_Callouts.PI_name_starts = pablo.Mask(1,0);
     450    ctCDPI_Callouts.PI_name_ends = pablo.Mask(1,0);
     451    ctCDPI_Callouts.PI_ends = pablo.Mask(1,0);
     452    stream CtCDPI_starts = pablo.Mask(1,0);
     453    stream CtCDPI_ends = pablo.Mask(1,0);
     454    stream ctCDPI_mask = pablo.Mask(1,0);
     455    stream v = (lex.LAngle | lex.Hyphen);
     456    stream w = (lex.Hyphen | lex.QMark);
     457    stream v1 = pablo.AdvanceN(v, 1);
     458    stream w1 = pablo.AdvanceN(w, 1);
     459    stream LAngle_scope = (v1 & (~ w1));
     460    stream PI_opener = (LAngle_scope & lex.QMark);
     461    stream CtCD_opener = (LAngle_scope & lex.Exclam);
     462    stream CtCDPI_opener = (PI_opener | CtCD_opener);
     463    stream CD_closer = pablo.Mask(1,0);
     464    stream DoubleHyphen = ((v1 & w1) & lex.Hyphen);
     465    if (lex.RBracket) {
     466        stream DoubleRBracket = (pablo.Advance(lex.RBracket) & lex.RBracket);
     467        CD_closer = (pablo.Advance(DoubleRBracket) & lex.RAngle);
     468    }
     469    stream PI_closer = ((w1 & (~ v1)) & lex.RAngle);
     470    stream CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener);
     471    while (CtCDPI_Cursor) {
     472        CtCDPI_starts |= CtCDPI_Cursor;
     473        stream PI_Cursor = (CtCDPI_Cursor & PI_opener);
     474        stream CD_Ct_Cursor = pablo.Advance((CtCDPI_Cursor & (~ PI_Cursor)));
     475        stream CD_Cursor = (CD_Ct_Cursor & lex.LBracket);
     476        stream Ct_Cursor = (CD_Ct_Cursor & lex.Hyphen);
     477        if (PI_Cursor) {
     478            ctCDPI_Callouts.PI_starts |= PI_Cursor;
     479            PI_Cursor = pablo.Advance(PI_Cursor);
     480            ctCDPI_Callouts.PI_name_starts |= PI_Cursor;
     481            stream PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan);
     482            stream PI_error = (PI_Cursor & PI_name_end);
     483            stream PI_noWS = (PI_name_end & (~ lex.WS));
     484            PI_error |= ((PI_noWS & (~ lex.QMark)) | (pablo.Advance(PI_noWS) & (~ PI_closer)));
     485            pablo.assert_0(PI_error, "Error in PI syntax");
     486            ctCDPI_Callouts.PI_name_ends |= PI_name_end;
     487            PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer);
     488            ctCDPI_Callouts.PI_ends |= PI_Cursor;
     489            CtCDPI_ends |= PI_Cursor;
     490        }
     491        if (CD_Cursor) {
     492            ctCDPI_Callouts.CD_starts |= CD_Cursor;
     493            CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer);
     494            ctCDPI_Callouts.CD_ends |= CD_Cursor;
     495            CtCDPI_ends |= CD_Cursor;
     496        }
     497        if (Ct_Cursor) {
     498            ctCDPI_Callouts.Ct_starts |= Ct_Cursor;
     499            Ct_Cursor = pablo.Advance(Ct_Cursor);
     500            stream Ct_error = (Ct_Cursor & (~ lex.Hyphen));
     501            Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor));
     502            Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen));
     503            pablo.assert_0((Ct_error | (Ct_Cursor & (~ lex.RAngle))), "Error in comment syntax");
     504            ctCDPI_Callouts.Ct_ends |= Ct_Cursor;
     505            CtCDPI_ends |= Ct_Cursor;
     506        }
     507        CtCDPI_Cursor = ((PI_Cursor | CD_Cursor) | Ct_Cursor);
     508        ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends);
     509        pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax");
     510        CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener);
     511    }
     512    check_streams.misc_mask = ((((lex.WS | lex.LAngle) | pablo.InclusiveSpan((ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts), (ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends))) | CtCDPI_starts) & EOF_mask);
     513    marker.LAngle_scope = (LAngle_scope & (~ ctCDPI_mask));
     514    marker.Ref_opener = (lex.RefStart & (~ ctCDPI_mask));
     515    marker.CD_closer = (CD_closer & (~ ctCDPI_mask));
     516}
     517
     518function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
     519    stream EqExpected = pablo.Mask(1,0);
     520    stream AttListEnd = pablo.Mask(1,0);
     521    stream DQuoteDelim = (lex.DQuote | lex.LAngle);
     522    stream SQuoteDelim = (lex.SQuote | lex.LAngle);
     523    stream AttListDelim = (lex.Slash | lex.RAngle);
     524    tag_Callouts.ElemName_starts = (marker.LAngle_scope & (~ lex.Slash));
     525    tag_Callouts.EndTag_marks = (marker.LAngle_scope & lex.Slash);
     526    tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
     527    stream ParseError = (tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends);
     528    tag_Callouts.AttName_starts = pablo.Mask(1,0);
     529    tag_Callouts.AttName_ends = pablo.Mask(1,0);
     530    tag_Callouts.AttVal_starts = pablo.Mask(1,0);
     531    tag_Callouts.AttVal_ends = pablo.Mask(1,0);
     532    if ((tag_Callouts.ElemName_ends & lex.WS)) {
     533        stream AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
     534        AttListEnd = (AfterWS & AttListDelim);
     535        stream AttNameStart = (AfterWS & (~ AttListDelim));
     536        while (AttNameStart) {
     537            ParseError |= (AttNameStart & (~ lex.NameScan));
     538            tag_Callouts.AttName_starts |= AttNameStart;
     539            stream AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan);
     540            tag_Callouts.AttName_ends |= AttNameFollow;
     541            if ((AttNameFollow & lex.WS)) {
     542                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
     543            }
     544            else {
     545                EqExpected = AttNameFollow;
     546            }
     547            ParseError |= (EqExpected & (~ lex.Equals));
     548            stream AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS);
     549            tag_Callouts.AttVal_starts |= AttValPos;
     550            stream DQuoteAttVal = (AttValPos & lex.DQuote);
     551            stream SQuoteAttVal = (AttValPos & lex.SQuote);
     552            stream DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim);
     553            stream SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim);
     554            stream AttValEnd = (DQuoteAttEnd | SQuoteAttEnd);
     555            ParseError |= ((AttValPos | AttValEnd) & (~ (lex.DQuote | lex.SQuote)));
     556            stream AttValFollow = pablo.Advance(AttValEnd);
     557            tag_Callouts.AttVal_ends |= AttValFollow;
     558            if ((AttValFollow & lex.WS)) {
     559                AfterWS = pablo.ScanThru(AttValFollow, lex.WS);
     560                AttListEnd |= (AfterWS & AttListDelim);
     561                AttNameStart = (AfterWS & (~ AttListDelim));
     562            }
     563            else {
     564                AttListEnd |= (AttValFollow & AttListDelim);
     565                AttNameStart = (AttValFollow & (~ AttListDelim));
     566            }
     567            ParseError |= (AttValFollow & AttNameStart);
     568        }
     569    }
     570    else {
     571        AttListEnd = (tag_Callouts.ElemName_ends & AttListDelim);
     572        ParseError |= (tag_Callouts.ElemName_ends & (~ AttListDelim));
     573    }
     574    stream STagEnds = (AttListEnd & lex.RAngle);
     575    tag_Callouts.EmptyTag_marks = pablo.Advance((AttListEnd & lex.Slash));
     576    ParseError |= (tag_Callouts.EmptyTag_marks & (~ lex.RAngle));
     577    stream EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan);
     578    if ((EndTagEnds & lex.WS)) {
     579        EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS);
     580    }
     581    ParseError |= (EndTagEnds & (~ lex.RAngle));
     582    pablo.assert_0(ParseError, "Tag parsing error found");
     583    tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends);
     584}
     585
     586function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
     587    ref_Callouts.GenRef_starts = pablo.Mask(1,0);
     588    ref_Callouts.GenRef_ends = pablo.Mask(1,0);
     589    ref_Callouts.DecRef_starts = pablo.Mask(1,0);
     590    ref_Callouts.DecRef_ends = pablo.Mask(1,0);
     591    ref_Callouts.HexRef_starts = pablo.Mask(1,0);
     592    ref_Callouts.HexRef_ends = pablo.Mask(1,0);
     593    stream ref_error = pablo.Mask(1,0);
     594    if (marker.Ref_opener) {
     595        stream Ref_scope = pablo.Advance(marker.Ref_opener);
     596        stream NumRef2 = (Ref_scope & lex.Hash);
     597        ref_Callouts.GenRef_starts = (Ref_scope & (~ lex.Hash));
     598        stream NumRef3 = pablo.Advance(NumRef2);
     599        stream HexRef3 = (NumRef3 & lex.x);
     600        ref_Callouts.DecRef_starts = (NumRef3 & (~ lex.x));
     601        ref_Callouts.HexRef_starts = pablo.Advance(HexRef3);
     602        ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan);
     603        ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit);
     604        ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex);
     605        stream ref_error1 = (ref_Callouts.DecRef_starts & (~ lex.Digit));
     606        stream ref_error2 = (ref_Callouts.HexRef_starts & (~ lex.Hex));
     607        stream ref_ends = ((ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends) | ref_Callouts.HexRef_ends);
     608        stream ref_error3 = (ref_ends & (~ lex.Semicolon));
     609        pablo.assert_0(((ref_error1 | ref_error2) | ref_error3), "Reference error found");
     610    }
     611}
     612
     613function void Validate_xml_names(struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Lex lex, struct U8 u8, struct Check_streams check_streams) {
     614    stream PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
     615    stream GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
     616    stream ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
     617    stream AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends);
     618    stream qname_stream = (ElemNames | AttNames);
     619    stream ncname_stream = (PI_names | GenRefs);
     620    stream name_stream = (qname_stream | ncname_stream);
     621    stream name_start = (name_stream & (~ pablo.Advance(name_stream)));
     622    stream name_cursor = (name_stream & (~ pablo.Advance(name_stream)));
     623    stream void_prefix_err = (name_cursor & lex.Colon);
     624    stream namespace_sep = (pablo.ScanThru(name_cursor, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
     625    stream local_part_start = pablo.Advance(namespace_sep);
     626    stream local_part_err = (local_part_start & (~ lex.NameScan));
     627    stream colon2_err = (pablo.ScanThru(local_part_start, (lex.NameScan & (~ lex.Colon))) & lex.Colon);
     628    stream ncname_err = (ncname_stream & lex.Colon);
     629    pablo.assert_0((((void_prefix_err | local_part_err) | colon2_err) | ncname_err), "name syntax error");
     630    check_streams.non_ascii_name_starts = (name_start & (~ lex.ASCII_name_start));
     631    check_streams.non_ascii_names = (((name_stream & (~ name_start)) & (~ lex.ASCII_name_char)) & (~ u8.suffix));
     632}
     633
     634function void Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
     635    pablo.assert_0((marker.CD_closer & (~ tag_Callouts.AttVal_spans)), "Error: ]]> in text");
     636    check_streams.tag_marks = (((tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts) | tag_Callouts.EndTag_marks) | tag_Callouts.AttName_starts);
     637    check_streams.name_follows = (tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends);
     638    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
     639}struct bb {
    2640        stream<1> a;
    3641
  • proto/pabloj/trunk/input/test/s2k/statements/assign/assign4.s2k

    r3691 r3699  
    33        // records
    44        temp4 = temp1.temp2;
    5         temp4 = temp1.temp2.temp3;
     5        //temp4 = temp1.temp2.temp3;
    66       
    77        temp1.temp2 = temp4;
    8         temp1.temp2.temp3 = temp4;
     8        //temp1.temp2.temp3 = temp4;
    99               
    1010};
  • proto/pabloj/trunk/output/clang/idisa_definitions.h

    r3192 r3699  
    11// GENERATED CODE. DO NOT MODIFY.
    2 // This template includes the minimal set
    32//
     3// This template includes the minimal set of runtime support libraries required
     4// to support compilation of PabloJ generated C++ code (bitblock.hpp, carryQ.hpp,
     5// pabloSupport.hpp, error_tracker.hpp)
     6//
     7// (c) 2012, 2013 Robert D. Cameron, Ken Herdy
     8// All rights reserved.
     9// Licensed to International Characters, Inc. under Academic Free License 3.0
     10//
     11//////////////////////////////////////////////////////////////////////////////////////////
    412// @ global - Stream structure and stream function declarations.
    513//
    614//////////////////////////////////////////////////////////////////////////////////////////
     15//
     16#ifndef PABLO_DEFINITIONS_HPP
     17#define PABLO_DEFINITIONS_HPP
    718
    8 #ifndef IDISA_DEFINITIONS_H
    9 #define IDISA_DEFINITIONS_H
     19// runtime libraries
     20#include <simd-lib/bitblock.hpp>
     21#include <simd-lib/carrySet.hpp>
     22#include <simd-lib/pabloSupport.hpp>
     23
     24// migrate error tracker, line/column tracker to compiler runtime
     25#include <ErrorTracker.h>
     26ErrorTracker error_tracker;
     27
     28#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
     29BitBlock EOF_mask = simd<1>::constant<1>();
    1030
    1131// namespace pablo
     
    1535        KernelName()
    1636        {
    17                
    1837        }
    19          
     38       
    2039        IDISA_INLINE void do_block()
    2140        {
     
    2544                BitBlock k;
    2645                BitBlock r;
    27                 bool t;
    28                 t = bitblock_any(a);
    29                 r = bitblock_slli(a, 10);
    30                 bitblock_store_unaligned(a, &b);
    31                 r = bitblock_load_aligned(&b);
    32                 r = simd_not(a);
    33                 r = simd_nor(a, b);
    34                 r = simd_ifh_16(a, b, c);
    35                 r = simd_constant_2(3);
    36                 r = simd_slli_8(a, 1);
    37                 r = simd_add_1(a, b);
    38                 r = simd_sub_2(a, b);
    39                 r = simd_mult_4(a, b);
    40                 r = simd_eq_8(a, b);
    41                 r = simd_gt_16(a, b);
    42                 r = simd_ugt_32(a, b);
    43                 r = simd_lt_64(a, b);
    44                 r = simd_ult_128(a, b);
    45                 r = simd_max_128(a, b);
    46                 r = simd_umax_1(a, b);
    47                 r = simd_min_2(a, b);
    48                 r = simd_umin_4(a, b);
    49                 r = simd_sll_64(a, b);
    50                 r = simd_srl_64(a, b);
     46
     47                print_register<BitBlock>("r",r);
    5148        }
    5249       
    53         IDISA_INLINE void do_final_block()
     50        void do_final_block()
    5451        {
    5552               
    5653        }
    5754       
    58         CarryDeclare(carry_set_0, 0, 0);
     55        CarryDeclare(carry_set_0,0,0);
    5956};
    6057 
     
    6259// } // pablo namespace
    6360
    64 #endif // IDISA_DEFINITIONS_H
     61#endif // PABLO_DEFINITIONS_HPP
  • proto/pabloj/trunk/output/clang/test.c

    r3134 r3699  
    1 #include "idisa_definitions.h"
     1#include "idisa_definitions.hpp"
    22#include <stdlib.h>
    33#include <stdio.h>
  • proto/pabloj/trunk/output/cpplang/Makefile

    r3231 r3699  
    1 OUTFILE=test
    2 SRCFILE=test.cpp
     1OUTFILE=idisa
     2SRCFILE=idisa.cpp
    33
    44CC= g++ $(CFLAGS)
  • proto/pabloj/trunk/output/cpplang/idisa_definitions.hpp

    r3369 r3699  
    7171                BitBlock k;
    7272                BitBlock r;
    73                 r = bitblock::any(a);
     73                r = simd<BitBlock>.add(a,a);
    7474        }
    7575       
  • proto/pabloj/trunk/runConfigurations/b2kCompiler.launch

    r3682 r3699  
    33<stringAttribute key="bad_container_name" value="/proto/pabloj/runConfigurations"/>
    44<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
    5 <listEntry value="/pabloj/src/application/PabloJ.java"/>
     5<listEntry value="/pabloj/src/application/S2K.java"/>
    66</listAttribute>
    77<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
    88<listEntry value="1"/>
    99</listAttribute>
    10 <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="application.PabloJ"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-b ${project_loc:pabloj}/input/test/pabloB/test.pablob -o idisa_definitions.hpp"/>
     10<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="application.S2K"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-b ${project_loc:pabloj}/input/test/b2k/idisa.b2k -o idisa_definitions.hpp"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pabloj/trunk/src/application/config/Configuration.java

    r3277 r3699  
    55 *
    66 * @author Ken Herdy <ksherdy at sfu dot ca>
     7 * @author Tom Shermer <shermer at sfu dot ca>
    78 */
    89
     
    1516public class Configuration {   
    1617        // General definitions used in main application
    17         public  static final String COMPILER_NAME               = "PabloJ";     
    18         public  static final String WARNING_MESSAGE     = "GENERATED CODE. DO NOT MODIFY.";
     18        public  static final String COMPILER_NAME               = "s2k";       
     19        public  static final String WARNING_MESSAGE             = "GENERATED CODE. DO NOT MODIFY.";
    1920        public  static final int    EXIT_CODE_FOR_ERROR         = 1;
    2021
     
    2526        private static final String DEFAULT_OUTPUT_BASE_DIRECTORY    = "output/";
    2627        private static final String DEFAULT_TEMPLATE_BASE_DIRECTORY  = "input/templates/";
    27         private static final String DEFAULT_TEMPLATE_FILENAME        = "pablo_definitions.template";
    28 
     28        private static final String DEFAULT_TEMPLATE_FILENAME        = "definitions.template";
    2929       
    3030        // public static factory
     
    3333    }
    3434
    35    
    3635        private CommandLine cli;
    3736        private Target target = DEFAULT_TARGET;
     
    5352        private SourceLanguage configureSource(CommandLine cli) {
    5453                if(cli.hasOption("s")) {
    55                         return SourceLanguage.PABLO_S;
     54                        return SourceLanguage.S2K;
    5655                }               
    5756                if(cli.hasOption("b")) {
    58                         return SourceLanguage.PABLO_B;
     57                        return SourceLanguage.B2K;
    5958                }
    60                 assert false : "neither pabloS nor pabloB selected.";
     59                assert false : "Neither s2k nor b2k language option specified.";
    6160                return null;
    6261        }
  • proto/pabloj/trunk/src/application/config/ConfigurationOptions.java

    r3289 r3699  
    3535
    3636                addrequiredOptionGroup(
    37                         nonrequiredOption("s", "pablos",       HAS_ARG, "PabloS input file."),
    38                         nonrequiredOption("b", "pablob",       HAS_ARG, "PabloB input file.")
     37                        nonrequiredOption("s", "s2k",              HAS_ARG, "s2k input file."),
     38                        nonrequiredOption("b", "b2k",          HAS_ARG, "b2k input file.")
    3939                );
    4040
     
    4343                addNonrequiredOption("o", "output",        HAS_ARG, COMPILER_NAME + " output file.");   
    4444                addNonrequiredOption("O", "outputdir",     HAS_ARG, COMPILER_NAME + " output directory.");     
    45                 addNonrequiredOption("e", "error",         HAS_ARG, "Name/qualified name of error routine.");   
     45                addNonrequiredOption("e", "error",         HAS_ARG, "Name or qualified name of an error routine.");     
    4646                addNonrequiredOption("a", "align",         NO_ARG,  "Add ASSERT_BITBLOCK_ALIGN statments.");   
    4747                addNonrequiredOption("d", "dump",          NO_ARG,  "Add SIMD register dump statements.");                                     
    48                 addNonrequiredOption("x", "language",      HAS_ARG, "Target language. Targets include: 'cpplang', 'clang (not yet supported)'.");
     48                addNonrequiredOption("x", "language",      HAS_ARG, "Target language. Targets include: 'cpplang', 'clang' (not yet supported).");
    4949                addNonrequiredOption("p", "experimental",  NO_ARG,  "Experimental mode.");                      // TS: unused           
    5050
  • proto/pabloj/trunk/src/application/config/SourceLanguage.java

    r3277 r3699  
     1/**
     2 * Source language configuration.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 * @author Tom Shermer <shermer at sfu dot ca>
     6 *
     7 */
    18package application.config;
    29
    3 // TS: original had PABLOS_EXT, PABLOB_EXT defined as extensions but never used them.  Remove extensions?
    410public enum SourceLanguage {
    5         PABLO_S(".pablos", "s"),
    6         PABLO_B(".pablob", "b");
     11        S2K(".s2k", "s"),
     12        B2K(".b2k", "b");
    713       
    814        private String extension;
  • proto/pabloj/trunk/src/application/generators/ASTGenerator.java

    r3387 r3699  
    11/*
    2  * PabloS parser wrapper.
     2 * s2k parser wrapper.
    33 *
    44 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    77package application.generators;
    88
    9 import pabloS.logging.ScatterLogger;
     9import s2k.logging.ScatterLogger;
    1010
    1111public class ASTGenerator {
    1212       
    13         public static pabloS.ast.ASTNode buildPabloSAST(String pabloSFile) throws ASTGeneratorException {                       
     13        public static s2k.ast.ASTNode buildS2KAST(String s2kFile) throws ASTGeneratorException {                       
    1414
    15                 pabloS.lexicalAnalyzer.LexicalController lexController = pabloS.lexicalAnalyzer.LexicalController.make(pabloSFile);
    16                 pabloS.ast.ASTNode ASTTree = pabloS.parser.Parser.parse(lexController);
     15                s2k.lexicalAnalyzer.LexicalController lexController = s2k.lexicalAnalyzer.LexicalController.make(s2kFile);
     16                s2k.ast.ASTNode ASTTree = s2k.parser.Parser.parse(lexController);
    1717       
    1818                if(thereAreErrors()) {
     
    2323        }               
    2424
    25         static public pabloB.ast.ASTNode buildPabloBAST(String pabloBFile) throws ASTGeneratorException {                       
     25        static public b2k.ast.ASTNode buildB2KAST(String b2kFile) throws ASTGeneratorException {                       
    2626
    27                 pabloB.lexicalAnalyzer.LexicalController lexController = pabloB.lexicalAnalyzer.LexicalController.make(pabloBFile);
    28                 pabloB.ast.ASTNode ASTTree = pabloB.parser.Parser.parse(lexController);
     27                b2k.lexicalAnalyzer.LexicalController lexController = b2k.lexicalAnalyzer.LexicalController.make(b2kFile);
     28                b2k.ast.ASTNode ASTTree = b2k.parser.Parser.parse(lexController);
    2929       
    3030                if(thereAreErrors()) {
  • proto/pabloj/trunk/src/application/generators/ASTGeneratorException.java

    r2998 r3699  
    22
    33public class ASTGeneratorException extends Exception {
    4 
    5         /**
    6          *      Default
    7          */
     4        /**     Default  */
    85        private static final long serialVersionUID = 1L;
    9 
    106}
  • proto/pabloj/trunk/src/application/generators/AbstractTemplateContentsGenerator.java

    r3010 r3699  
    77package application.generators;
    88
    9 import toolchain.pabloB.codeGenerator.visitors.AbstractUnparser;
     9import toolchain.b2k.codeGenerator.visitors.AbstractUnparser;
    1010
    1111abstract public class AbstractTemplateContentsGenerator {
    1212   
    13         protected pabloB.ast.ProgramNode programNode;
     13        protected b2k.ast.ProgramNode programNode;
    1414        protected AbstractUnparser unparser;
    1515    protected String outputDirectory;
     
    1717        protected String targetFilePath;
    1818               
    19         public AbstractTemplateContentsGenerator(pabloB.ast.ProgramNode programNode,
     19        public AbstractTemplateContentsGenerator(b2k.ast.ProgramNode programNode,
    2020                                                                                AbstractUnparser unparser,
    2121                                                                                String outputDirectory,
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3401 r3699  
    11/*
    2  * High-level module that captures the logic to generates application code based on the application configuration.
     2 * High-level module that captures the logic to generates application
     3 * code based on the application configuration.
    34 *
    4  * <ksherdy at sfu dot ca>
     5 * @author Ken Herdy ksherdy at sfu dot ca
     6 * @author Tom Shermer shermer at sfu dot ca
    57 */
    68
    79package application.generators;
    810
    9 import toolchain.pabloB.codeGenerator.idisa.IDISABuiltin2C;
    10 import toolchain.pabloB.codeGenerator.idisa.IDISABuiltin2CPP;
    11 import toolchain.pabloB.codeGenerator.visitors.AbstractUnparser;
    12 import toolchain.pabloB.codeGenerator.visitors.Unparser;
    13 import toolchain.pabloB.transformer.visitors.pabloB2PabloB.PabloB2PabloBController;
     11import toolchain.b2k.codeGenerator.idisa.IDISABuiltin2C;
     12import toolchain.b2k.codeGenerator.idisa.IDISABuiltin2CPP;
     13import toolchain.b2k.codeGenerator.visitors.AbstractUnparser;
     14import toolchain.b2k.codeGenerator.visitors.Unparser;
     15import toolchain.b2k.transformer.visitors.B2K2B2K.B2K2B2KController;
    1416
    15 import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBTransformer;
    16 import toolchain.pabloS.transformer.visitors.pabloS2pabloS.PabloS2SPabloController;
     17import toolchain.s2k.transformer.visitors.S2K2B2K.S2K2B2KTransformer;
     18import toolchain.s2k.transformer.visitors.S2K2S2K.S2K2S2kController;
    1719
    1820import application.config.Configuration;
     
    2628       
    2729        public ApplicationGenerator(Configuration applicationConfiguration) {
    28                 pabloS.tokens.Tokens.setPrintLevel(pabloS.tokens.Tokens.Level.FULL);           
     30                s2k.tokens.Tokens.setPrintLevel(s2k.tokens.Tokens.Level.FULL);         
    2931                this.applicationConfiguration = applicationConfiguration;
    3032        }
     
    3840               
    3941                // Transformation configurations to support multiple backends
    40                 toolchain.pabloS.lang.PabloSBuiltinEncoder pabloSbuiltinsEncoder  = null;
    41                 toolchain.pabloB.lang.BuiltinEncoder pabloBBuiltinsEncoder  = null;
     42                toolchain.s2k.lang.BuiltinEncoder s2kBuiltinsEncoder  = null;
     43                toolchain.b2k.lang.BuiltinEncoder b2kBuiltinsEncoder  = null;
    4244                AbstractUnparser unparser                                                                       = null;
    4345               
    44                 toolchain.pabloS.lang.carrySet.CarrySetEncoder carrySetEncoder = null;
     46                toolchain.s2k.lang.carrySet.CarrySetEncoder carrySetEncoder = null;
    4547                               
    4648                if(applicationConfiguration.getTarget() == Target.C_LANG) {
    47             pabloSbuiltinsEncoder       = new toolchain.pabloS.lang.PabloSBuiltin2C();
    48             pabloBBuiltinsEncoder       = new toolchain.pabloB.lang.PabloBBuiltins2C();
    49             carrySetEncoder             = new toolchain.pabloS.lang.carrySet.CarrySetBuiltin2C();
     49            s2kBuiltinsEncoder  = new toolchain.s2k.lang.S2KBuiltin2C();
     50            b2kBuiltinsEncoder  = new toolchain.b2k.lang.B2KBuiltins2C();
     51            carrySetEncoder             = new toolchain.s2k.lang.carrySet.CarrySetBuiltin2C();
    5052                        unparser                        = new Unparser(new IDISABuiltin2C());                   
    5153                } else if(applicationConfiguration.getTarget() == Target.CPP_LANG) {
    52                         pabloSbuiltinsEncoder   = new toolchain.pabloS.lang.PabloSBuiltin2CPP();
    53                         pabloBBuiltinsEncoder   = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
    54                         carrySetEncoder                 = new toolchain.pabloS.lang.carrySet.CarrySetBuiltin2CPP();
     54                        s2kBuiltinsEncoder      = new toolchain.s2k.lang.S2KBuiltin2CPP();
     55                        b2kBuiltinsEncoder      = new toolchain.b2k.lang.B2KBuiltins2CPP();
     56                        carrySetEncoder                 = new toolchain.s2k.lang.carrySet.CarrySetBuiltin2CPP();
    5557                        unparser                                = new Unparser(new IDISABuiltin2CPP());
    5658                } /*else if(applicationConfiguration.targetLang.contentEquals(Configuration.LLVM)) {  // default C++
    57                         builtins2Lang = new PabloSBuiltins2CPP();
     59                        builtins2Lang = new S2KBuiltins2CPP();
    5860                        carrySet2Lang = new CarrySetBuiltins2CPP();
    5961                        unparser          = new Unparser(new IDISABuiltins2LLVM());
    6062                } */
    6163
    62                 pabloB.ast.ASTNode pabloBAST = null;
     64                b2k.ast.ASTNode b2kAST = null;
    6365               
    64                 if(applicationConfiguration.getSource() == SourceLanguage.PABLO_S) {
     66                if(applicationConfiguration.getSource() == SourceLanguage.S2K) {
    6567                    //////////////////////////////////////////////////////////////
    66                     // Parse PabloS input
    67                     pabloS.ast.ASTNode pabloSAST = ASTGenerator.buildPabloSAST(applicationConfiguration.sourceFile());
     68                    // Parse s2k input
     69                    s2k.ast.ASTNode s2kAST = ASTGenerator.buildS2KAST(applicationConfiguration.sourceFile());
    6870                                               
    6971            //////////////////////////////////////////////////////////////
    70             // PabloS to PabloS transformations
    71                         pabloS.ast.ASTNode decoratedTree             = PabloS2SPabloController.accept(pabloSAST);
    72                         pabloS.ast.ASTNode finalBlockDecoratedTree   = PabloS2SPabloController.accept(pabloSAST);
     72            // s2k to s2k transformations
     73                        s2k.ast.ASTNode decoratedTree             = S2K2S2kController.accept(s2kAST);
     74                        s2k.ast.ASTNode finalBlockDecoratedTree   = S2K2S2kController.accept(s2kAST);
    7375                                               
    7476            //////////////////////////////////////////////////////////////
    75             // PabloS to PabloB transformation
    76                         pabloBAST = PabloS2PabloBTransformer.apply(pabloSbuiltinsEncoder, carrySetEncoder, decoratedTree, finalBlockDecoratedTree);
     77            // s2k to b2k transformations
     78                        b2kAST = S2K2B2KTransformer.apply(s2kBuiltinsEncoder, carrySetEncoder, decoratedTree, finalBlockDecoratedTree);
    7779                       
    78                 } else if (applicationConfiguration.getSource() == SourceLanguage.PABLO_B) {
     80                } else if (applicationConfiguration.getSource() == SourceLanguage.B2K) {
    7981            //////////////////////////////////////////////////////////////
    80             // Parse PabloB input
    81                     pabloBAST = ASTGenerator.buildPabloBAST(applicationConfiguration.sourceFile());
     82            // Parse b2k input
     83                    b2kAST = ASTGenerator.buildB2KAST(applicationConfiguration.sourceFile());
    8284                }
    8385
    8486        //////////////////////////////////////////////////////////////
    85         // PabloB to PabloB transformations
    86                 PabloB2PabloBController.setBuiltins2Lang(pabloBBuiltinsEncoder);
     87        // b2k to b2k transformations
     88                B2K2B2KController.setBuiltins2Lang(b2kBuiltinsEncoder);
    8789       
    8890        if(applicationConfiguration.addingAlignmentAssertions()) {
    89             PabloB2PabloBController.setAddAssertBitBlockAlignStmts(true);
     91            B2K2B2KController.setAddAssertBitBlockAlignStmts(true);
    9092        }
    9193       
    9294        if(applicationConfiguration.addingDumpStatements()) {
    93             PabloB2PabloBController.setAddDumpStmts(true);
     95            B2K2B2KController.setAddDumpStmts(true);
    9496        } 
    9597
    96         pabloBAST = PabloB2PabloBController.accept(pabloBAST);
     98        b2kAST = B2K2B2KController.accept(b2kAST);
    9799       
    98100       
     
    104106               
    105107                HeaderTemplateContentsGenerator templateContentsGenerator
    106                                                                         = new HeaderTemplateContentsGenerator((pabloB.ast.ProgramNode) pabloBAST,
     108                                                                        = new HeaderTemplateContentsGenerator((b2k.ast.ProgramNode) b2kAST,
    107109                                                                                                                                                        unparser,
    108110                                                                                                                                                        outputDirectory,
  • proto/pabloj/trunk/src/application/generators/HeaderTemplateContentsGenerator.java

    r3192 r3699  
    11/*
    2  * Generates a target language output header file from a PabloB ProgramNode.
     2 * Generates a target language output header file.
     3 * Expects b2k ProgramNode as input.
    34 *
    45 * @author <ksherdy at sfu dot ca>
     
    89package application.generators;
    910
    10 import pabloB.ast.*;
    11 import toolchain.pabloB.ast.Accessors;
    12 import toolchain.pabloB.codeGenerator.visitors.AbstractUnparser;
     11import b2k.ast.*;
     12import toolchain.b2k.ast.Accessors;
     13import toolchain.b2k.codeGenerator.visitors.AbstractUnparser;
    1314
    1415import application.config.Configuration;
  • proto/pabloj/trunk/src/application/logging/Logger.java

    r2998 r3699  
     1/**
     2 * This class is a Facade for java.util.logging.
     3 * It also retains the number of messages that have been logged.
     4 * Optionally, one may configure this logger to throw an exception
     5 * when a certain message count is reached.
     6 * <p>
     7 * Retains hard references to all loggers created.
     8 *
     9 * @author Tom Shermer <shermer at sfu dot ca>
     10 *
     11 */
    112package application.logging;
    213
     
    415import java.util.Map;
    516import java.util.logging.Level;
    6 
    7 /** This class is a Facade for java.util.logging.
    8  * It also retains the number of messages that have been logged.
    9  * Optionally, one may configure this logger to throw an exception
    10  * when a certain message count is reached.
    11  * <p>
    12  * Retains hard references to all loggers created.
    13  */
    1417
    1518public class Logger {
  • proto/pabloj/trunk/src/application/templating/FileTemplate.java

    r2998 r3699  
     1/*
     2 * File Templating.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 * @author Tom Shermer <shermer at sfu dot ca>
     6 */
    17package application.templating;
    28
    3 import pabloS.inputHandler.LineBasedReader;
     9import s2k.inputHandler.LineBasedReader;
    410import java.io.PrintStream;
    511
     
    6470       
    6571        // The Template implementation just delegates to the MemoryTemplate
    66        
    6772        @Override
    6873        public void set(String name, String value) {
  • proto/pabloj/trunk/src/application/templating/MemoryTemplate.java

    r2998 r3699  
     1/*
     2 * Memory Templating.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca
     5 * @author Tom Shermer <shermer at sfu dot ca
     6 */
    17package application.templating;
    28
  • proto/pabloj/trunk/src/application/templating/Template.java

    r2998 r3699  
     1/*
     2 * Templating Interface.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 * @author Tom Shermer <shermer at sfu dot ca>
     6 */
    17package application.templating;
    28
  • proto/pabloj/trunk/src/test/helpers/ASTComparator.java

    r3173 r3699  
    44
    55import java.util.List;
    6 import pabloS.ast.ASTNode;
     6import s2k.ast.ASTNode;
    77
    88/**
  • proto/pabloj/trunk/src/test/helpers/AssertNodePairComparator.java

    r3173 r3699  
    99package test.helpers;
    1010
    11 import pabloS.ast.*;
     11import s2k.ast.*;
    1212
    1313public class AssertNodePairComparator {
Note: See TracChangeset for help on using the changeset viewer.