source: proto/JSON/json_pablo_compilable.py @ 792

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

Add Pybit/Pablo? specific Python compilable files.

File size: 10.9 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        # Odd = simd_const_2(1) -> Parity.Odd, since 'Odd' will be defined as a member of the Parity struct
257        # Even = simd_const_2(2) -> Parity.Even, since 'Even' will be defined as a member of the Parity Struct
258        Start = Lex.RSolidus &~ bitutil.Advance(Lex.RSolidus)
259       
260        EvenStart = Start & Parity.Even
261        EvenFinal = (EvenStart + Lex.RSolidus) & ~Lex.RSolidus
262        EvenEscape = EvenFinal & Parity.Odd
263       
264        OddStart = Start & Parity.Odd
265        OddFinal = (OddStart + Lex.RSolidus) & ~Lex.RSolidus
266        OddEscape = (OddFinal & Parity.Even)
267
268        Escape = (EvenEscape | OddEscape) 
269        UnescapedDQuotes = (Lex.DQuote &~ Escape)
270        #
271        ### End parse_escape
272       
273        ### parallel_prefix_mask() --- we currently manually insert this method into the JSON template.c
274       
275        ### Start Generate String Mask ---
276        #
277        StringMask = Parity.ParityMask & bitutil.Advance(Parity.ParityMask)
278        StringSpans = StringMask | UnescapedDQuotes
279        #
280        ### End Generate String Mask ---
281
282        ### Start atom_starts   
283        #
284       
285       
286        StringStarts = StringSpans &~ bitutil.Advance(StringSpans)     
287
288        UnmaskedAtomSpans = (Lex.True | Lex.False | Lex.Null | Lex.Number) &~ StringSpans
289        UnmaskedAtomStarts = UnmaskedAtomSpans &~ bitutil.Advance(UnmaskedAtomSpans)
290
291        NumberStarts = UnmaskedAtomStarts & (Lex.Minus|Lex.Digit0_9)
292        TrueStarts = UnmaskedAtomStarts & (Lex.t)
293        FalseStarts = UnmaskedAtomStarts & (Lex.f)
294        NullStarts = UnmaskedAtomStarts & (Lex.n)
295       
296        #
297        ### End atom_starts
298       
299        ### Start validate_string
300        #
301        # (1) Validate escape characters
302        StringEscapeChars = Escape & StringMask
303        StringErrors = (StringEscapeChars &~ Lex.Escape)
304       
305        u = StringEscapeChars & Lex.u
306       
307        uScope1 = bitutil.Advance(u)
308        uScope2 = bitutil.Advance(uScope1)
309        uScope3 = bitutil.Advance(uScope2)
310        uScope4 = bitutil.Advance(uScope3)
311       
312        StringErrors |= uScope1 &~ Lex.HexDigit
313        StringErrors |= uScope2 &~ Lex.HexDigit
314        StringErrors |= uScope3 &~ Lex.HexDigit
315        StringErrors |= uScope4 &~ Lex.HexDigit
316       
317        # (2) Validation of unescaped characters
318        # (2.1) StringMask construction ensures all '"' are escaped.
319        # (2.2) '\' are either correctly escaped or the character following an odd length run is escaped.
320
321        StringNotEscapedChars = (~(Escape | Lex.RSolidus)) & StringMask
322        StringErrors |= (StringNotEscapedChars & Ctrl.x00_x1F)
323       
324        # (3) Validate all strings are terminated with an unescaped "
325        StringCursor = bitutil.Advance(StringStarts)
326        StringEnds = bitutil.ScanThru(StringCursor, StringMask)
327        StringErrors |= StringEnds &~ UnescapedDQuotes
328        #
329        ### End validate_string
330       
331        ### Start validate_number
332        #
333        M0 = NumberStarts                                       # Initialize marker stream     
334       
335        M1 = bitutil.ScanThru(M0, Lex.Minus & M0)               # ? Optional character class [-]
336        E1 = M1 &~(Lex.Zero|Lex.Digit1_9)
337        M1 = M1 &~ E1                                           # Remove cursors at error positions so as to report a single error position
338
339        M1a = M1 & Lex.Zero                                     # Split
340        M1b = M1 & Lex.Digit1_9                         
341        M2a = bitutil.Advance(M1a)
342        M2b = bitutil.Advance(M1b)
343        M3b = bitutil.ScanThru(M2b,Lex.Digit0_9)
344        M4 =  M2a | M3b                                         # Join
345       
346        M4a = M4 &~(Lex.DecimalPoint)                           # Split
347        M4b = M4 & (Lex.DecimalPoint)
348        M5b = bitutil.Advance(M4b)
349        E5b = M5b &~(Lex.Digit0_9)                              # + [0-9]+
350        M5b = M5b &~E5b                                         # Remove cursors at error positions so as to report a single error position
351       
352        M6 = bitutil.ScanThru(M5b,Lex.Digit0_9)
353        M7 = M4a | M6                                           # Join
354       
355        M7a = M7 &~(Lex.Ee)                                     # Split
356        M7b = M7 & (Lex.Ee)
357        M8b = bitutil.Advance(M7b)
358        M9b = bitutil.ScanThru(M8b, Lex.PlusMinus & M8b)        # ? Optional character class [+-]               
359        E9b  = M9b &~(Lex.Digit0_9)                             # + [0-9]+
360        M9b = M9b &~ E9b                                        # Remove cursors at error positions so as to report a single error position
361        M10b = bitutil.ScanThru(M9b,Lex.Digit0_9)
362
363        M11 = E1 | E5b | E9b | M7a | M10b                       # Record final marker positions,
364                                                                # At Advance(M11) this positions is either (1) a known error position or (2) an undetermined position to be checked
365       
366        NumberErrors = E1 | E5b | E9b
367       
368        NumberSpans = M11 - M0
369        #
370        ### End validate_number
371
372        ### Start validate_true
373        #
374        TrueScope1 = bitutil.Advance(TrueStarts)
375        TrueScope2 = bitutil.Advance(TrueScope1)
376        TrueScope3 = bitutil.Advance(TrueScope2)
377       
378        TrueErrors = TrueScope1 &~ Lex.r
379        TrueErrors |= TrueScope2 &~ Lex.u
380        TrueErrors |= TrueScope3 &~ Lex.e
381       
382        TrueFollows = bitutil.Advance(TrueScope3)
383        TrueSpans = TrueFollows - TrueStarts
384        #
385        ### End validate_true
386
387        ### Start validate_false
388        #
389        FalseScope1 = bitutil.Advance(FalseStarts)
390        FalseScope2 = bitutil.Advance(FalseScope1)
391        FalseScope3 = bitutil.Advance(FalseScope2)
392        FalseScope4 = bitutil.Advance(FalseScope3)
393       
394        FalseErrors = FalseScope1 &~ Lex.a
395        FalseErrors |= FalseScope2 &~ Lex.l
396        FalseErrors |= FalseScope3 &~ Lex.s
397        FalseErrors |= FalseScope4 &~ Lex.e
398
399        FalseFollows = bitutil.Advance(FalseScope4)
400        FalseSpans = FalseFollows - FalseStarts
401        #
402        ### End validate_false
403       
404        ### Start validate_null
405        #
406        NullScope1 = bitutil.Advance(NullStarts)
407        NullScope2 = bitutil.Advance(NullScope1)
408        NullScope3 = bitutil.Advance(NullScope2)
409       
410        NullErrors |= NullScope1 &~ Lex.u
411        NullErrors |= NullScope2 &~ Lex.l
412        NullErrors |= NullScope3 &~ Lex.l
413       
414        NullFollows = bitutil.Advance(NullScope3)
415        NullSpans = NullFollows - NullStarts
416        #
417        ### End validate_null
418
419        # AtomSpans & AtomsStarts serve as the basic interface to ANTLR
420        AtomStarts = StringStarts | NumberStarts | TrueStarts | FalseStarts | NullStarts
421        AtomSpans = StringSpans | NumberSpans | TrueSpans | FalseSpans | NullSpans
422
423        # Consolidate errors
424        error_mask = StringErrors | NumberErrors | TrueErrors | FalseErrors | NullErrors
425
Note: See TracBrowser for help on using the repository browser.