source: proto/JSON/json_compilable.py @ 767

Last change on this file since 767 was 766, checked in by ksherdy, 8 years ago

Initial working JSON compilable and executable.

File size: 9.3 KB
RevLine 
[672]1# -*- coding: utf-8 -*-
[739]2#
3# json_compilable.py
4#
5# Parallel JSON validation.
6#
7# RFC 4627 - JavaScript Object Notation (JSON) 
8# RFC 5234 - Augmented BNF for Syntax Specifications: ABNF
9#
10# Ken Herdy
11# November 26, 2010
12#
13       
[672]14def main(u8data):
[766]15        ### Transpose to parallel bit streams and prepare an EOF mask.
[739]16        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
[672]17
[766]18        ### Classify bytes for UTF-8 processing, whitespace control processing, and JSON lexical analysis.     
[739]19        u8.unibyte = (~bit[0]);
20        u8.prefix = (bit[0] & bit[1]);
21        u8.prefix2 = (u8.prefix &~ bit[2]);
22        temp1 = (bit[2] &~ bit[3]);
23        u8.prefix3 = (u8.prefix & temp1);
24        temp2 = (bit[2] & bit[3]);
25        u8.prefix4 = (u8.prefix & temp2);
26        u8.suffix = (bit[0] &~ bit[1]);
27        temp3 = (bit[2] | bit[3]);
28        temp4 = (u8.prefix &~ temp3);
29        temp5 = (bit[4] | bit[5]);
30        temp6 = (temp5 | bit[6]);
31        temp7 = (temp4 &~ temp6);
32        temp8 = (bit[6] | bit[7]);
33        temp9 = (bit[5] & temp8);
34        temp10 = (bit[4] | temp9);
35        temp11 = (u8.prefix4 & temp10);
36        u8.badprefix = (temp7 | temp11);
37        temp12 = (temp5 | temp8);
38        u8.xE0 = (u8.prefix3 &~ temp12);
39        temp13 = (bit[4] & bit[5]);
40        temp14 = (bit[7] &~ bit[6]);
41        temp15 = (temp13 & temp14);
42        u8.xED = (u8.prefix3 & temp15);
43        u8.xF0 = (u8.prefix4 &~ temp12);
44        temp16 = (bit[5] &~ bit[4]);
45        temp17 = (temp16 &~ temp8);
46        u8.xF4 = (u8.prefix4 & temp17);
47        u8.xA0_xBF = (u8.suffix & bit[2]);
48        u8.x80_x9F = (u8.suffix &~ bit[2]);
49        u8.x90_xBF = (u8.suffix & temp3);
50        u8.x80_x8F = (u8.suffix &~ temp3);
51        temp18 = (bit[0] | bit[1]);
52        temp19 = (temp18 | bit[2]);
53        Ctrl.x00_x1F = (~temp19);
54        temp20 = (temp18 | temp3);
55        Ctrl.CR = (temp15 &~ temp20);
56        temp21 = (bit[4] &~ bit[5]);
57        temp22 = (bit[6] &~ bit[7]);
58        temp23 = (temp21 & temp22);
59        Ctrl.LF = (temp23 &~ temp20);
60        temp24 = (temp21 & temp14);
61        Ctrl.HT = (temp24 &~ temp20);
62        temp25 = (temp1 &~ temp18);
63        Ctrl.SP = (temp25 &~ temp12);
64        temp26 = (bit[1] &~ bit[0]);
65        temp27 = (temp26 & temp2);
66        temp28 = (bit[6] & bit[7]);
67        temp29 = (temp21 & temp28);
68        Lex.LCurlyBrace = (temp27 & temp29);
69        temp30 = (temp2 &~ temp18);
70        Lex.Colon = (temp30 & temp23);
71        temp31 = (temp13 &~ temp8);
72        Lex.Comma = (temp25 & temp31);
73        Lex.RCurlyBrace = (temp27 & temp15);
74        temp32 = (bit[3] &~ bit[2]);
75        temp33 = (temp26 & temp32);
76        Lex.LSquareBracket = (temp33 & temp29);
77        Lex.RSquareBracket = (temp33 & temp15);
78        Lex.Minus = (temp25 & temp15);
79        Lex.Zero = (temp30 &~ temp12);
80        temp34 = (bit[5] | bit[6]);
81        temp35 = (~temp34);
82        temp36 = (bit[5] | temp8);
83        temp37 = ((bit[4] & temp35)|(~(bit[4]) & temp36));
84        Lex.Digit1_9 = (temp30 & temp37);
85        temp38 = (bit[4] & temp34);
86        Lex.Digit0_9 = (temp30 &~ temp38);
87        temp39 = (temp13 & temp22);
88        Lex.DecimalPoint = (temp25 & temp39);
89        temp40 = (temp16 & temp14);
90        temp41 = (temp3 &~ temp1);
91        temp42 = (temp26 &~ temp41);
92        Lex.Ee = (temp40 & temp42);
93        temp43 = (temp29 | temp15);
94        Lex.PlusMinus = (temp25 & temp43);
95        temp44 = (Lex.Minus | Lex.Digit0_9);
96        temp45 = (temp44 | Lex.DecimalPoint);
97        temp46 = (temp26 &~ temp3);
98        temp47 = (temp46 & temp40);
99        temp48 = (temp45 | temp47);
100        temp49 = (temp26 & temp1);
101        temp50 = (temp49 & temp40);
102        temp51 = (temp48 | temp50);
103        temp52 = (temp25 & temp29);
104        temp53 = (temp51 | temp52);
105        Lex.Number = (temp53 | Lex.Minus);
106        temp54 = (temp22 &~ temp5);
107        Lex.DQuote = (temp25 & temp54);
108        Lex.RSolidus = (temp33 & temp31);
109        Lex.u = (temp27 & temp40);
110        temp55 = (Lex.DQuote | Lex.RSolidus);
111        temp56 = (temp13 & temp28);
112        temp57 = (temp25 & temp56);
113        temp58 = (temp55 | temp57);
114        temp59 = (temp49 & temp54);
115        temp60 = (temp58 | temp59);
116        temp61 = (temp16 & temp22);
117        temp62 = (temp49 & temp61);
118        temp63 = (temp60 | temp62);
119        temp64 = (temp49 & temp39);
120        temp65 = (temp63 | temp64);
121        temp66 = (temp27 & temp54);
122        temp67 = (temp65 | temp66);
123        temp68 = (temp27 & temp17);
124        temp69 = (temp67 | temp68);
125        Lex.Escape = (temp69 | Lex.u);
126        temp70 = (temp49 &~ bit[4]);
127        temp71 = (~temp28);
128        temp72 = ((bit[5] & temp71)|(~(bit[5]) & temp8));
129        temp73 = (temp70 & temp72);
130        temp74 = (Lex.Digit0_9 | temp73);
131        temp75 = (temp46 &~ bit[4]);
132        temp76 = (temp75 & temp72);
133        Lex.HexDigit = (temp74 | temp76);
134        temp77 = (temp15 | temp23);
135        temp78 = (temp77 | temp24);
136        temp79 = (temp78 &~ temp20);
137        Lex.WS = (temp79 | Ctrl.SP);
138        Lex.t = (temp27 & temp17);
139        Lex.r = (temp27 & temp54);
140        Lex.e = (temp49 & temp40);
141        temp80 = (temp17 | temp54);
142        temp81 = (temp80 | temp40);
143        temp82 = (temp27 & temp81);
144        Lex.True = (temp82 | Lex.e);
145        Lex.f = (temp49 & temp61);
146        temp83 = (temp14 &~ temp5);
147        Lex.a = (temp49 & temp83);
148        Lex.l = (temp49 & temp31);
149        temp84 = (temp28 &~ temp5);
150        Lex.s = (temp27 & temp84);
151        temp85 = (temp61 | temp83);
152        temp86 = (temp85 | temp31);
153        temp87 = (temp49 & temp86);
154        temp88 = (temp87 | Lex.s);
155        Lex.False = (temp88 | Lex.e);
156        Lex.n = (temp49 & temp39);
157        temp89 = (Lex.n | Lex.u);
158        Lex.Null = (temp89 | Lex.l);
159
[766]160        ### Start parse_escape
161        #
[744]162        # Odd = simd_const_2(1)
163        # Even = simd_const_2(2)
164        Start = Lex.RSolidus &~ bitutil.Advance(Lex.RSolidus)
165       
166        EvenStart = Start & Even
167        EvenFinal = (EvenStart + Lex.RSolidus) & ~Lex.RSolidus
168        EvenEscape = EvenFinal & Odd
169       
170        OddStart = Start & Odd
171        OddFinal = (OddStart + Lex.RSolidus) & ~Lex.RSolidus
172        OddEscape = (OddFinal & Even)
173
174        Escape = (EvenEscape | OddEscape) 
[746]175        UnescapedDQuotes = (Lex.DQuote &~ Escape)
[766]176        #
177        ### End parse_escape
[744]178       
[766]179        ### parallel_prefix_mask() --- we currently manually insert this method into the JSON template.c
[744]180       
[766]181        ### Start Generate String Mask ---
182        #
[744]183        StringMask = ParityMask & bitutil.Advance(ParityMask)
[766]184        #
185        ### End Generate String Mask ---
[744]186
[766]187        ### Start atom_starts   
188        #
[744]189        StringSpans = StringMask | UnescapedDQuotes
[755]190       
191        AtomSpans = (Lex.True | Lex.False | Lex.Null | Lex.Number | StringSpans)
192        AtomStarts = AtomSpans &~ bitutil.Advance(AtomSpans)
193               
194        StringStarts = AtomStarts & (Lex.DQuote)       
195        NumberStarts = AtomStarts & (Lex.Minus|Lex.Digit0_9)
196        TrueStarts = AtomStarts & (Lex.t)
197        FalseStarts = AtomStarts & (Lex.f)
198        NullStarts = AtomStarts & (Lex.n)       
[766]199        #
200        ### End atom_starts
[755]201       
[766]202        ### Start validate_string
203        #
[755]204        # (1) Validate escape characters
[766]205        StringEscapeChars = Escape & StringMask
[755]206        StringErrors = (StringEscapeChars &~ Lex.Escape)
207       
208        u = StringEscapeChars & Lex.u
209       
210        uScope1 = bitutil.Advance(u)
211        uScope2 = bitutil.Advance(uScope1)
212        uScope3 = bitutil.Advance(uScope2)
213        uScope4 = bitutil.Advance(uScope3)
214       
215        StringErrors |= uScope1 &~ Lex.HexDigit
216        StringErrors |= uScope2 &~ Lex.HexDigit
217        StringErrors |= uScope3 &~ Lex.HexDigit
218        StringErrors |= uScope4 &~ Lex.HexDigit
219       
220        # (2) Validation of unescaped characters
221        # (2.1) StringMask construction ensures all '"' are escaped.
222        # (2.2) '\' are either correctly escaped or the character following an odd length run is escaped.
[744]223
[766]224        StringNotEscapedChars = (~(Escape | Lex.RSolidus)) & StringMask
[755]225        StringErrors |= (StringNotEscapedChars & Ctrl.x00_x1F)
226       
227        # (3) Validate all strings are terminated with an unescaped "
228        StringCursor = bitutil.Advance(StringStarts)
229        StringEnds = bitutil.ScanThru(StringCursor, StringMask)
230        StringErrors |= StringEnds &~ UnescapedDQuotes
[766]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
[755]241
[766]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
[755]248       
[766]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
[755]322        # Consolidate errors
[766]323        error_mask = StringErrors | NumberErrors | TrueErrors | FalseErrors | NullErrors
[755]324
[739]325        return (u8,Lex,Ctrl,EOF_mask)
326
Note: See TracBrowser for help on using the repository browser.