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

Initial working JSON compilable and executable.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/JSON/json_compilable.py

    r755 r766  
    1313       
    1414def main(u8data):
    15         # Transpose to parallel bit streams and prepare an EOF mask.
     15        ### Transpose to parallel bit streams and prepare an EOF mask.
    1616        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    1717
    18         # Classify bytes for UTF-8 processing, whitespace control processing, and JSON lexical analysis.       
     18        ### Classify bytes for UTF-8 processing, whitespace control processing, and JSON lexical analysis.     
    1919        u8.unibyte = (~bit[0]);
    2020        u8.prefix = (bit[0] & bit[1]);
     
    158158        Lex.Null = (temp89 | Lex.l);
    159159
    160         # Start parse_escape --- manual inline
     160        ### Start parse_escape
     161        #
    161162        # Odd = simd_const_2(1)
    162163        # Even = simd_const_2(2)
     
    173174        Escape = (EvenEscape | OddEscape) 
    174175        UnescapedDQuotes = (Lex.DQuote &~ Escape)
    175        
    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 ---
     176        #
     177        ### End parse_escape
     178       
     179        ### parallel_prefix_mask() --- we currently manually insert this method into the JSON template.c
     180       
     181        ### Start Generate String Mask ---
     182        #
    181183        StringMask = ParityMask & bitutil.Advance(ParityMask)
    182         # End Generate String Mask ---
    183 
    184         # Start atom_starts --- manual inline   
     184        #
     185        ### End Generate String Mask ---
     186
     187        ### Start atom_starts   
     188        #
    185189        StringSpans = StringMask | UnescapedDQuotes
    186190       
     
    193197        FalseStarts = AtomStarts & (Lex.f)
    194198        NullStarts = AtomStarts & (Lex.n)       
    195         # End atom_starts --- manual inline
    196        
    197         # Start validate_string --- manual inline
     199        #
     200        ### End atom_starts
     201       
     202        ### Start validate_string
     203        #
    198204        # (1) Validate escape characters
    199         StringEscapeChars = EscapeChars & StringMask
     205        StringEscapeChars = Escape & StringMask
    200206        StringErrors = (StringEscapeChars &~ Lex.Escape)
    201207       
     
    216222        # (2.2) '\' are either correctly escaped or the character following an odd length run is escaped.
    217223
    218         StringNotEscapedChars = (~(EscapeChars | Lex.RSolidus)) & StringMask # TODO - Verify logic.
     224        StringNotEscapedChars = (~(Escape | Lex.RSolidus)) & StringMask
    219225        StringErrors |= (StringNotEscapedChars & Ctrl.x00_x1F)
    220226       
     
    223229        StringEnds = bitutil.ScanThru(StringCursor, StringMask)
    224230        StringErrors |= StringEnds &~ UnescapedDQuotes
    225         StringSpans = (StringEnds - StringStarts) | StringEnds 
    226 
    227         # End validate_string --- manual inline
    228        
     231        #
     232        ### End validate_string
     233       
     234        ### Start validate_number
     235        #
     236        M0 = NumberStarts                                       # Initialize marker stream     
     237       
     238        M1 = bitutil.ScanThru(M0, Lex.Minus & M0)               # ? Optional character class [-]
     239        E1 = M1 &~(Lex.Zero|Lex.Digit1_9)
     240        M1 = M1 &~ E1                                           # Remove cursors at error positions so as to report a single error position
     241
     242        M1a = M1 & Lex.Zero                                     # Split
     243        M1b = M1 & Lex.Digit1_9                         
     244        M2a = bitutil.Advance(M1a)
     245        M2b = bitutil.Advance(M1b)
     246        M3b = bitutil.ScanThru(M2b,Lex.Digit0_9)
     247        M4 =  M2a | M3b                                         # Join
     248       
     249        M4a = M4 &~(Lex.DecimalPoint)                           # Split
     250        M4b = M4 & (Lex.DecimalPoint)
     251        M5b = bitutil.Advance(M4b)
     252        E5b = M5b &~(Lex.Digit0_9)                              # + [0-9]+
     253        M5b = M5b &~E5b                                         # Remove cursors at error positions so as to report a single error position
     254       
     255        M6 = bitutil.ScanThru(M5b,Lex.Digit0_9)
     256        M7 = M4a | M6                                           # Join
     257       
     258        M7a = M7 &~(Lex.Ee)                                     # Split
     259        M7b = M7 &(Lex.Ee)
     260        M8b = bitutil.Advance(M7b)
     261        M9b = bitutil.ScanThru(M8b, Lex.PlusMinus & M8b)        # ? Optional character class [+-]               
     262        E9b  = M9b &~(Lex.Digit0_9)                             # + [0-9]+
     263        M9b = M9b &~ E9b                                        # Remove cursors at error positions so as to report a single error position
     264        M10b = bitutil.ScanThru(M9b,Lex.Digit0_9)
     265
     266        M11 = M7a | M10b                                       
     267       
     268        NumberErrors = E1 | E5b | E9b   
     269        #
     270        ### End validate_number
     271
     272        ### Start validate_true
     273        #
     274        Scope1 = bitutil.Advance(TrueStarts)
     275        Scope2 = bitutil.Advance(Scope1)
     276        Scope3 = bitutil.Advance(Scope2)
     277       
     278        TrueErrors = Scope1 &~ Lex.r
     279        TrueErrors |= Scope2 &~ Lex.u
     280        TrueErrors |= Scope3 &~ Lex.e
     281       
     282        Follows = bitutil.Advance(Scope3)
     283        TrueSpans = Follows - TrueStarts
     284        #
     285        ### End validate_true
     286
     287        ### Start validate_false
     288        #
     289        Scope1 = bitutil.Advance(FalseStarts)
     290        Scope2 = bitutil.Advance(Scope1)
     291        Scope3 = bitutil.Advance(Scope2)
     292        Scope4 = bitutil.Advance(Scope3)
     293       
     294        FalseErrors = Scope1 &~ Lex.a
     295        FalseErrors |= Scope2 &~ Lex.l
     296        FalseErrors |= Scope3 &~ Lex.s
     297        FalseErrors |= Scope4 &~ Lex.e
     298
     299        Follows = bitutil.Advance(Scope4)
     300        FalseSpans = Follows - FalseStarts
     301        #
     302        ### End validate_false
     303       
     304        ### Start validate_null
     305        #
     306        Scope1 = bitutil.Advance(NullStarts)
     307        Scope2 = bitutil.Advance(Scope1)
     308        Scope3 = bitutil.Advance(Scope2)
     309       
     310        NullErrors |= Scope1 &~ Lex.u
     311        NullErrors |= Scope2 &~ Lex.l
     312        NullErrors |= Scope3 &~ Lex.l
     313       
     314        Follows = bitutil.Advance(Scope3)
     315        NullSpans = Follows - NullStarts
     316        #
     317        ### End validate_null
     318
     319        # AtomSpans & AtomsStarts serve as the basic interface to ANTLR
     320        AtomsSpans = StringSpans | NumberSpans | TrueSpans | FalseSpans | NullSpans
     321
    229322        # Consolidate errors
    230         error_mask = StringErrors
     323        error_mask = StringErrors | NumberErrors | TrueErrors | FalseErrors | NullErrors
    231324
    232325        return (u8,Lex,Ctrl,EOF_mask)
Note: See TracChangeset for help on using the changeset viewer.