Changeset 682


Ignore:
Timestamp:
Oct 29, 2010, 2:37:43 PM (9 years ago)
Author:
ksherdy
Message:

Add UTF8 validation. Add UTF8 character set definitions.

Location:
proto/JSON
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • proto/JSON/byteclass.py

    r675 r682  
    66#
    77
     8class u8_streams ():
     9        unibyte = 0
     10        prefix = 0
     11        prefix2 = 0
     12        prefix3 = 0
     13        prefix4 = 0
     14        suffix = 0
     15        badprefix = 0
     16        xE0 = 0
     17        xED = 0
     18        xF0 = 0
     19        xF4 = 0
     20        xA0_xBF = 0
     21        x80_x9F = 0
     22        x90_xBF = 0
     23        x80_x8F = 0
     24        xEF = 0
     25        xBF = 0
     26        xBE = 0
     27        scope22 = 0
     28        scope32 = 0
     29        scope33 = 0
     30        scope42 = 0
     31        scope43 = 0
     32        scope44 = 0
     33        error = 0
     34
    835class lexical_streams ():
    9         """
     36        r"""
    1037        RFC 4627 - JavaScript Object Notation (JSON) 
    1138        RFC 5234 - Augmented BNF for Syntax Specifications: ABNF
    12        
    13         number = [ minus ] int [ frac ] [ exp ]
    14         decimal-point = %x2E       ; .
    15         digit1-9 = %x31-39         ; 1-9
    16         e = %x65 / %x45            ; e E
    17         exp = e [ minus / plus ] 1*DIGIT
    18         frac = decimal-point 1*DIGIT
    19         int = zero / ( digit1-9 *DIGIT )
    20         minus = %x2D               ; -
    21         plus = %x2B                ; +
    22         zero = %x30                ; 0
    23        
    24         Any single character alternative can be combined into a single character class.
    25        
    2639        """
    2740        #Object
     
    5164        t = 0
    5265        u = 0
    53         Digit0_ = 0
     66        HexDigit = 0
     67       
     68class control_streams ():
     69        r"""
     70        RFC 4627 - JavaScript Object Notation (JSON) 
     71        """
     72        x00_x1F = 0
     73        CR = 0
     74        LF = 0
     75        HT = 0
     76        SP = 0 
    5477
    5578def classify_bytes(bit) :
     79  u8 = u8_streams()
    5680  lex = lexical_streams()
    57   temp1 = (bit[1] &~ bit[0]);
     81  ctrl = control_streams()
     82  u8.unibyte = (~bit[0]);
     83  u8.prefix = (bit[0] & bit[1]);
     84  u8.prefix2 = (u8.prefix &~ bit[2]);
     85  temp1 = (bit[2] &~ bit[3]);
     86  u8.prefix3 = (u8.prefix & temp1);
    5887  temp2 = (bit[2] & bit[3]);
    59   temp3 = (temp1 & temp2);
    60   temp4 = (bit[4] &~ bit[5]);
    61   temp5 = (bit[6] & bit[7]);
    62   temp6 = (temp4 & temp5);
    63   lex.LCurlyBrace = (temp3 & temp6);
    64   temp7 = (bit[0] | bit[1]);
    65   temp8 = (temp2 &~ temp7);
    66   temp9 = (bit[6] &~ bit[7]);
    67   temp10 = (temp4 & temp9);
    68   lex.Colon = (temp8 & temp10);
    69   temp11 = (bit[2] &~ bit[3]);
    70   temp12 = (temp11 &~ temp7);
     88  u8.prefix4 = (u8.prefix & temp2);
     89  u8.suffix = (bit[0] &~ bit[1]);
     90  temp3 = (bit[2] | bit[3]);
     91  temp4 = (u8.prefix &~ temp3);
     92  temp5 = (bit[4] | bit[5]);
     93  temp6 = (temp5 | bit[6]);
     94  temp7 = (temp4 &~ temp6);
     95  temp8 = (bit[6] | bit[7]);
     96  temp9 = (bit[5] & temp8);
     97  temp10 = (bit[4] | temp9);
     98  temp11 = (u8.prefix4 & temp10);
     99  u8.badprefix = (temp7 | temp11);
     100  temp12 = (temp5 | temp8);
     101  u8.xE0 = (u8.prefix3 &~ temp12);
    71102  temp13 = (bit[4] & bit[5]);
    72   temp14 = (bit[6] | bit[7]);
    73   temp15 = (temp13 &~ temp14);
    74   lex.Comma = (temp12 & temp15);
    75   temp16 = (bit[7] &~ bit[6]);
    76   temp17 = (temp13 & temp16);
    77   lex.RCurlyBrace = (temp3 & temp17);
    78   temp18 = (bit[3] &~ bit[2]);
    79   temp19 = (temp1 & temp18);
    80   lex.LSquareBracket = (temp19 & temp6);
    81   lex.RSquareBracket = (temp19 & temp17);
    82   lex.Minus = (temp12 & temp17);
    83   temp20 = (bit[4] | bit[5]);
    84   temp21 = (temp20 | temp14);
    85   lex.Zero = (temp8 &~ temp21);
    86   temp22 = (bit[5] | bit[6]);
    87   temp23 = (~temp22);
    88   temp24 = (bit[5] | temp14);
    89   temp25 = ((bit[4] & temp23)|(~(bit[4]) & temp24));
    90   lex.Digit1_9 = (temp8 & temp25);
    91   temp26 = (bit[4] & temp22);
    92   lex.Digit0_9 = (temp8 &~ temp26);
    93   temp27 = (temp13 & temp9);
    94   lex.DecimalPoint = (temp12 & temp27);
    95   temp28 = (bit[5] &~ bit[4]);
    96   temp29 = (temp28 & temp16);
    97   temp30 = (bit[2] | bit[3]);
    98   temp31 = (temp30 &~ temp11);
    99   temp32 = (temp1 &~ temp31);
    100   lex.Ee = (temp29 & temp32);
    101   temp33 = (temp6 | temp17);
    102   lex.PlusMinus = (temp12 & temp33);
    103   temp34 = (lex.Comma | lex.RCurlyBrace);
    104   lex.NumberFollowSet = (temp34 | lex.RSquareBracket);
    105   lex.DQuote = (temp19 & temp15);
    106   lex.RSolidus = (temp19 & temp15);
    107   lex.Solidus = (temp19 & temp15);
    108   lex.b = (temp19 & temp15);
    109   lex.f = (temp19 & temp15);
    110   lex.n = (temp19 & temp15);
    111   lex.t = (temp19 & temp15);
    112   lex.u = (temp19 & temp15);
    113   temp35 = (temp1 &~ temp30);
    114   temp36 = (temp35 &~ bit[4]);
    115   temp37 = (~temp5);
    116   temp38 = ((bit[5] & temp37)|(~(bit[5]) & temp14));
    117   temp39 = (temp36 & temp38);
    118   lex.Digit0_9 = (lex.Digit0_9 | temp39);
    119   return (lex)
     103  temp14 = (bit[7] &~ bit[6]);
     104  temp15 = (temp13 & temp14);
     105  u8.xED = (u8.prefix3 & temp15);
     106  u8.xF0 = (u8.prefix4 &~ temp12);
     107  temp16 = (bit[5] &~ bit[4]);
     108  temp17 = (temp16 &~ temp8);
     109  u8.xF4 = (u8.prefix4 & temp17);
     110  u8.xA0_xBF = (u8.suffix & bit[2]);
     111  u8.x80_x9F = (u8.suffix &~ bit[2]);
     112  u8.x90_xBF = (u8.suffix & temp3);
     113  u8.x80_x8F = (u8.suffix &~ temp3);
     114  temp18 = (bit[0] | bit[1]);
     115  temp19 = (temp18 | bit[2]);
     116  ctrl.x00_x1F = (~temp19);
     117  temp20 = (temp18 | temp3);
     118  ctrl.CR = (temp15 &~ temp20);
     119  temp21 = (bit[4] &~ bit[5]);
     120  temp22 = (bit[6] &~ bit[7]);
     121  temp23 = (temp21 & temp22);
     122  ctrl.LF = (temp23 &~ temp20);
     123  temp24 = (temp21 & temp14);
     124  ctrl.HT = (temp24 &~ temp20);
     125  temp25 = (temp1 &~ temp18);
     126  ctrl.SP = (temp25 &~ temp12);
     127  temp26 = (bit[1] &~ bit[0]);
     128  temp27 = (temp26 & temp2);
     129  temp28 = (bit[6] & bit[7]);
     130  temp29 = (temp21 & temp28);
     131  lex.LCurlyBrace = (temp27 & temp29);
     132  temp30 = (temp2 &~ temp18);
     133  lex.Colon = (temp30 & temp23);
     134  temp31 = (temp13 &~ temp8);
     135  lex.Comma = (temp25 & temp31);
     136  lex.RCurlyBrace = (temp27 & temp15);
     137  temp32 = (bit[3] &~ bit[2]);
     138  temp33 = (temp26 & temp32);
     139  lex.LSquareBracket = (temp33 & temp29);
     140  lex.RSquareBracket = (temp33 & temp15);
     141  lex.Minus = (temp25 & temp15);
     142  lex.Zero = (temp30 &~ temp12);
     143  temp34 = (bit[5] | bit[6]);
     144  temp35 = (~temp34);
     145  temp36 = (bit[5] | temp8);
     146  temp37 = ((bit[4] & temp35)|(~(bit[4]) & temp36));
     147  lex.Digit1_9 = (temp30 & temp37);
     148  temp38 = (bit[4] & temp34);
     149  lex.Digit0_9 = (temp30 &~ temp38);
     150  temp39 = (temp13 & temp22);
     151  lex.DecimalPoint = (temp25 & temp39);
     152  temp40 = (temp16 & temp14);
     153  temp41 = (temp3 &~ temp1);
     154  temp42 = (temp26 &~ temp41);
     155  lex.Ee = (temp40 & temp42);
     156  temp43 = (temp29 | temp15);
     157  lex.PlusMinus = (temp25 & temp43);
     158  temp44 = (lex.Comma | lex.RCurlyBrace);
     159  lex.NumberFollowSet = (temp44 | lex.RSquareBracket);
     160  lex.DQuote = (temp33 & temp31);
     161  lex.RSolidus = (temp33 & temp31);
     162  lex.Solidus = (temp33 & temp31);
     163  lex.b = (temp33 & temp31);
     164  lex.f = (temp33 & temp31);
     165  lex.n = (temp33 & temp31);
     166  lex.t = (temp33 & temp31);
     167  lex.u = (temp33 & temp31);
     168  temp45 = (temp26 & temp1);
     169  temp46 = (temp45 &~ bit[4]);
     170  temp47 = (~temp28);
     171  temp48 = ((bit[5] & temp47)|(~(bit[5]) & temp8));
     172  temp49 = (temp46 & temp48);
     173  temp50 = (lex.Digit0_9 | temp49);
     174  temp51 = (temp26 &~ temp3);
     175  temp52 = (temp51 &~ bit[4]);
     176  temp53 = (temp52 & temp48);
     177  lex.HexDigit = (temp50 | temp53);
     178  temp54 = (temp15 | temp23);
     179  temp55 = (temp54 | temp24);
     180  temp56 = (temp55 &~ temp20);
     181  lex.WS = (temp56 | ctrl.SP); 
     182  return (u8,lex,ctrl)
    120183
  • proto/JSON/json_prototype.py

    r675 r682  
    1717import bitutil
    1818import byteclass
     19import u8u16
    1920import math
    2021import sys
     
    2425
    2526# Globals
     27#
    2628# Bitstream function defs input/output *only* bitstream type variables.
    2729# Global declarations allow debug blocks in bitstream defs. Do not shadow variables.
     
    155157
    156158        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    157         (lex) = byteclass.classify_bytes(bit)
     159        (u8, lex, ctrl) = byteclass.classify_bytes(bit)
    158160        Errors = validate_number(lex,EOF_mask)
    159161
     
    199201
    200202        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    201         (lex) = byteclass.classify_bytes(bit)
     203        (u8, lex, ctrl) = byteclass.classify_bytes(bit)
    202204        (escape) = parse_escape(lex,EOF_mask)
    203205
     
    251253
    252254        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    253         (lex) = byteclass.classify_bytes(bit)
     255        (u8, lex, ctrl) = byteclass.classify_bytes(bit)
    254256        brackets = (lex.LSquareBracket | lex.RSquareBracket)
    255257        (parity) = parallel_prefix_parity(brackets,lgth)
     
    262264        return
    263265
     266def parse_json(u8data):
     267 
     268        # Transpose to parallel bit streams and prepare an EOF mask.
     269        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
     270
     271        # Classify bytes for UTF-8 processing, whitespace, control and JSON lexical analysis.
     272        (u8, control, lex) = byteclass.classify_bytes(bit)
     273
     274        # Validate UTF-8 multibyte sequences and determine the UTF-8 scope streams.
     275        u8 = u8u16.validate_utf8(u8) 
     276 
     277        return
     278 
     279def demo_parse_json(u8data):
     280 
     281        global lgth
     282        lgth = len(u8data)
     283       
     284        parse_json(u8data)
     285 
     286        return
     287
    264288if __name__ == "__main__":
    265289        import doctest
     
    273297#       demo_validate_number(u8data)
    274298#       demo_parse_escape(u8data)
    275         demo_parallel_prefix_parity(u8data)
     299#       demo_parallel_prefix_parity(u8data)
     300#       demo_parse_json(u8data)
Note: See TracChangeset for help on using the changeset viewer.