Ignore:
Timestamp:
Oct 30, 2010, 4:34:25 PM (9 years ago)
Author:
ksherdy
Message:

General reorganization. Addition of JSON String processing logic.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/JSON/json_prototype.py

    r682 r684  
    3030u8data = ""
    3131lgth = 0
     32
     33def simd_const_4(hexdigit,EOF_mask):
     34        r"""
     35        IDISA library function.
     36        """
     37        lgth = bitutil.count_leading_zeroes(~EOF_mask)/4
     38        return int(hexdigit*(lgth+1),16)&EOF_mask
     39       
     40def parse_escape(lex, EOF_mask):
     41        odd = simd_const_4('a',EOF_mask)
     42        even = simd_const_4('5',EOF_mask)
     43       
     44        start = lex.RSolidus &~ bitutil.Advance(lex.RSolidus)
     45       
     46        even_start = start & even
     47        even_final = (even_start + lex.RSolidus) & ~lex.RSolidus
     48        even_escape = even_final & odd
     49       
     50        odd_start = start & odd
     51        odd_final = (odd_start + lex.RSolidus) & ~lex.RSolidus
     52        odd_escape = (odd_final & even)
     53       
     54        escape = (even_escape | odd_escape)
     55       
     56        return escape
     57       
     58def demo_parse_escape(u8data):
     59        global lgth
     60        lgth = len(u8data)
     61
     62        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
     63        (u8, lex, ctrl) = byteclass.classify_bytes(bit)
     64        (escape) = parse_escape(lex,EOF_mask)
     65
     66        bitutil.print_aligned_streams([('Input Data', u8data),
     67                              ('lex.RSolidus', bitutil.bitstream2string(lex.RSolidus, lgth)),   
     68                              ('escape', bitutil.bitstream2string(escape, lgth)),       
     69                              ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1))])
     70        return
     71
     72def parallel_prefix_parity(strm,lgth):
     73        r"""
     74        Translate to library function.
     75       
     76        x y  x XOR y
     77        ------------
     78        0 0   0
     79        0 1   1
     80        1 0   1
     81        0 0   0
     82
     83        Let n = length(bitstream).
     84
     85        Define Pk,i as the parity of the bit range [k-(k+2^i),k] for bit positions n >= k >= 1.
     86       
     87        Base Case: Pk,0 = bitstream at position k, for all k, n >= k >= 0.
     88        Inductive Step: Pk,i+1 = (Pk,i << 2^i) XOR Pk,i.
     89       
     90        Pk,ceil(log(n) denotes the parity of the bit position k, n >= k >= 0.
     91       
     92        bitstream[k] = 1 --> odd parity
     93        bitstream[k] = 0 --> even parity
     94        """
     95        t1 = strm
     96        for i in range(0,int(math.ceil(math.log(lgth,2)))):
     97                t2 = t1 ^ (t1 << pow(2,i))
     98                t1 = t2
     99        return t2 
     100
     101def demo_parallel_prefix_parity(u8data):
     102        r"""
     103        >>> demo_parallel_prefix_parity('[data] [data][data] [data] [data')
     104        Input Data        : [data] [data][data] [data] [data
     105        lex.LSquareBracket: 1______1_____1______1______1____
     106        lex.RSquareBracket: _____1______1_____1______1______
     107        parity            : 11111__11111_11111__11111__11111
     108        EOF_Mask          : 11111111111111111111111111111111_
     109        <BLANKLINE>
     110        """
     111        global lgth
     112        lgth = len(u8data)
     113
     114        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
     115        (u8, lex, ctrl) = byteclass.classify_bytes(bit)
     116        brackets = (lex.LSquareBracket | lex.RSquareBracket)
     117        (parity) = parallel_prefix_parity(brackets,lgth)
     118
     119        bitutil.print_aligned_streams([('Input Data', u8data),
     120                              ('lex.LSquareBracket', bitutil.bitstream2string(lex.LSquareBracket, lgth)),
     121                              ('lex.RSquareBracket', bitutil.bitstream2string(lex.RSquareBracket, lgth)),                             
     122                              ('parity', bitutil.bitstream2string(parity, lgth)),       
     123                              ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1))])
     124        return
     125
    32126
    33127def validate_number(lex, EOF_mask):
     
    92186        return Errors
    93187
    94 
    95188def demo_validate_number(u8data):
    96189        r"""   
    97         For example, 00 is not reported as an error case, but -- is reported as an error case.
    98 
    99190        RFC 4627 - JavaScript Object Notation (JSON) 
    100191        RFC 5234 - Augmented BNF for Syntax Specifications: ABNF
     
    171262                              ('Errors', bitutil.bitstream2string(Errors, lgth))])
    172263
    173 def simd_const_4(hexdigit,EOF_mask):
    174         r"""
    175         IDISA library function.
    176         """
    177         lgth = bitutil.count_leading_zeroes(~EOF_mask)/4
    178         return int(hexdigit*(lgth+1),16)&EOF_mask
    179        
    180 def parse_escape(lex, EOF_mask):
    181         odd = simd_const_4('a',EOF_mask)
    182         even = simd_const_4('5',EOF_mask)
    183        
    184         start = lex.RSolidus &~ bitutil.Advance(lex.RSolidus)
    185        
    186         even_start = start & even
    187         even_final = (even_start + lex.RSolidus) & ~lex.RSolidus
    188         even_escape = even_final & odd
    189        
    190         odd_start = start & odd
    191         odd_final = (odd_start + lex.RSolidus) & ~lex.RSolidus
    192         odd_escape = (odd_final & even)
    193        
    194         escape = (even_escape | odd_escape)
    195        
    196         return escape
    197        
    198 def demo_parse_escape(u8data):
    199         global lgth
    200         lgth = len(u8data)
    201 
    202         (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    203         (u8, lex, ctrl) = byteclass.classify_bytes(bit)
    204         (escape) = parse_escape(lex,EOF_mask)
    205 
     264def validate_string(lex,escape,lgth):
     265        r"""
     266        RFC 4627 - JavaScript Object Notation (JSON) 
     267
     268        string = quotation-mark *char quotation-mark
     269        char = unescaped /
     270              escape (
     271                  %x22 /          ; "    quotation mark  U+0022
     272                  %x5C /          ; \    reverse solidus U+005C
     273                  %x2F /          ; /    solidus         U+002F
     274                  %x62 /          ; b    backspace       U+0008
     275                  %x66 /          ; f    form feed       U+000C
     276                  %x6E /          ; n    line feed       U+000A
     277                  %x72 /          ; r    carriage return U+000D
     278                  %x74 /          ; t    tab             U+0009
     279                  %x75 4HEXDIG )  ; uXXXX                U+XXXX
     280
     281        escape = %x5C              ; \
     282
     283        quotation-mark = %x22      ; "
     284
     285        unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
     286        """
     287
     288        return
     289
     290def demo_validate_string(u8data):
     291
     292        global lgth
     293        lgth = len(u8data)
     294
     295        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
     296        (u8, lex, ctrl) = byteclass.classify_bytes(bit)
     297        escape = parse_escape(lex, EOF_mask)
     298       
     299        # Mark String starts "
     300        unescaped_quotation_marks = (lex.DQuote &~ escape)
     301       
     302        # Mask String interiors
     303        parity_mask = parallel_prefix_parity(unescaped_quotation_marks, lgth)
     304        string_mask = parity_mask & bitutil.Advance(parity_mask)
     305       
     306       
     307       
     308        errors = validate_string(lex,escape,lgth)
     309       
     310        errors = 1
     311       
    206312        bitutil.print_aligned_streams([('Input Data', u8data),
    207                               ('lex.RSolidus', bitutil.bitstream2string(lex.RSolidus, lgth)),   
    208                               ('escape', bitutil.bitstream2string(escape, lgth)),       
    209                               ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1))])
    210         return
    211 
    212 def parallel_prefix_parity(strm,lgth):
    213         r"""
    214         Translate to library function.
    215        
    216         x y  x XOR y
    217         ------------
    218         0 0   0
    219         0 1   1
    220         1 0   1
    221         0 0   0
    222 
    223         Let n = length(bitstream).
    224 
    225         Define Pk,i as the parity of the bit range [k-(k+2^i),k] for bit positions n >= k >= 1.
    226        
    227         Base Case: Pk,0 = bitstream at position k, for all k, n >= k >= 0.
    228         Inductive Step: Pk,i+1 = (Pk,i << 2^i) XOR Pk,i.
    229        
    230         Pk,ceil(log(n) denotes the parity of the bit position k, n >= k >= 0.
    231        
    232         bitstream[k] = 1 --> odd parity
    233         bitstream[k] = 0 --> even parity
    234         """
    235         t1 = strm
    236         for i in range(0,int(math.ceil(math.log(lgth,2)))):
    237                 t2 = t1 ^ (t1 << pow(2,i))
    238                 t1 = t2
    239         return t2 
    240 
    241 def demo_parallel_prefix_parity(u8data):
    242         r"""
    243         >>> demo_parallel_prefix_parity('[data] [data][data] [data] [data')
    244         Input Data        : [data] [data][data] [data] [data
    245         lex.LSquareBracket: 1______1_____1______1______1____
    246         lex.RSquareBracket: _____1______1_____1______1______
    247         parity            : 11111__11111_11111__11111__11111
    248         EOF_Mask          : 11111111111111111111111111111111_
    249         <BLANKLINE>
    250         """
    251         global lgth
    252         lgth = len(u8data)
    253 
    254         (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    255         (u8, lex, ctrl) = byteclass.classify_bytes(bit)
    256         brackets = (lex.LSquareBracket | lex.RSquareBracket)
    257         (parity) = parallel_prefix_parity(brackets,lgth)
    258 
    259         bitutil.print_aligned_streams([('Input Data', u8data),
    260                               ('lex.LSquareBracket', bitutil.bitstream2string(lex.LSquareBracket, lgth)),
    261                               ('lex.RSquareBracket', bitutil.bitstream2string(lex.RSquareBracket, lgth)),                             
    262                               ('parity', bitutil.bitstream2string(parity, lgth)),       
    263                               ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1))])
     313                              ('escape', bitutil.bitstream2string(escape, lgth)),
     314                              ('DQuote', bitutil.bitstream2string(lex.DQuote, lgth)),
     315                              ('unescaped_quotation_marks', bitutil.bitstream2string(unescaped_quotation_marks, lgth)),
     316                              ('string_mask', bitutil.bitstream2string(string_mask, lgth)),                           
     317                              ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1)),
     318                              ('errors', bitutil.bitstream2string(errors, lgth))])     
     319                             
    264320        return
    265321
     
    268324        # Transpose to parallel bit streams and prepare an EOF mask.
    269325        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    270 
     326       
    271327        # Classify bytes for UTF-8 processing, whitespace, control and JSON lexical analysis.
    272         (u8, control, lex) = byteclass.classify_bytes(bit)
    273 
     328        (u8, lex, ctrl) = byteclass.classify_bytes(bit)
     329       
    274330        # Validate UTF-8 multibyte sequences and determine the UTF-8 scope streams.
    275331        u8 = u8u16.validate_utf8(u8) 
    276  
     332       
     333        # Mark escape characters
     334        escape = parse_escape(lex, EOF_mask)
     335       
     336#       bitutil.print_aligned_streams([('Input Data', u8data),
     337#                             ('escape', bitutil.bitstream2string(escape, lgth)),
     338#                             ('DQuote', bitutil.bitstream2string(lex.DQuote, lgth)),
     339#                             ('EOF_Mask', bitutil.bitstream2string(EOF_mask, lgth+1))])       
     340       
     341        # Mark unescaped "
     342       
     343
    277344        return
    278345 
     
    295362
    296363        u8data = bitutil.readfile(sys.argv[1])
    297 #       demo_validate_number(u8data)
    298364#       demo_parse_escape(u8data)
    299365#       demo_parallel_prefix_parity(u8data)
     366#       demo_validate_number(u8data)
     367        demo_validate_string(u8data)
    300368#       demo_parse_json(u8data)
Note: See TracChangeset for help on using the changeset viewer.