Changeset 4514 for proto


Ignore:
Timestamp:
Feb 24, 2015, 7:18:31 PM (4 years ago)
Author:
cameron
Message:

Avoid generating some unused variables

Location:
proto/charsetcompiler
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/charsetcompiler/CC_compiler.py

    r4355 r4514  
    3030    def bit_var(self, n):
    3131
    32             if len(self.mEncoding.basis_pattern) == 1:
    33                 return self.mEncoding.basis_pattern[0] % n
    34            
    35             if self.mEncoding.name == UTF_encoding.UTF16.name:
    36                 if options.little_endian == True:
    37                     if n >= 8:
    38                         return self.mEncoding.basis_pattern[0] % (n - 8)
    39                     else:
    40                         return self.mEncoding.basis_pattern[1] % n
    41                 else:
    42                     if n <= 7:
    43                         return self.mEncoding.basis_pattern[0] % n
    44                     else:
    45                         return self.mEncoding.basis_pattern[1] % (n - 8)
    46 
    47             if self.mEncoding.name == UTF_encoding.UTF32.name:
    48                 if options.little_endian == True:
    49                     if n >= 21:
    50                         return "unused_bit%i" % (n - 21)
    51                     elif n < 21 and n >= 16:
    52                         return self.mEncoding.basis_pattern[0] % (n - 16)
    53                     elif n < 16 and n >= 8:
    54                         return self.mEncoding.basis_pattern[1] % (n - 8)
    55                     elif n < 8:
    56                         return self.mEncoding.basis_pattern[2] % n
    57                 else:
    58                     if n <= 10:
    59                         return "unused_bit%i" % n
    60                     elif n > 10 and n <= 15:
    61                         return self.mEncoding.basis_pattern[0] % (n - 8)
    62                     elif n > 15 and n <= 23:
    63                         return self.mEncoding.basis_pattern[1] % (n - 16)
    64                     elif n > 23:
    65                         return self.mEncoding.basis_pattern[2] % (n - 24)
    66 
    67     def make_bitv(self, n):             
    68             if self.little_endian == True:
    69                 return Var(self.bit_var(n))
    70             else:
    71                 return Var(self.bit_var((self.mEncoding.bits - 1) -n))
    72                
     32            if len(self.mEncoding.basis_pattern) == 1:
     33                return self.mEncoding.basis_pattern[0] % n
     34           
     35            if self.mEncoding.name == UTF_encoding.UTF16.name:
     36                if options.little_endian == True:
     37                    if n >= 8:
     38                        return self.mEncoding.basis_pattern[0] % (n - 8)
     39                    else:
     40                        return self.mEncoding.basis_pattern[1] % n
     41                else:
     42                    if n <= 7:
     43                        return self.mEncoding.basis_pattern[0] % n
     44                    else:
     45                        return self.mEncoding.basis_pattern[1] % (n - 8)
     46
     47            if self.mEncoding.name == UTF_encoding.UTF32.name:
     48                if options.little_endian == True:
     49                    if n >= 21:
     50                        return "unused_bit%i" % (n - 21)
     51                    elif n < 21 and n >= 16:
     52                        return self.mEncoding.basis_pattern[0] % (n - 16)
     53                    elif n < 16 and n >= 8:
     54                        return self.mEncoding.basis_pattern[1] % (n - 8)
     55                    elif n < 8:
     56                        return self.mEncoding.basis_pattern[2] % n
     57                else:
     58                    if n <= 10:
     59                        return "unused_bit%i" % n
     60                    elif n > 10 and n <= 15:
     61                        return self.mEncoding.basis_pattern[0] % (n - 8)
     62                    elif n > 15 and n <= 23:
     63                        return self.mEncoding.basis_pattern[1] % (n - 16)
     64                    elif n > 23:
     65                        return self.mEncoding.basis_pattern[2] % (n - 24)
     66
     67    def make_bitv(self, n):                 
     68            if self.little_endian == True:
     69                return Var(self.bit_var(n))
     70            else:
     71                return Var(self.bit_var((self.mEncoding.bits - 1) -n))
     72               
    7373    def bit_pattern_expr(self, pattern, selected_bits):
    74             if selected_bits == 0: return TrueLiteral()
    75             bit_terms = []
    76             bit_no = 0
    77             while selected_bits:
    78               test_bit = 1 << bit_no
    79               if selected_bits & test_bit:
    80                 if (pattern & test_bit) == 0:
    81                     bit_terms = [make_not(self.make_bitv(bit_no))] + bit_terms
    82                 else: bit_terms = [self.make_bitv(bit_no)] + bit_terms
    83               else: bit_terms = [TrueLiteral()] + bit_terms
    84               # Appending TrueLiteral() for nonselected bits is intended
    85               # to keep consistent grouping of variables in the next loop.
    86               selected_bits &= ~test_bit
    87               bit_no += 1
    88             while len(bit_terms) > 1:
    89                 new_terms = []
    90                 for i in range(0, len(bit_terms)/ 2):
    91                     new_terms.append(make_and(bit_terms[2*i], bit_terms[2*i+1]))
    92                 if len(bit_terms) % 2 == 1:
    93                     new_terms.append(bit_terms[-1])
    94                 bit_terms = new_terms      
    95             return bit_terms[0]
     74            if selected_bits == 0: return TrueLiteral()
     75            bit_terms = []
     76            bit_no = 0
     77            while selected_bits:
     78              test_bit = 1 << bit_no
     79              if selected_bits & test_bit:
     80                if (pattern & test_bit) == 0:
     81                    bit_terms = [make_not(self.make_bitv(bit_no))] + bit_terms
     82                else: bit_terms = [self.make_bitv(bit_no)] + bit_terms
     83              else: bit_terms = [TrueLiteral()] + bit_terms
     84              # Appending TrueLiteral() for nonselected bits is intended
     85              # to keep consistent grouping of variables in the next loop.
     86              selected_bits &= ~test_bit
     87              bit_no += 1
     88            while len(bit_terms) > 1:
     89                new_terms = []
     90                for i in range(0, len(bit_terms)/ 2):
     91                    new_terms.append(make_and(bit_terms[2*i], bit_terms[2*i+1]))
     92                if len(bit_terms) % 2 == 1:
     93                    new_terms.append(bit_terms[-1])
     94                bit_terms = new_terms           
     95            return bit_terms[0]
    9696   
    9797    def char_test_expr(self, chval):
    98             return self.bit_pattern_expr(chval, self.mEncoding.mask) 
     98            return self.bit_pattern_expr(chval, self.mEncoding.mask) 
    9999
    100100    def GE_Range(self, N, n):
    101             if N == 0: return TrueLiteral()
    102             elif N % 2 == 0 and (n >> (N - 2)) == 0:
    103                 return make_or(make_or(self.make_bitv(N-1), self.make_bitv(N-2)),
    104                                 self.GE_Range(N - 2, n))
    105             elif N % 2 == 0 and (n >> (N - 2)) == 3:   # >= 11xxxx
    106                 return make_and(make_and(self.make_bitv(N-1), self.make_bitv(N-2)),
    107                                 self.GE_Range(N - 2, n - (3 << (N-2))))
    108             elif N >= 1:
    109                 hi_bit = n & (1 << (N-1))
    110                 lo_bits = n - hi_bit
    111                 lo_range = self.GE_Range(N-1, lo_bits)
    112                 if hi_bit == 0:
    113                     # If the hi_bit of n is not set, then whenever the corresponding bit
    114                     # is set in the target, the target will certainly be >=.  Otherwise,
    115                     # the value of GE_range(N-1, lo_bits) is required.
    116                     return make_or(self.make_bitv(N-1), lo_range)
    117                 else:
    118                     # If the hi_bit of n is set, then the corresponding bit must be set
    119                     # in the target for >= and GE_range(N-1, lo_bits) must also be true.
    120                     return make_and(self.make_bitv(N-1), lo_range)
     101            if N == 0: return TrueLiteral()
     102            elif N % 2 == 0 and (n >> (N - 2)) == 0:
     103                return make_or(make_or(self.make_bitv(N-1), self.make_bitv(N-2)),
     104                                self.GE_Range(N - 2, n))
     105            elif N % 2 == 0 and (n >> (N - 2)) == 3:   # >= 11xxxx
     106                return make_and(make_and(self.make_bitv(N-1), self.make_bitv(N-2)),
     107                                self.GE_Range(N - 2, n - (3 << (N-2))))
     108            elif N >= 1:
     109                hi_bit = n & (1 << (N-1))
     110                lo_bits = n - hi_bit
     111                lo_range = self.GE_Range(N-1, lo_bits)
     112                if hi_bit == 0:
     113                    # If the hi_bit of n is not set, then whenever the corresponding bit
     114                    # is set in the target, the target will certainly be >=.  Otherwise,
     115                    # the value of GE_range(N-1, lo_bits) is required.
     116                    return make_or(self.make_bitv(N-1), lo_range)
     117                else:
     118                    # If the hi_bit of n is set, then the corresponding bit must be set
     119                    # in the target for >= and GE_range(N-1, lo_bits) must also be true.
     120                    return make_and(self.make_bitv(N-1), lo_range)
    121121
    122122    def LE_Range(self, N, n):
    123             # If an N-bit pattern is all ones, then it is always
    124             # true that any n-bit value is LE this pattern.
    125             # Handling this as a special case avoids an overflow
    126             # issue with n+1 requiring more than N bits.
    127             if n+1 == 2 ** N:
    128                 return TrueLiteral()
    129             else:
    130                 return make_not(self.GE_Range(N, n+1))
     123            # If an N-bit pattern is all ones, then it is always
     124            # true that any n-bit value is LE this pattern.
     125            # Handling this as a special case avoids an overflow
     126            # issue with n+1 requiring more than N bits.
     127            if n+1 == 2 ** N:
     128                return TrueLiteral()
     129            else:
     130                return make_not(self.GE_Range(N, n+1))
    131131
    132132    def Make_Range(self, n1, n2):  # require n2 >= n1
    133             diff_bits = n1 ^ n2
    134             diff_count = 0
    135             while diff_bits > 0:
    136                 diff_count += 1
    137                 diff_bits >>= 1
    138             if n2 < n1 or diff_count > self.mEncoding.bits: raise Exception("Bad range: (%x, %x)." % (n1, n2))
    139             mask = 2**(diff_count) - 1
    140             common = self.bit_pattern_expr(n1 & ~mask, self.mEncoding.mask^mask)   
    141             if diff_count == 0: return common
    142             mask = 2**(diff_count-1) - 1
    143             lo_test = self.GE_Range(diff_count-1, n1 & mask)
    144             hi_test = self.LE_Range(diff_count-1, n2 & mask)
    145             return make_and(common, make_sel(self.make_bitv(diff_count-1), hi_test, lo_test))
     133            diff_bits = n1 ^ n2
     134            diff_count = 0
     135            while diff_bits > 0:
     136                diff_count += 1
     137                diff_bits >>= 1
     138            if n2 < n1 or diff_count > self.mEncoding.bits: raise Exception("Bad range: (%x, %x)." % (n1, n2))
     139            mask = 2**(diff_count) - 1
     140            common = self.bit_pattern_expr(n1 & ~mask, self.mEncoding.mask^mask)   
     141            if diff_count == 0: return common
     142            mask = 2**(diff_count-1) - 1
     143            lo_test = self.GE_Range(diff_count-1, n1 & mask)
     144            hi_test = self.LE_Range(diff_count-1, n2 & mask)
     145            return make_and(common, make_sel(self.make_bitv(diff_count-1), hi_test, lo_test))
    146146
    147147
    148148    def char_or_range_expr(self, charset_item):
    149149            (lo, hi) = charset_item
    150             if lo == hi:
    151                 return self.char_test_expr(lo)
    152             else:
    153                 return self.Make_Range(lo, hi)
     150            if lo == hi:
     151                return self.char_test_expr(lo)
     152            else:
     153                return self.Make_Range(lo, hi)
    154154
    155155    def charset_expr(self, chardef):
    156             if chardef.items == []: return FalseLiteral()
    157             if len(chardef.items) > 2:
    158                 combine = True
    159                 #If all of the charset items are single codepoints
    160                 #such that X0 == Y0, X1 == Y1 etc.
    161                 for item in chardef.items:
    162                     if item[0] != item[1]:
    163                         combine = False
    164                         break
    165                 if combine == True:
    166                     #If charset items are all of the form X1 = X0 + 2.
    167                     for i in range(len(chardef.items) - 1):
    168                         curr_item = chardef.items[i]
    169                         next_item = chardef.items[i+1]
    170                         if curr_item[0] != next_item[0] - 2:
    171                             combine = False
    172                             break
    173                 if combine == True:
    174                     lo = chardef.items[0][0]
    175                     hi = chardef.items[-1][0]
     156            if chardef.items == []: return FalseLiteral()
     157            if len(chardef.items) > 2:
     158                combine = True
     159                #If all of the charset items are single codepoints
     160                #such that X0 == Y0, X1 == Y1 etc.
     161                for item in chardef.items:
     162                    if item[0] != item[1]:
     163                        combine = False
     164                        break
     165                if combine == True:
     166                    #If charset items are all of the form X1 = X0 + 2.
     167                    for i in range(len(chardef.items) - 1):
     168                        curr_item = chardef.items[i]
     169                        next_item = chardef.items[i+1]
     170                        if curr_item[0] != next_item[0] - 2:
     171                            combine = False
     172                            break
     173                if combine == True:
     174                    lo = chardef.items[0][0]
     175                    hi = chardef.items[-1][0]
    176176                    print "Combined odd/even range %x-%x" % (lo, hi)
    177177                    #
    178                     if lo & 1 == 1: return make_and(self.char_or_range_expr((lo&~1, hi)), self.make_bitv(0))
     178                    if lo & 1 == 1: return make_and(self.char_or_range_expr((lo&~1, hi)), self.make_bitv(0))
    179179                    else: return make_and(self.char_or_range_expr((lo, hi|1)), make_not(self.make_bitv(0)))
    180             e1 = self.char_or_range_expr(chardef.items[0])
    181             for i in range(1, len(chardef.items)):   
    182                 e1 = make_or(e1, self.char_or_range_expr(chardef.items[i]))
    183             if chardef.complemented: return make_not(e1)
    184             else: return e1
     180            e1 = self.char_or_range_expr(chardef.items[0])
     181            for i in range(1, len(chardef.items)):   
     182                e1 = make_or(e1, self.char_or_range_expr(chardef.items[i]))
     183            if chardef.complemented: return make_not(e1)
     184            else: return e1
    185185
    186186    def add_assignment(self, varname, expr_string):
    187         if self.common_expression_map.has_key(expr_string):
    188                 assigned = self.common_expression_map[expr_string]
    189                 if assigned == varname: return
    190         else:
     187        if self.common_expression_map.has_key(expr_string):
     188            assigned = self.common_expression_map[expr_string]
     189            if assigned == varname: return
     190        else:
    191191            self.common_expression_map[expr_string] = varname
    192192            assigned = expr_string   
     
    222222
    223223    def expr2py(self, expr):
    224             """Translate a Boolean expression into three-address python code.
    225             """
    226             if isinstance(expr, TrueLiteral): return '-1'
    227             elif isinstance(expr, FalseLiteral): return '0'
    228             elif isinstance(expr, Var):
     224            """Translate a Boolean expression into three-address python code.
     225            """
     226            if isinstance(expr, TrueLiteral): return '-1'
     227            elif isinstance(expr, FalseLiteral): return '0'
     228            elif isinstance(expr, Var):
    229229               # This is a hack.
    230230               self.common_expression_map[expr.varname] = expr.varname
    231231               return expr.varname
    232             elif isinstance(expr, Not):
    233                e = self.expr_string_to_variable(self.expr2py(expr.operand))
    234                return '(~%s)' % (e)
    235             elif isinstance(expr, Or):
    236                e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
    237                e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
    238                return '(%s | %s)' % (e1, e2)
    239             elif isinstance(expr, Xor):
    240                e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
    241                e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
    242                return '(%s ^ %s)' % (e1, e2)
    243             elif isinstance(expr, And):
    244                if isinstance(expr.operand1, Not):
    245                    e1 = self.expr_string_to_variable(self.expr2py(expr.operand1.operand))
    246                    e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
    247                    return '(%s &~ %s)' % (e2, e1)
    248                elif isinstance(expr.operand2, Not):
    249                    e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
    250                    e2 = self.expr_string_to_variable(self.expr2py(expr.operand2.operand))
    251                    return '(%s &~ %s)' % (e1, e2)
    252                else:
    253                    e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
    254                    e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
    255                    return '(%s & %s)' % (e1, e2)
    256             elif isinstance(expr, Sel):
    257                sel = self.expr_string_to_variable(self.expr2py(expr.sel))
    258                e1 = self.expr_string_to_variable(self.expr2py(expr.true_branch))
    259                e2 = self.expr_string_to_variable(self.expr2py(expr.false_branch))
    260                return '((%s & %s)|(~(%s) & %s))' %(sel, e1, sel, e2)
    261             elif isinstance(expr, Adv):
    262                e = self.expr_string_to_variable(self.expr2py(expr.operand))
     232            elif isinstance(expr, Not):
     233               e = self.expr_string_to_variable(self.expr2py(expr.operand))
     234               return '(~%s)' % (e)
     235            elif isinstance(expr, Or):
     236               e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
     237               e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
     238               return '(%s | %s)' % (e1, e2)
     239            elif isinstance(expr, Xor):
     240               e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
     241               e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
     242               return '(%s ^ %s)' % (e1, e2)
     243            elif isinstance(expr, And):
     244               if isinstance(expr.operand1, Not):
     245                   e1 = self.expr_string_to_variable(self.expr2py(expr.operand1.operand))
     246                   e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
     247                   return '(%s &~ %s)' % (e2, e1)
     248               elif isinstance(expr.operand2, Not):
     249                   e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
     250                   e2 = self.expr_string_to_variable(self.expr2py(expr.operand2.operand))
     251                   return '(%s &~ %s)' % (e1, e2)
     252               else:
     253                   e1 = self.expr_string_to_variable(self.expr2py(expr.operand1))
     254                   e2 = self.expr_string_to_variable(self.expr2py(expr.operand2))
     255                   return '(%s & %s)' % (e1, e2)
     256            elif isinstance(expr, Sel):
     257               sel = self.expr_string_to_variable(self.expr2py(expr.sel))
     258               e1 = self.expr_string_to_variable(self.expr2py(expr.true_branch))
     259               e2 = self.expr_string_to_variable(self.expr2py(expr.false_branch))
     260               return '((%s & %s)|(~(%s) & %s))' %(sel, e1, sel, e2)
     261            elif isinstance(expr, Adv):
     262               e = self.expr_string_to_variable(self.expr2py(expr.operand))
    263263               if expr.offset == 1: return 'Advance(%s)' % (e)
    264                else: return 'Advance(%s, %i)' % (e, expr.offset)
     264               else: return 'Advance(%s, %i)' % (e, expr.offset)
    265265            else: raise Exception("Bad expression: %s" % repr(expr))
    266266
    267267    def chardef2py(self, chardef):
    268             self.add_assignment(chardef.name, self.expr2py(self.charset_expr(chardef)))
     268            self.add_assignment(chardef.name, self.expr2py(self.charset_expr(chardef)))
    269269
    270270    def chardef_canonical(self, chardef):
    271             self.add_canonical_assignment(chardef.name, self.expr2py(self.charset_expr(chardef)))
     271            self.add_canonical_assignment(chardef.name, self.expr2py(self.charset_expr(chardef)))
    272272   
    273273    def chardeflist2py(self, chardeflist):
    274             for d in chardeflist:
    275                 self.chardef2py(d)
    276             return self.showcode()
    277 
    278 
     274            for d in chardeflist:
     275                self.chardef2py(d)
     276            return self.showcode()
     277
     278
  • proto/charsetcompiler/if_hierarchy.py

    r4424 r4514  
    307307    #
    308308    for rg in cpset:
    309             (lo, hi) = rg
    310             lbyte = utf8_byte(lo, byte_no)
    311             hbyte = utf8_byte(hi, byte_no)
    312             if lbyte != hbyte:
    313                 if not is_low_codepoint_after_byte(lo, byte_no):
    314                     lo1 = lo | ((1 << (6 * (u8len_lo - byte_no))) - 1)
    315                     #print "lo--lo1:  %x--%x (%i)" % (lo, lo1, byte_no)
    316                     utf8_sequence_generator([(lo, lo1)], byte_no, targetVar, cgo)
    317                     utf8_sequence_generator([(lo1+1, hi)], byte_no, targetVar, cgo)
    318                 elif not is_high_codepoint_after_byte(hi, byte_no):
    319                     hi1 = hi &~ ((1 << (6 * (u8len_lo - byte_no))) - 1)
    320                     #print "lo--hi1-1:  %x--%x (%i)" % (lo, hi1-1, byte_no)
    321                     utf8_sequence_generator([(lo, hi1-1)], byte_no, targetVar, cgo)
    322                     utf8_sequence_generator([(hi1, hi)], byte_no, targetVar, cgo)
    323                 else:
    324                     # we have a prefix group of type (a)
    325                     #print "lo--hi:  %x--%x (%i)" % (lo, hi, byte_no)
    326                     byteVar = "byte_range_%x_%x" % (lbyte, hbyte)
    327                     cgo.chardef_canonical(CanonicalCharSetDef(byteVar, [(lbyte, hbyte)]))
    328                     if byte_no > 1:
    329                            last_prefix = utf8_prefix_var(lo, byte_no - 1)
    330                            this_prefix = last_prefix + "_" + byteVar
    331                            cgo.add_canonical_assignment(this_prefix, cgo.expr2py(make_and(make_shift_forward(Var(last_prefix), 1), Var(byteVar))))
    332                     else: this_prefix = byteVar
    333                     suffixVar = "byte_range_%x_%x" % (0x80, 0xBF)
    334                     cgo.chardef_canonical(CanonicalCharSetDef(suffixVar, [(0x80, 0xBF)]))
    335                     last_prefix = this_prefix
    336                     while byte_no < utf8_length(lo):
    337                            byte_no += 1
    338                            this_prefix = last_prefix + "_sfx"
    339                            cgo.add_assignment(this_prefix, cgo.expr2py(make_and(make_shift_forward(Var(last_prefix), 1), Var(suffixVar))))
    340                            last_prefix = this_prefix
    341                     cgo.add_assignment(targetVar, cgo.expr2py(make_or(Var(targetVar), Var(last_prefix))))
    342             else:
    343                 # lobyte1 == hybyte1
    344                 byteVar = "byte_%x" % lbyte
    345                 cgo.chardef_canonical(CanonicalCharSetDef(byteVar, [(lbyte, lbyte)]))
    346                 if byte_no > 1:
    347                     last_prefix = utf8_prefix_var(lo, byte_no - 1)
    348                     this_prefix = utf8_prefix_var(lo, byte_no)
    349                     cgo.add_canonical_assignment(this_prefix, cgo.expr2py(make_and(make_shift_forward(Var(last_prefix), 1), Var(byteVar))))
    350                 if byte_no < utf8_length(lo): utf8_sequence_generator([rg], byte_no+1, targetVar, cgo)
     309        (lo, hi) = rg
     310        lbyte = utf8_byte(lo, byte_no)
     311        hbyte = utf8_byte(hi, byte_no)
     312        if lbyte != hbyte:
     313            if not is_low_codepoint_after_byte(lo, byte_no):
     314                lo1 = lo | ((1 << (6 * (u8len_lo - byte_no))) - 1)
     315                #print "lo--lo1:  %x--%x (%i)" % (lo, lo1, byte_no)
     316                utf8_sequence_generator([(lo, lo1)], byte_no, targetVar, cgo)
     317                utf8_sequence_generator([(lo1+1, hi)], byte_no, targetVar, cgo)
     318            elif not is_high_codepoint_after_byte(hi, byte_no):
     319                hi1 = hi &~ ((1 << (6 * (u8len_lo - byte_no))) - 1)
     320                #print "lo--hi1-1:  %x--%x (%i)" % (lo, hi1-1, byte_no)
     321                utf8_sequence_generator([(lo, hi1-1)], byte_no, targetVar, cgo)
     322                utf8_sequence_generator([(hi1, hi)], byte_no, targetVar, cgo)
     323            else:
     324                # we have a prefix group of type (a)
     325                #print "lo--hi:  %x--%x (%i)" % (lo, hi, byte_no)
     326                byteVar = "byte_range_%x_%x" % (lbyte, hbyte)
     327                cgo.chardef_canonical(CanonicalCharSetDef(byteVar, [(lbyte, hbyte)]))
     328                if byte_no > 1:
     329                       last_prefix = utf8_prefix_var(lo, byte_no - 1)
     330                       last_prefix_adv = last_prefix + "_adv"
     331                       this_prefix = last_prefix + "_" + byteVar
     332                       cgo.add_canonical_assignment(last_prefix_adv, cgo.expr2py(make_shift_forward(Var(last_prefix), 1)))
     333                       cgo.add_canonical_assignment(this_prefix, cgo.expr2py(make_and(Var(last_prefix_adv), Var(byteVar))))
     334                else: this_prefix = byteVar
     335                suffixVar = "byte_range_%x_%x" % (0x80, 0xBF)
     336                cgo.chardef_canonical(CanonicalCharSetDef(suffixVar, [(0x80, 0xBF)]))
     337                last_prefix = this_prefix
     338                while byte_no < utf8_length(lo):
     339                       byte_no += 1
     340                       last_prefix_adv = last_prefix + "_adv"
     341                       cgo.add_canonical_assignment(last_prefix_adv, cgo.expr2py(make_shift_forward(Var(last_prefix), 1)))
     342                       this_prefix = last_prefix + "_sfx"
     343                       cgo.add_assignment(this_prefix, cgo.expr2py(make_and(Var(last_prefix_adv), Var(suffixVar))))
     344                       last_prefix = this_prefix
     345                cgo.add_assignment(targetVar, cgo.expr2py(make_or(Var(targetVar), Var(last_prefix))))
     346        else:
     347            # lobyte1 == hybyte1
     348            byteVar = "byte_%x" % lbyte
     349            cgo.chardef_canonical(CanonicalCharSetDef(byteVar, [(lbyte, lbyte)]))
     350            if byte_no > 1:
     351                last_prefix = utf8_prefix_var(lo, byte_no - 1)
     352                last_prefix_adv = last_prefix + "_adv"
     353                cgo.add_canonical_assignment(last_prefix_adv, cgo.expr2py(make_shift_forward(Var(last_prefix), 1)))
     354                this_prefix = utf8_prefix_var(lo, byte_no)
     355                cgo.add_canonical_assignment(this_prefix, cgo.expr2py(make_and(Var(last_prefix_adv), Var(byteVar))))
     356            if byte_no < utf8_length(lo): utf8_sequence_generator([rg], byte_no+1, targetVar, cgo)
    351357
    352358
Note: See TracChangeset for help on using the changeset viewer.