Changeset 755 for proto/JSON


Ignore:
Timestamp:
Dec 1, 2010, 2:56:27 PM (8 years ago)
Author:
ksherdy
Message:

Update template.

Location:
proto/JSON
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/JSON/json_compilable.py

    r746 r755  
    158158        Lex.Null = (temp89 | Lex.l);
    159159
    160         # --- Start Generate String Mask ---
    161         # parse_escape() --- manual inline
     160        # Start parse_escape --- manual inline
    162161        # Odd = simd_const_2(1)
    163162        # Even = simd_const_2(2)
     
    175174        UnescapedDQuotes = (Lex.DQuote &~ Escape)
    176175       
    177         # parallel_prefix_mask() --- manual insert and bitblock logic in JSON template.c --- assume existence of ParityMask
    178        
     176        # End parse_escape --- manual inline
     177       
     178        # parallel_prefix_mask() --- we currently manually insert this method into the JSON template.c
     179       
     180        # Start Generate String Mask ---
    179181        StringMask = ParityMask & bitutil.Advance(ParityMask)
    180         # --- End Generate String Mask ---
    181 
     182        # End Generate String Mask ---
     183
     184        # Start atom_starts --- manual inline   
    182185        StringSpans = StringMask | UnescapedDQuotes
     186       
     187        AtomSpans = (Lex.True | Lex.False | Lex.Null | Lex.Number | StringSpans)
     188        AtomStarts = AtomSpans &~ bitutil.Advance(AtomSpans)
     189               
     190        StringStarts = AtomStarts & (Lex.DQuote)       
     191        NumberStarts = AtomStarts & (Lex.Minus|Lex.Digit0_9)
     192        TrueStarts = AtomStarts & (Lex.t)
     193        FalseStarts = AtomStarts & (Lex.f)
     194        NullStarts = AtomStarts & (Lex.n)       
     195        # End atom_starts --- manual inline
     196       
     197        # Start validate_string --- manual inline
     198        # (1) Validate escape characters
     199        StringEscapeChars = EscapeChars & StringMask
     200        StringErrors = (StringEscapeChars &~ Lex.Escape)
     201       
     202        u = StringEscapeChars & Lex.u
     203       
     204        uScope1 = bitutil.Advance(u)
     205        uScope2 = bitutil.Advance(uScope1)
     206        uScope3 = bitutil.Advance(uScope2)
     207        uScope4 = bitutil.Advance(uScope3)
     208       
     209        StringErrors |= uScope1 &~ Lex.HexDigit
     210        StringErrors |= uScope2 &~ Lex.HexDigit
     211        StringErrors |= uScope3 &~ Lex.HexDigit
     212        StringErrors |= uScope4 &~ Lex.HexDigit
     213       
     214        # (2) Validation of unescaped characters
     215        # (2.1) StringMask construction ensures all '"' are escaped.
     216        # (2.2) '\' are either correctly escaped or the character following an odd length run is escaped.
     217
     218        StringNotEscapedChars = (~(EscapeChars | Lex.RSolidus)) & StringMask # TODO - Verify logic.
     219        StringErrors |= (StringNotEscapedChars & Ctrl.x00_x1F)
     220       
     221        # (3) Validate all strings are terminated with an unescaped "
     222        StringCursor = bitutil.Advance(StringStarts)
     223        StringEnds = bitutil.ScanThru(StringCursor, StringMask)
     224        StringErrors |= StringEnds &~ UnescapedDQuotes
     225        StringSpans = (StringEnds - StringStarts) | StringEnds 
     226
     227        # End validate_string --- manual inline
     228       
     229        # Consolidate errors
     230        error_mask = StringErrors
    183231
    184232        return (u8,Lex,Ctrl,EOF_mask)
  • proto/JSON/json_prototype.py

    r746 r755  
    4040lgth = 0
    4141
    42 def simd_const_4(hexdigit,EOF_mask):
     42def simd_const_4(hexdigit, EOF_mask):
    4343        r"""
    4444        IDISA library function.
     
    6868        odd_escape = (odd_final & even)
    6969
    70         escape = (even_escape | odd_escape) 
    71        
    72         return escape
     70        Escape = (even_escape | odd_escape) 
     71       
     72        return Escape
    7373       
    7474def demo_parse_escape(u8data):
     
    139139        return
    140140
    141 def atom_starts(Lex,StringSpans):
     141def atom_starts(Lex, StringSpans):
    142142        r"""
    143143        This function returns multi-cursor start positions for each JSON value type.
     
    184184        (u8, Lex, Ctrl) = byteclass.classify_bytes(bit)
    185185       
    186         EscapeChars = parse_escape(Lex, EOF_mask)
    187        
    188         UnescapedDQuotes = (Lex.DQuote &~ EscapeChars)
     186        Escape = parse_escape(Lex, EOF_mask)
     187       
     188        UnescapedDQuotes = (Lex.DQuote &~ Escape)
    189189       
    190190        ParityMask = parallel_prefix_parity(UnescapedDQuotes) # TODO - Solve EOF_mask problem, if final position is 1 then the final DQUOTE is not matched.
     
    410410        (u8, Lex, Ctrl) = byteclass.classify_bytes(bit)
    411411       
    412         EscapeChars = parse_escape(Lex, EOF_mask)
    413         UnescapedDQuotes = (Lex.DQuote &~ EscapeChars)
     412        Escape = parse_escape(Lex, EOF_mask)
     413        UnescapedDQuotes = (Lex.DQuote &~ Escape)
    414414       
    415415        ParityMask = parallel_prefix_parity(UnescapedDQuotes)
     
    433433                              ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1))])
    434434
    435 def validate_string(StringStarts, Lex,Ctrl,StringMask,EscapeChars,UnescapedDQuotes):
     435def validate_string(StringStarts, Lex, Ctrl, StringMask, Escape, UnescapedDQuotes):
    436436        r"""
    437437        RFC 4627 - JavaScript Object Notation (JSON) 
     
    461461       
    462462        # (1) Validate escape characters
    463         StringEscapeChars = EscapeChars & StringMask
    464         Errors = (StringEscapeChars &~ Lex.Escape)
     463        StringEscapeChars = Escape & StringMask
     464        StringErrors = (StringEscapeChars &~ Lex.Escape)
    465465       
    466466        u = StringEscapeChars & Lex.u
     
    471471        uScope4 = bitutil.Advance(uScope3)
    472472       
    473         Errors |= uScope1 &~ Lex.HexDigit
    474         Errors |= uScope2 &~ Lex.HexDigit
    475         Errors |= uScope3 &~ Lex.HexDigit
    476         Errors |= uScope4 &~ Lex.HexDigit
     473        StringErrors |= uScope1 &~ Lex.HexDigit
     474        StringErrors |= uScope2 &~ Lex.HexDigit
     475        StringErrors |= uScope3 &~ Lex.HexDigit
     476        StringErrors |= uScope4 &~ Lex.HexDigit
    477477       
    478478        # (2) Validation of unescaped characters
     
    480480        # (2.2) '\' are either correctly escaped or the character following an odd length run is escaped.
    481481
    482         StringNotEscapedChars = (~(EscapeChars | Lex.RSolidus)) & StringMask # TODO - Verify logic.
    483         Errors |= (StringNotEscapedChars & Ctrl.x00_x1F)
     482        StringNotEscapedChars = (~(Escape | Lex.RSolidus)) & StringMask # TODO - Verify logic.
     483        StringErrors |= (StringNotEscapedChars & Ctrl.x00_x1F)
    484484       
    485485        # (3) Validate all strings are terminated with an unescaped "
    486486        StringCursor = bitutil.Advance(StringStarts)
    487487        StringEnds = bitutil.ScanThru(StringCursor, StringMask)
    488         Errors |= StringEnds &~ UnescapedDQuotes
     488        StringErrors |= StringEnds &~ UnescapedDQuotes
    489489        StringSpans = (StringEnds - StringStarts) | StringEnds
    490490       
    491491        if debug:
    492492                bitutil.print_aligned_streams([('Input Data', u8data),
    493                               ('EscapeChars', bitutil.bitstream2string(EscapeChars, lgth)),
     493                              ('Escape', bitutil.bitstream2string(Escape, lgth)),
    494494                              ('StringEscapeChars', bitutil.bitstream2string(StringEscapeChars, lgth)),
    495495                              ('u', bitutil.bitstream2string(u, lgth)),
     
    502502                              ('StringEnds', bitutil.bitstream2string(StringEnds, lgth)),
    503503                              ('StringSpans', bitutil.bitstream2string(StringSpans, lgth)),
    504                               ('Errors', bitutil.bitstream2string(Errors, lgth+1))])     
    505         return (Errors, StringSpans)
     504                              ('StringErrors', bitutil.bitstream2string(StringErrors, lgth+1))])         
     505        return (StringErrors, StringSpans)
    506506
    507507def demo_validate_string(u8data):
     
    509509        >>> demo_validate_string('["\u abcd", "\u1___", "\u12__", "\u123_"]')
    510510        Input Data      : ["\u abcd", "\u1___", "\u12__", "\u123_"]
    511         EscapeChars     : ___1__________1_________1_________1______
     511        Escape          : ___1__________1_________1_________1______
    512512        UnescapedDQuotes: _1_______1__1______1__1______1__1______1_
    513513        ParityMask      : _11111111___1111111___1111111___1111111__
     
    515515        StringStarts    : _1__________1_________1_________1________
    516516        StringSpans     : _111111111__11111111__11111111__11111111_
    517         Errors          : ____1___________111________11_________1___
     517        StringErrors    : ____1___________111________11_________1___
    518518        EOF_Mask        : 11111111111111111111111111111111111111111_
    519519        <BLANKLINE>
     
    527527        # Construct string interiors mask (1),(2),(3)
    528528        # (1) Mark all escaped characters
    529         EscapeChars = parse_escape(Lex, EOF_mask)
     529        Escape = parse_escape(Lex, EOF_mask)
    530530
    531531        # (2) Mark all unescaped "
    532         UnescapedDQuotes = (Lex.DQuote &~ EscapeChars)
     532        UnescapedDQuotes = (Lex.DQuote &~ Escape)
    533533
    534534        # (3) Construct string interiors mask
     
    539539        (StringStarts, NumberStarts, TrueStarts, FalseStarts, NullStarts) = atom_starts(Lex, StringSpans)                               
    540540       
    541         (Errors, StringSpans) = validate_string(StringStarts, Lex,Ctrl,StringMask,EscapeChars,UnescapedDQuotes)
     541        (StringErrors, StringSpans) = validate_string(StringStarts, Lex,Ctrl,StringMask,Escape,UnescapedDQuotes)
    542542       
    543543        bitutil.print_aligned_streams([('Input Data', u8data),
    544                               ('EscapeChars', bitutil.bitstream2string(EscapeChars, lgth)),
     544                              ('Escape', bitutil.bitstream2string(Escape, lgth)),
    545545                              ('UnescapedDQuotes', bitutil.bitstream2string(UnescapedDQuotes, lgth)),
    546546                              ('ParityMask', bitutil.bitstream2string(ParityMask, lgth)),
     
    548548                              ('StringStarts', bitutil.bitstream2string(StringStarts, lgth)),
    549549                              ('StringSpans', bitutil.bitstream2string(StringSpans, lgth)),
    550                               ('Errors', bitutil.bitstream2string(Errors, lgth+1)),
     550                              ('StringErrors', bitutil.bitstream2string(StringErrors, lgth+1)),
    551551                              ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1))])       
    552552                             
     
    561561        (u8, Lex, Ctrl) = byteclass.classify_bytes(bit)
    562562       
    563         EscapeChars = parse_escape(Lex, EOF_mask)
    564         UnescapedDQuotes = (Lex.DQuote &~ EscapeChars)
     563        Escape = parse_escape(Lex, EOF_mask)
     564        UnescapedDQuotes = (Lex.DQuote &~ Escape)
    565565        ParityMask = parallel_prefix_parity(UnescapedDQuotes)
    566566        StringMask = ParityMask & bitutil.Advance(ParityMask)   
     
    569569        (StringStarts, NumberStarts, TrueStarts, FalseStarts, NullStarts) = atom_starts(Lex, StringSpans)
    570570       
    571         (StringErrors, StringSpans) = validate_string(StringStarts, Lex, Ctrl, StringMask, EscapeChars, UnescapedDQuotes)
     571        (StringErrors, StringSpans) = validate_string(StringStarts, Lex, Ctrl, StringMask, Escape, UnescapedDQuotes)
    572572       
    573573        (NumberErrors, NumberSpans) = validate_number(NumberStarts, Lex, EOF_mask)
  • proto/JSON/src/json.c

    r746 r755  
    1717#define BUFFER_SIZE (BLOCK_SIZE * 16)           /* BUFFER_SIZE          - multiple of BLOCK_SIZE */
    1818#define OVERLAP_BUFSIZE BLOCK_SIZE              /* OVERLAP_BUFSIZE      - SIMD register width in bytes overlap */
     19
     20#define DEBUG 1
    1921
    2022#ifdef BUFFER_PROFILING
     
    4547BitBlock temp49;
    4648BitBlock temp42;
     49BitBlock StringErrors_1;
    4750BitBlock strct_u8__xF4_;
     51BitBlock StringErrors_3;
    4852BitBlock temp43;
     53BitBlock StringErrors_5;
     54BitBlock StringErrors_4;
    4955BitBlock strct_Lex__True_;
     56BitBlock strct_Lex__DecimalPoint_;
    5057BitBlock strct_Lex__Null_;
    5158BitBlock temp10;
    5259BitBlock array_bit__2_;
    5360BitBlock strct_u8__suffix_;
     61BitBlock StringSpans_6;
    5462BitBlock strct_u8__xE0_;
    5563BitBlock temp59;
     
    6371BitBlock temp51;
    6472BitBlock temp50;
     73BitBlock Temp9;
    6574BitBlock strct_Ctrl__CR_;
    6675BitBlock strct_Lex__f_;
    6776BitBlock UnescapedDQuotes;
     77BitBlock StringEscapeChars;
    6878BitBlock OddFinal;
    6979BitBlock strct_u8__unibyte_;
     80BitBlock StringErrors_0;
     81BitBlock TrueStarts;
     82BitBlock StringErrors_2;
    7083BitBlock array_bit__3_;
    7184BitBlock strct_u8__xED_;
     
    7487BitBlock temp29;
    7588BitBlock temp22;
    76 BitBlock EvenStart;
     89BitBlock strct_Ctrl__SP_;
    7790BitBlock temp20;
    7891BitBlock temp21;
     
    92105BitBlock temp8;
    93106BitBlock strct_Lex__a_;
     107BitBlock StringStarts;
    94108BitBlock strct_u8__x80_x8F_;
     109BitBlock StringCursor;
     110BitBlock NullStarts;
    95111BitBlock StringMask;
     112BitBlock strct_Lex__Digit1_9_;
    96113BitBlock strct_u8__prefix2_;
     114BitBlock AtomSpans;
    97115BitBlock array_bit__0_;
    98116BitBlock temp39;
     
    112130BitBlock temp35;
    113131BitBlock EvenFinal;
     132BitBlock AtomStarts;
    114133BitBlock strct_Lex__DQuote_;
    115 BitBlock EvenEscape;
     134BitBlock Temp20;
     135BitBlock Temp21;
    116136BitBlock strct_Lex__RSolidus_;
    117 //BitBlock Escape;
     137BitBlock Escape;
    118138BitBlock array_bit__1_;
    119139BitBlock Even;
     
    122142BitBlock Start;
    123143BitBlock strct_u8__xF0_;
     144BitBlock temp14;
    124145BitBlock strct_Ctrl__x00_x1F_;
    125146BitBlock strct_u8__x90_xBF_;
     147BitBlock uScope2;
    126148BitBlock strct_u8__badprefix_;
    127 BitBlock strct_Ctrl__SP_;
     149BitBlock EvenStart;
    128150BitBlock strct_Lex__False_;
    129151BitBlock temp23;
     152BitBlock uScope1;
    130153BitBlock strct_Lex__Digit0_9_;
    131154BitBlock strct_Lex__Comma_;
    132155BitBlock array_bit__7_;
    133156BitBlock strct_Lex__Colon_;
    134 BitBlock OddStart;
     157BitBlock uScope4;
    135158BitBlock temp53;
    136 BitBlock strct_Lex__DecimalPoint_;
    137 BitBlock Escape;
     159BitBlock FalseStarts;
     160BitBlock error_mask;
     161BitBlock NumberStarts;
     162BitBlock StringNotEscapedChars;
     163BitBlock EscapeChars;
    138164BitBlock temp88;
    139165BitBlock temp89;
     166BitBlock strct_Lex__e_;
    140167BitBlock temp84;
    141168BitBlock temp85;
     
    147174BitBlock temp83;
    148175BitBlock strct_u8__xA0_xBF_;
     176BitBlock StringErrors;
    149177BitBlock strct_u8__prefix3_;
    150178BitBlock Odd;
     
    159187BitBlock temp68;
    160188BitBlock temp69;
    161 BitBlock strct_Lex__e_;
    162 BitBlock strct_Lex__PlusMinus_;
     189BitBlock Temp13;
     190BitBlock Temp12;
     191BitBlock Temp11;
     192BitBlock Temp10;
     193BitBlock Temp17;
     194BitBlock Temp16;
     195BitBlock Temp15;
     196BitBlock Temp14;
     197BitBlock Temp19;
     198BitBlock Temp18;
    163199BitBlock strct_Lex__u_;
    164200BitBlock strct_u8__x80_x9F_;
     201BitBlock uScope3;
    165202BitBlock strct_Lex__Zero_;
     203BitBlock strct_Lex__WS_;
    166204BitBlock temp13;
    167205BitBlock temp12;
     
    171209BitBlock temp16;
    172210BitBlock temp15;
    173 BitBlock temp14;
     211BitBlock StringEnds;
     212BitBlock Temp7;
    174213BitBlock temp19;
    175214BitBlock temp18;
     
    189228BitBlock strct_u8__prefix_;
    190229BitBlock strct_Lex__s_;
    191 BitBlock strct_Lex__WS_;
     230BitBlock Temp5;
     231BitBlock EvenEscape;
    192232BitBlock array_bit__5_;
    193233BitBlock AllOne = simd_const_1(1);
     
    199239BitBlock Temp2;
    200240BitBlock Temp1;
    201 BitBlock Temp7;
     241BitBlock u;
    202242BitBlock Temp6;
    203 BitBlock Temp5;
     243BitBlock strct_Lex__PlusMinus_;
    204244BitBlock Temp4;
    205245BitBlock strct_Lex__HexDigit_;
    206246BitBlock strct_Lex__RCurlyBrace_;
    207247BitBlock Temp8;
    208 BitBlock strct_Lex__Digit1_9_;
     248BitBlock OddStart;
    209249CarryType carry1 = Carry0;
    210250CarryType carry0 = Carry0;
    211251CarryType carry3 = Carry0;
    212252CarryType carry2 = Carry0;
    213 
    214        
    215         BitBlock error_mask;
     253CarryType carry5 = Carry0;
     254CarryType carry4 = Carry0;
     255CarryType carry7 = Carry0;
     256CarryType carry6 = Carry0;
     257CarryType carry9 = Carry0;
     258CarryType carry8 = Carry0;
     259CarryType carry_brw0 = Carry0;
     260CarryType carry10 = Carry0;
     261
     262       
     263        // BitBlock error_mask;  // PyBit compiler auto declares this variables
    216264        BitBlock EOF_mask = simd_const_1(1);
    217265       
     
    417465Escape = simd_or(EvenEscape,OddEscape);
    418466UnescapedDQuotes = simd_andc(strct_Lex__DQuote_,Escape);
     467advance_with_carry(ParityMask, carry3, Temp8);
     468StringMask = simd_and(ParityMask,Temp8);
     469StringSpans_6 = simd_or(StringMask,UnescapedDQuotes);
     470Temp9 = simd_or(strct_Lex__True_,strct_Lex__False_);
     471Temp10 = simd_or(Temp9,strct_Lex__Null_);
     472Temp11 = simd_or(Temp10,strct_Lex__Number_);
     473AtomSpans = simd_or(Temp11,StringSpans_6);
     474advance_with_carry(AtomSpans, carry4, Temp12);
     475AtomStarts = simd_andc(AtomSpans,Temp12);
     476StringStarts = simd_and(AtomStarts,strct_Lex__DQuote_);
     477NumberStarts = simd_and(AtomStarts,temp44);
     478TrueStarts = simd_and(AtomStarts,temp68);
     479FalseStarts = simd_and(AtomStarts,temp62);
     480NullStarts = simd_and(AtomStarts,temp64);
     481StringEscapeChars = simd_and(EscapeChars,StringMask);
     482StringErrors_0 = simd_andc(StringEscapeChars,strct_Lex__Escape_);
     483u = simd_and(StringEscapeChars,strct_Lex__u_);
     484advance_with_carry(u, carry5, uScope1);
     485advance_with_carry(uScope1, carry6, uScope2);
     486advance_with_carry(uScope2, carry7, uScope3);
     487advance_with_carry(uScope3, carry8, uScope4);
     488Temp13 = simd_andc(uScope1,strct_Lex__HexDigit_);
     489StringErrors_1 = simd_or(StringErrors_0,Temp13);
     490Temp14 = simd_andc(uScope2,strct_Lex__HexDigit_);
     491StringErrors_2 = simd_or(StringErrors_1,Temp14);
     492Temp15 = simd_andc(uScope3,strct_Lex__HexDigit_);
     493StringErrors_3 = simd_or(StringErrors_2,Temp15);
     494Temp16 = simd_andc(uScope4,strct_Lex__HexDigit_);
     495StringErrors_4 = simd_or(StringErrors_3,Temp16);
     496Temp17 = simd_or(EscapeChars,strct_Lex__RSolidus_);
     497StringNotEscapedChars = simd_andc(StringMask,Temp17);
     498Temp18 = simd_and(StringNotEscapedChars,strct_Ctrl__x00_x1F_);
     499StringErrors_5 = simd_or(StringErrors_4,Temp18);
     500advance_with_carry(StringStarts, carry9, StringCursor);
     501adc128(StringCursor, StringMask, carry10, Temp19);
     502StringEnds = simd_andc(Temp19,StringMask);
     503Temp20 = simd_andc(StringEnds,UnescapedDQuotes);
     504StringErrors = simd_or(StringErrors_5,Temp20);
     505sbb128(StringEnds, StringStarts, carry_brw0, Temp21);
     506StringSpans = simd_or(Temp21,StringEnds);
     507error_mask = StringErrors;
     508
    419509
    420510                        /* Generate Parity Mask */
     
    423513                        bitblock_parity_mask = sisd_add( simd_not(sisd_srl(high_bit_is_set, sisd_from_int(BLOCK_SIZE-1))) , sisd_low_bit_mask);                                         
    424514                        ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
    425 
    426 advance_with_carry(ParityMask, carry3, Temp8);
    427 StringMask = simd_and(ParityMask,Temp8);
    428 StringSpans = simd_or(StringMask,UnescapedDQuotes);
    429 
    430 
    431                         /* strct_Lex__Null_ = simd_or(temp89,strct_Lex__l_); */
     515                       
     516                        #ifdef DEBUG
     517                       
    432518                        print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
    433519                        print_simd_register("Escape", Escape);
    434                        
    435 
    436                        
    437520                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
    438521                        /*
     
    443526                        print_simd_register("StringMask", StringMask);
    444527                        print_simd_register("StringSpans", StringSpans);                                               
     528               
     529                        print_simd_register("AtomStarts", AtomStarts);
     530                        print_simd_register("StringStarts", StringStarts);
     531                        print_simd_register("NumberStarts", NumberStarts);
     532                        print_simd_register("TrueStarts", TrueStarts);
     533                        print_simd_register("FalseStarts", FalseStarts);
     534                        print_simd_register("NullStarts", NullStarts);
     535                                               
     536                        #endif
    445537                       
    446538                        if (bitblock_has_bit(error_mask)){
     
    638730advance_with_carry(ParityMask, carry3, Temp8);
    639731StringMask = simd_and(ParityMask,Temp8);
    640 StringSpans = simd_or(StringMask,UnescapedDQuotes);
    641 
    642 
    643                         /* strct_Lex__Null_ = simd_or(temp89,strct_Lex__l_); */
     732StringSpans_6 = simd_or(StringMask,UnescapedDQuotes);
     733Temp9 = simd_or(strct_Lex__True_,strct_Lex__False_);
     734Temp10 = simd_or(Temp9,strct_Lex__Null_);
     735Temp11 = simd_or(Temp10,strct_Lex__Number_);
     736AtomSpans = simd_or(Temp11,StringSpans_6);
     737advance_with_carry(AtomSpans, carry4, Temp12);
     738AtomStarts = simd_andc(AtomSpans,Temp12);
     739StringStarts = simd_and(AtomStarts,strct_Lex__DQuote_);
     740NumberStarts = simd_and(AtomStarts,temp44);
     741TrueStarts = simd_and(AtomStarts,temp68);
     742FalseStarts = simd_and(AtomStarts,temp62);
     743NullStarts = simd_and(AtomStarts,temp64);
     744
     745StringEscapeChars = simd_and(Escape,StringMask);
     746StringErrors_0 = simd_andc(StringEscapeChars,strct_Lex__Escape_);
     747u = simd_and(StringEscapeChars,strct_Lex__u_);
     748advance_with_carry(u, carry5, uScope1);
     749advance_with_carry(uScope1, carry6, uScope2);
     750advance_with_carry(uScope2, carry7, uScope3);
     751advance_with_carry(uScope3, carry8, uScope4);
     752Temp13 = simd_andc(uScope1,strct_Lex__HexDigit_);
     753StringErrors_1 = simd_or(StringErrors_0,Temp13);
     754Temp14 = simd_andc(uScope2,strct_Lex__HexDigit_);
     755StringErrors_2 = simd_or(StringErrors_1,Temp14);
     756Temp15 = simd_andc(uScope3,strct_Lex__HexDigit_);
     757StringErrors_3 = simd_or(StringErrors_2,Temp15);
     758Temp16 = simd_andc(uScope4,strct_Lex__HexDigit_);
     759StringErrors_4 = simd_or(StringErrors_3,Temp16);
     760Temp17 = simd_or(Escape,strct_Lex__RSolidus_);
     761StringNotEscapedChars = simd_andc(StringMask,Temp17);
     762Temp18 = simd_and(StringNotEscapedChars,strct_Ctrl__x00_x1F_);
     763StringErrors_5 = simd_or(StringErrors_4,Temp18);
     764advance_with_carry(StringStarts, carry9, StringCursor);
     765adc128(StringCursor, StringMask, carry10, Temp19);
     766StringEnds = simd_andc(Temp19,StringMask);
     767Temp20 = simd_andc(StringEnds,UnescapedDQuotes);
     768StringErrors = simd_or(StringErrors_5,Temp20);
     769sbb128(StringEnds, StringStarts, carry_brw0, Temp21);
     770StringSpans = simd_or(Temp21,StringEnds);
     771error_mask = StringErrors;
     772
     773                        #ifdef DEBUG
     774                       
    644775                        print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
    645776                        print_simd_register("Escape", Escape);
    646                        
    647 
    648                        
    649                        
    650777                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
    651                        
     778                        /*
    652779                        print_simd_register("high_bit_is_set", high_bit_is_set);
    653780                        print_simd_register("high_bit_mask", high_bit_mask);
    654                        
     781                        */
    655782                        print_simd_register("ParityMask", ParityMask);
    656783                        print_simd_register("StringMask", StringMask);
    657                         print_simd_register("StringSpans", StringSpans);                       
     784                        print_simd_register("StringSpans", StringSpans);                                               
     785               
     786                        print_simd_register("AtomStarts", AtomStarts);
     787                        print_simd_register("StringStarts", StringStarts);
     788                        print_simd_register("NumberStarts", NumberStarts);
     789                        print_simd_register("TrueStarts", TrueStarts);
     790                        print_simd_register("FalseStarts", FalseStarts);
     791                        print_simd_register("NullStarts", NullStarts);
     792                       
     793                        print_simd_register("u", u);
     794                        print_simd_register("StringErrors", StringErrors);
     795                       
     796                        #endif
    658797                       
    659798                        if(bitblock_has_bit(error_mask)) {
  • proto/JSON/template.c

    r746 r755  
    1717#define BUFFER_SIZE (BLOCK_SIZE * 16)           /* BUFFER_SIZE          - multiple of BLOCK_SIZE */
    1818#define OVERLAP_BUFSIZE BLOCK_SIZE              /* OVERLAP_BUFSIZE      - SIMD register width in bytes overlap */
     19
     20#define DEBUG 1
    1921
    2022#ifdef BUFFER_PROFILING
     
    3638        @decl
    3739       
    38         BitBlock error_mask;
     40        // BitBlock error_mask;  // PyBit compiler auto declares this variable
    3941        BitBlock EOF_mask = simd_const_1(1);
    4042       
     
    4648        BitBlock high_bit_mask = sisd_high_bit_mask;   
    4749        BitBlock high_bit_is_set;
    48         // BitBlock ParityMask = simd_const_1(0); // ParityMask declaration via PyBit
     50        // BitBlock ParityMask = simd_const_1(0); // PyBit compiler auto declares this variable
    4951        BitBlock bitblock_parity_mask; 
    5052       
     
    8688                        @block_stmts
    8789
    88                         /* strct_Lex__Null_ = simd_or(temp89,strct_Lex__l_); */
    89                         print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
    90                         print_simd_register("Escape", Escape);
    91                        
    9290                        /* Generate Parity Mask */
    9391                        high_bit_mask = sisd_high_bit_mask;
     
    9694                        ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
    9795                       
     96                        #ifdef DEBUG
     97                       
     98                        print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
     99                        print_simd_register("Escape", Escape);
    98100                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
    99101                        /*
     
    104106                        print_simd_register("StringMask", StringMask);
    105107                        print_simd_register("StringSpans", StringSpans);                                               
     108               
     109                        print_simd_register("AtomStarts", AtomStarts);
     110                        print_simd_register("StringStarts", StringStarts);
     111                        print_simd_register("NumberStarts", NumberStarts);
     112                        print_simd_register("TrueStarts", TrueStarts);
     113                        print_simd_register("FalseStarts", FalseStarts);
     114                        print_simd_register("NullStarts", NullStarts);
     115                                               
     116                        #endif
    106117                       
    107118                        if (bitblock_has_bit(error_mask)){
    108119                                err_pos = src_pos + buf_pos + count_forward_zeroes(error_mask);
    109                                 fprintf(stderr, "Error at position %i\n.", err_pos);
     120                                fprintf(stderr, "Error at position %i.\n", err_pos);
    110121                                exit(-1);
    111122                        }
     
    134145                       
    135146                        @block_stmts
    136 
    137                         /* strct_Lex__Null_ = simd_or(temp89,strct_Lex__l_); */
    138                         print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
    139                         print_simd_register("Escape", Escape);
    140147                       
    141148                        /* Generate Parity Mask */
     
    146153                        ParityMask = simd_and(ParityMask, EOF_mask);
    147154                       
    148                        
     155                        #ifdef DEBUG
     156                       
     157                        print_array_le("Data", &srcbuf[buf_pos],BLOCK_SIZE);
     158                        print_simd_register("Escape", Escape);
    149159                        print_simd_register("Unescaped DQuote",UnescapedDQuotes);
    150160                        /*
     
    154164                        print_simd_register("ParityMask", ParityMask);
    155165                        print_simd_register("StringMask", StringMask);
    156                         print_simd_register("StringSpans", StringSpans);                       
     166                        print_simd_register("StringSpans", StringSpans);                                               
     167               
     168                        print_simd_register("AtomStarts", AtomStarts);
     169                        print_simd_register("StringStarts", StringStarts);
     170                        print_simd_register("NumberStarts", NumberStarts);
     171                        print_simd_register("TrueStarts", TrueStarts);
     172                        print_simd_register("FalseStarts", FalseStarts);
     173                        print_simd_register("NullStarts", NullStarts);
     174                                               
     175                        #endif
    157176                       
    158177                        if(bitblock_has_bit(error_mask)) {
Note: See TracChangeset for help on using the changeset viewer.