source: proto/JSON/json_pablo_compilable.py @ 872

Last change on this file since 872 was 872, checked in by ksherdy, 9 years ago

Add call to bitblock_prefix_parity to avoid manual insertion.

File size: 11.2 KB
Line 
1# -*- coding: utf-8 -*-
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# December 7, 2010
12#
13
14class u8 ():
15        unibyte = 0
16        prefix = 0
17        prefix2 = 0
18        prefix3 = 0
19        prefix4 = 0
20        suffix = 0
21        badprefix = 0
22        xE0 = 0
23        xED = 0
24        xF0 = 0
25        xF4 = 0
26        xA0_xBF = 0
27        x80_x9F = 0
28        x90_xBF = 0
29        x80_x8F = 0
30        xEF = 0
31        xBF = 0
32        xBE = 0
33        scope22 = 0
34        scope32 = 0
35        scope33 = 0
36        scope42 = 0
37        scope43 = 0
38        scope44 = 0
39        error = 0
40
41class Lex ():   
42        #Object
43        LCurlyBrace = 0
44        Colon = 0
45        Comma = 0
46        RCurlyBrace = 0
47       
48        #Array
49        LSquareBracket = 0
50        RSquareBracket = 0
51       
52        #Number
53        Number = 0
54        Minus = 0
55        Zero = 0
56        Digit1_9 = 0
57        Digit0_9 = 0
58        DecimalPoint = 0
59        Ee = 0
60        PlusMinus = 0
61       
62        #String
63        DQuote = 0
64        RSolidus = 0
65#       Solidus = 0
66#       b = 0
67#       f = 0
68#       n = 0
69#       t = 0
70        u = 0
71        Escape = 0
72        HexDigit = 0
73        NotUnescaped = 0       
74        # White space
75        WS = 0
76       
77        True = 0
78        t = 0
79        r = 0
80#       u = 0
81        e = 0
82       
83        False = 0
84        f = 0
85        a = 0
86        l = 0
87        s = 0
88#       e = 0
89       
90        Null = 0
91        n = 0
92#       u = 0
93#       l = 0
94#       l = 0   
95
96class Ctrl ():
97        x00_x1F = 0
98        CR = 0
99        LF = 0
100        HT = 0
101        SP = 0 
102
103class Parity ():
104        Odd = 0
105        Even = 0
106        ParityMask = 0
107
108def main(u8data):
109        ### Transpose to parallel bit streams and prepare an EOF mask.
110        # (bit, EOF_mask) = bitutil.transpose_streams(u8data)
111
112        ### Classify bytes for UTF-8 processing, whitespace control processing, and JSON lexical analysis.     
113        u8.unibyte = (~bit[0]);
114        u8.prefix = (bit[0] & bit[1]);
115        u8.prefix2 = (u8.prefix &~ bit[2]);
116        temp1 = (bit[2] &~ bit[3]);
117        u8.prefix3 = (u8.prefix & temp1);
118        temp2 = (bit[2] & bit[3]);
119        u8.prefix4 = (u8.prefix & temp2);
120        u8.suffix = (bit[0] &~ bit[1]);
121        temp3 = (bit[2] | bit[3]);
122        temp4 = (u8.prefix &~ temp3);
123        temp5 = (bit[4] | bit[5]);
124        temp6 = (temp5 | bit[6]);
125        temp7 = (temp4 &~ temp6);
126        temp8 = (bit[6] | bit[7]);
127        temp9 = (bit[5] & temp8);
128        temp10 = (bit[4] | temp9);
129        temp11 = (u8.prefix4 & temp10);
130        u8.badprefix = (temp7 | temp11);
131        temp12 = (temp5 | temp8);
132        u8.xE0 = (u8.prefix3 &~ temp12);
133        temp13 = (bit[4] & bit[5]);
134        temp14 = (bit[7] &~ bit[6]);
135        temp15 = (temp13 & temp14);
136        u8.xED = (u8.prefix3 & temp15);
137        u8.xF0 = (u8.prefix4 &~ temp12);
138        temp16 = (bit[5] &~ bit[4]);
139        temp17 = (temp16 &~ temp8);
140        u8.xF4 = (u8.prefix4 & temp17);
141        u8.xA0_xBF = (u8.suffix & bit[2]);
142        u8.x80_x9F = (u8.suffix &~ bit[2]);
143        u8.x90_xBF = (u8.suffix & temp3);
144        u8.x80_x8F = (u8.suffix &~ temp3);
145        temp18 = (bit[0] | bit[1]);
146        temp19 = (temp18 | bit[2]);
147        ctrl.x00_x1F = (~temp19);
148        temp20 = (temp18 | temp3);
149        ctrl.CR = (temp15 &~ temp20);
150        temp21 = (bit[4] &~ bit[5]);
151        temp22 = (bit[6] &~ bit[7]);
152        temp23 = (temp21 & temp22);
153        ctrl.LF = (temp23 &~ temp20);
154        temp24 = (temp21 & temp14);
155        ctrl.HT = (temp24 &~ temp20);
156        temp25 = (temp1 &~ temp18);
157        ctrl.SP = (temp25 &~ temp12);
158        temp26 = (bit[1] &~ bit[0]);
159        temp27 = (temp26 & temp2);
160        temp28 = (bit[6] & bit[7]);
161        temp29 = (temp21 & temp28);
162        lex.LCurlyBrace = (temp27 & temp29);
163        temp30 = (temp2 &~ temp18);
164        lex.Colon = (temp30 & temp23);
165        temp31 = (temp13 &~ temp8);
166        lex.Comma = (temp25 & temp31);
167        lex.RCurlyBrace = (temp27 & temp15);
168        temp32 = (bit[3] &~ bit[2]);
169        temp33 = (temp26 & temp32);
170        lex.LSquareBracket = (temp33 & temp29);
171        lex.RSquareBracket = (temp33 & temp15);
172        lex.Minus = (temp25 & temp15);
173        lex.Zero = (temp30 &~ temp12);
174        temp34 = (bit[5] | bit[6]);
175        temp35 = (~temp34);
176        temp36 = (bit[5] | temp8);
177        temp37 = ((bit[4] & temp35)|(~(bit[4]) & temp36));
178        lex.Digit1_9 = (temp30 & temp37);
179        temp38 = (bit[4] & temp34);
180        lex.Digit0_9 = (temp30 &~ temp38);
181        temp39 = (temp13 & temp22);
182        lex.DecimalPoint = (temp25 & temp39);
183        temp40 = (temp16 & temp14);
184        temp41 = (temp3 &~ temp1);
185        temp42 = (temp26 &~ temp41);
186        lex.Ee = (temp40 & temp42);
187        temp43 = (temp29 | temp15);
188        lex.PlusMinus = (temp25 & temp43);
189        temp44 = (lex.Minus | lex.Digit0_9);
190        temp45 = (temp44 | lex.DecimalPoint);
191        temp46 = (temp26 &~ temp3);
192        temp47 = (temp46 & temp40);
193        temp48 = (temp45 | temp47);
194        temp49 = (temp26 & temp1);
195        temp50 = (temp49 & temp40);
196        temp51 = (temp48 | temp50);
197        temp52 = (temp25 & temp29);
198        temp53 = (temp51 | temp52);
199        lex.Number = (temp53 | lex.Minus);
200        temp54 = (temp22 &~ temp5);
201        lex.DQuote = (temp25 & temp54);
202        lex.RSolidus = (temp33 & temp31);
203        lex.u = (temp27 & temp40);
204        temp55 = (lex.DQuote | lex.RSolidus);
205        temp56 = (temp13 & temp28);
206        temp57 = (temp25 & temp56);
207        temp58 = (temp55 | temp57);
208        temp59 = (temp49 & temp54);
209        temp60 = (temp58 | temp59);
210        temp61 = (temp16 & temp22);
211        temp62 = (temp49 & temp61);
212        temp63 = (temp60 | temp62);
213        temp64 = (temp49 & temp39);
214        temp65 = (temp63 | temp64);
215        temp66 = (temp27 & temp54);
216        temp67 = (temp65 | temp66);
217        temp68 = (temp27 & temp17);
218        temp69 = (temp67 | temp68);
219        lex.Escape = (temp69 | lex.u);
220        temp70 = (temp49 &~ bit[4]);
221        temp71 = (~temp28);
222        temp72 = ((bit[5] & temp71)|(~(bit[5]) & temp8));
223        temp73 = (temp70 & temp72);
224        temp74 = (lex.Digit0_9 | temp73);
225        temp75 = (temp46 &~ bit[4]);
226        temp76 = (temp75 & temp72);
227        lex.HexDigit = (temp74 | temp76);
228        temp77 = (temp15 | temp23);
229        temp78 = (temp77 | temp24);
230        temp79 = (temp78 &~ temp20);
231        lex.WS = (temp79 | ctrl.SP);
232        lex.t = (temp27 & temp17);
233        lex.r = (temp27 & temp54);
234        lex.e = (temp49 & temp40);
235        temp80 = (temp17 | temp54);
236        temp81 = (temp80 | temp40);
237        temp82 = (temp27 & temp81);
238        lex.True = (temp82 | lex.e);
239        lex.f = (temp49 & temp61);
240        temp83 = (temp14 &~ temp5);
241        lex.a = (temp49 & temp83);
242        lex.l = (temp49 & temp31);
243        temp84 = (temp28 &~ temp5);
244        lex.s = (temp27 & temp84);
245        temp85 = (temp61 | temp83);
246        temp86 = (temp85 | temp31);
247        temp87 = (temp49 & temp86);
248        temp88 = (temp87 | lex.s);
249        lex.False = (temp88 | lex.e);
250        lex.n = (temp49 & temp39);
251        temp89 = (lex.n | lex.u);
252        lex.Null = (temp89 | lex.l);
253
254        ### Start parse_escape
255        #
256        # parity.Odd = simd_const_2(1) -> parity.Odd, since 'Odd' will be defined as a member of the Parity struct
257        # parity.Even = simd_const_2(2) -> parity.Even, since 'Even' will be defined as a member of the Parity Struct
258       
259       
260        Start = lex.RSolidus &~ bitutil.Advance(lex.RSolidus)
261       
262        EvenStart = Start & parity.Even
263        EvenFinal = (EvenStart + lex.RSolidus) & ~lex.RSolidus
264        EvenEscape = EvenFinal & parity.Odd
265       
266        OddStart = Start & parity.Odd
267        OddFinal = (OddStart + lex.RSolidus) & ~lex.RSolidus
268        OddEscape = (OddFinal & parity.Even)
269
270        Escape = (EvenEscape | OddEscape) 
271        UnescapedDQuotes = (lex.DQuote &~ Escape)
272        #
273        ### End parse_escape
274       
275        ### parallel_prefix_mask() --- we currently manually insert this method into the JSON template.c
276        # A hack to avoid the need for manual insertion of parity.ParityMask generation
277        parity.ParityMask = bitblock_parallel_prefix_parity(UnescapedDQuotes, bitblock_parity_mask);
278        parity.ParityMask = simd_and(parity.ParityMask, EOF_mask);     
279       
280        ### Start Generate String Mask ---
281        #
282        StringMask = parity.ParityMask & bitutil.Advance(parity.ParityMask)
283        StringSpans = StringMask | UnescapedDQuotes
284        #
285        ### End Generate String Mask ---
286
287        ### Start atom_starts   
288        #
289       
290       
291        StringStarts = StringSpans &~ bitutil.Advance(StringSpans)     
292
293        UnmaskedAtomSpans = (lex.True | lex.False | lex.Null | lex.Number) &~ StringSpans
294        UnmaskedAtomStarts = UnmaskedAtomSpans &~ bitutil.Advance(UnmaskedAtomSpans)
295
296        NumberStarts = UnmaskedAtomStarts & (lex.Minus|lex.Digit0_9)
297        TrueStarts = UnmaskedAtomStarts & (lex.t)
298        FalseStarts = UnmaskedAtomStarts & (lex.f)
299        NullStarts = UnmaskedAtomStarts & (lex.n)
300       
301        #
302        ### End atom_starts
303       
304        ### Start validate_string
305        #
306        # (1) Validate escape characters
307        StringEscapeChars = Escape & StringMask
308        StringErrors = (StringEscapeChars &~ lex.Escape)
309       
310        u = StringEscapeChars & lex.u
311       
312        uScope1 = bitutil.Advance(u)
313        uScope2 = bitutil.Advance(uScope1)
314        uScope3 = bitutil.Advance(uScope2)
315        uScope4 = bitutil.Advance(uScope3)
316       
317        StringErrors |= uScope1 &~ lex.HexDigit
318        StringErrors |= uScope2 &~ lex.HexDigit
319        StringErrors |= uScope3 &~ lex.HexDigit
320        StringErrors |= uScope4 &~ lex.HexDigit
321       
322        # (2) Validation of unescaped characters
323        # (2.1) StringMask construction ensures all '"' are escaped.
324        # (2.2) '\' are either correctly escaped or the character following an odd length run is escaped.
325
326        StringNotEscapedChars = (~(Escape | lex.RSolidus)) & StringMask
327        StringErrors |= (StringNotEscapedChars & ctrl.x00_x1F)
328       
329        # (3) Validate all strings are terminated with an unescaped "
330        StringCursor = bitutil.Advance(StringStarts)
331        StringEnds = bitutil.ScanThru(StringCursor, StringMask)
332        StringErrors |= StringEnds &~ UnescapedDQuotes
333        #
334        ### End validate_string
335       
336        ### Start validate_number
337        #
338        M0 = NumberStarts                                       # Initialize marker stream     
339       
340        M1 = bitutil.ScanThru(M0, lex.Minus & M0)               # ? Optional character class [-]
341        E1 = M1 &~(lex.Zero|lex.Digit1_9)
342        M1 = M1 &~ E1                                           # Remove cursors at error positions so as to report a single error position
343
344        M1a = M1 & lex.Zero                                     # Split
345        M1b = M1 & lex.Digit1_9                         
346        M2a = bitutil.Advance(M1a)
347        M2b = bitutil.Advance(M1b)
348        M3b = bitutil.ScanThru(M2b,lex.Digit0_9)
349        M4 =  M2a | M3b                                         # Join
350       
351        M4a = M4 &~(lex.DecimalPoint)                           # Split
352        M4b = M4 & (lex.DecimalPoint)
353        M5b = bitutil.Advance(M4b)
354        E5b = M5b &~(lex.Digit0_9)                              # + [0-9]+
355        M5b = M5b &~E5b                                         # Remove cursors at error positions so as to report a single error position
356       
357        M6 = bitutil.ScanThru(M5b,lex.Digit0_9)
358        M7 = M4a | M6                                           # Join
359       
360        M7a = M7 &~(lex.Ee)                                     # Split
361        M7b = M7 & (lex.Ee)
362        M8b = bitutil.Advance(M7b)
363        M9b = bitutil.ScanThru(M8b, lex.PlusMinus & M8b)        # ? Optional character class [+-]               
364        E9b  = M9b &~(lex.Digit0_9)                             # + [0-9]+
365        M9b = M9b &~ E9b                                        # Remove cursors at error positions so as to report a single error position
366        M10b = bitutil.ScanThru(M9b,lex.Digit0_9)
367
368        M11 = E1 | E5b | E9b | M7a | M10b                       # Record final marker positions,
369                                                                # At Advance(M11) this positions is either (1) a known error position or (2) an undetermined position to be checked
370       
371        NumberErrors = E1 | E5b | E9b
372       
373        NumberSpans = M11 - M0
374        #
375        ### End validate_number
376
377        ### Start validate_true
378        #
379        TrueScope1 = bitutil.Advance(TrueStarts)
380        TrueScope2 = bitutil.Advance(TrueScope1)
381        TrueScope3 = bitutil.Advance(TrueScope2)
382       
383        TrueErrors = TrueScope1 &~ lex.r
384        TrueErrors |= TrueScope2 &~ lex.u
385        TrueErrors |= TrueScope3 &~ lex.e
386       
387        TrueFollows = bitutil.Advance(TrueScope3)
388        TrueSpans = TrueFollows - TrueStarts
389        #
390        ### End validate_true
391
392        ### Start validate_false
393        #
394        FalseScope1 = bitutil.Advance(FalseStarts)
395        FalseScope2 = bitutil.Advance(FalseScope1)
396        FalseScope3 = bitutil.Advance(FalseScope2)
397        FalseScope4 = bitutil.Advance(FalseScope3)
398       
399        FalseErrors = FalseScope1 &~ lex.a
400        FalseErrors |= FalseScope2 &~ lex.l
401        FalseErrors |= FalseScope3 &~ lex.s
402        FalseErrors |= FalseScope4 &~ lex.e
403
404        FalseFollows = bitutil.Advance(FalseScope4)
405        FalseSpans = FalseFollows - FalseStarts
406        #
407        ### End validate_false
408       
409        ### Start validate_null
410        #
411        NullScope1 = bitutil.Advance(NullStarts)
412        NullScope2 = bitutil.Advance(NullScope1)
413        NullScope3 = bitutil.Advance(NullScope2)
414       
415        NullErrors |= NullScope1 &~ lex.u
416        NullErrors |= NullScope2 &~ lex.l
417        NullErrors |= NullScope3 &~ lex.l
418       
419        NullFollows = bitutil.Advance(NullScope3)
420        NullSpans = NullFollows - NullStarts
421        #
422        ### End validate_null
423
424        # AtomSpans & AtomsStarts serve as the basic interface to ANTLR
425        AtomStarts = StringStarts | NumberStarts | TrueStarts | FalseStarts | NullStarts
426        AtomSpans = StringSpans | NumberSpans | TrueSpans | FalseSpans | NullSpans
427
428        # Consolidate errors
429        error_mask = StringErrors | NumberErrors | TrueErrors | FalseErrors | NullErrors
430
Note: See TracBrowser for help on using the repository browser.