Changeset 915


Ignore:
Timestamp:
Feb 13, 2011, 6:15:21 PM (8 years ago)
Author:
ksherdy
Message:

Modularize charset compiler and character set definitions.

Location:
proto/charsetcompiler
Files:
2 added
2 edited

Legend:

Unmodified
Added
Removed
  • proto/charsetcompiler/charset_compiler.py

    r854 r915  
    3030#  3. Code Generator Objects
    3131#
     32import sys
    3233import re, binascii, string
    3334
    34 #
    35 #  Character sets are defined as lists of items that
    36 #  are either individual characters or ranges of contiguous
    37 #  characters.
    38 #
    39 class CharSetDef:
    40     """Definitions of character sets.   Examples:
    41     CharSetDef('alpha_', ['a-z', 'A-Z', '_'])
    42     CharDef('semicolon', ';') (equiv. to CharSetDef('semicolon', [';']))
    43     """
    44     def __init__(self, name, items, invert = False):
    45         self.name = name
    46         self.items = items
    47         self.complemented = invert
    48     def show(self):
    49         if self.complemented:
    50             return "CharSetDef(%s, %s, True)" % (self.name, self.items)
    51         else: return "CharSetDef(%s, %s)" % (self.name, self.items)
    52 
    53        
    54 class CharDef(CharSetDef):
    55     def __init__(self, name, char, invert = False):
    56         self.name = name
    57         self.items = [char]
    58         self.complemented = invert
    59     def show(self):
    60         if self.complemented:
    61             return "CharDef(%s, '\\%X', True)" % (self.name, ord(self.items[0]))
    62         else: return "CharDef(%s, '\\%X')" % (self.name, ord(self.items[0]))
    63 
    64 
    65 #
    66 # UTF-8 bytes occurring in the additional XML 1.1 line break
    67 # characters NEL and LS.
    68 
    69 UTF8_XML11_WS_bytes = [CharDef('NEL1', chr(0xC2)),
    70                         CharDef('NEL2', chr(0x85)),
    71                         CharDef('LS1', chr(0xE2)),
    72                         CharDef('LS2', chr(0x80)),
    73                         CharDef('LS3', chr(0xA8))]
    74            
    75 DefinitionSet = {}
    76 
    77 
    78 
    79 DefinitionSet['WS_Control_10'] = [CharSetDef('control.x00_x1F', ['\x00-\x1F']),
    80                                   CharDef('control.CR', '\x0D'),
    81                                   CharDef('control.LF', '\x0A'),
    82                                   CharDef('control.HT', '\x09'),
    83                                   CharDef('control.SP', ' '),
    84                                   CharSetDef('lex.WS', ['\x0D', '\x0A', '\x09', ' '])]
    85 
    86 DefinitionSet['WS_Control_10_EBCDIC'] = [CharSetDef('Control', ['\x00-\x03', '\x37',
    87                                                                 '\x2d-\x2f', '\x16',
    88                                                                 '\x0b-\x13', '\x3c-\x3d',
    89                                                                 '\x32', '\x26-\x27',
    90                                                                 '\x18-\x19', '\x3f',
    91                                                                 '\x1c-\x1f']),
    92                                          CharDef('CR', '\x0D'),
    93                                          CharDef('LF', '\x25'),
    94                                          CharDef('HT', '\x05'),
    95                                          CharDef('SP', '\x40')]
    96 
    97 DefinitionSet['WS_Control_11_EBCDIC'] = [CharSetDef('Control', ['\x00-\x3f']),
    98                                          CharDef('CR', '\x0D'),
    99                                          CharDef('LF', '\x25'),
    100                                          CharDef('HT', '\x05'),
    101                                          CharDef('SP', '\x40'),
    102                                          CharDef('NEL', '\x15')]
    103 
    104 
    105 DefinitionSet['WS_Control_11_ISO8859'] = [CharSetDef('Control', ['\x00-\x1F', '\x7F', '\x80-\x9F']),
    106                                           CharDef('CR', '\x0D'),
    107                                           CharDef('LF', '\x0A'),
    108                                           CharDef('HT', '\x09'),
    109                                           CharDef('SP', ' '),
    110                                           CharDef('NEL', '\x85')]
    111 
    112 DefinitionSet['Markup'] = [CharDef('RefStart', '&'),
    113                            CharDef('Semicolon', ';'),
    114                            CharDef('LAngle', '<'),
    115                            CharDef('RAngle', '>'),
    116                            CharDef('RBracket', ']'),
    117                            CharDef('Hyphen', '-'),
    118                            CharDef('QMark', '?'),
    119                            CharDef('Equals', "="),
    120                            CharDef('SQuote', "'"),
    121                            CharDef('DQuote', '"'),
    122                            CharDef('Slash', '/')
    123                            ]
    124 
    125 DefinitionSet['Digit_and_Hex'] = [CharSetDef('Digit', ['0-9']),
    126                                   CharSetDef('Hex', ['0-9', 'A-F', 'a-f'])]
    127 
    128 DefinitionSet['Markup2'] = DefinitionSet['Markup'] + DefinitionSet['Digit_and_Hex']
    129 
    130 DefinitionSet['LexicalItems'] = [CharSetDef('MarkupStart', ['<', '&']),
    131                                  CharDef('RAngle', '>'),
    132                                  CharDef('RBracket', ']'),
    133                                  CharDef('Hyphen', '-'),
    134                                  CharDef('QMark', '?'),
    135                                  CharSetDef('Quote', ['"', "'", '<', '&']),
    136                                  CharSetDef('NameFollow', [';', '=', '/', '>', '?', ')', '[', '|', '?', '*', '+', ','])
    137                                  ]
    138 DefinitionSet['LexicalItems2'] = [CharSetDef('MarkupStart', ['<', '&']),
    139                                  CharDef('RAngle', '>'),
    140                                  CharDef('RBracket', ']'),
    141                                  CharDef('Hyphen', '-'),
    142                                  CharDef('QMark', '?'),
    143                                  CharSetDef('Quote', ['"', "'", '<', '&']),
    144                                  CharSetDef('NameFollow', [' -,', '/', ';-?', '[-^', '{-~'])
    145                                  ]
    146 
    147 
    148 
    149 DefinitionSet['Digit_and_Hex'] = [CharSetDef('lex.Digit', ['0-9']),
    150                                   CharSetDef('lex.Hex', ['0-9', 'A-F', 'a-f'])]
    151                                  
    152 DefinitionSet['LexicalItems_with_Digit'] = DefinitionSet['LexicalItems2'] + DefinitionSet['Digit_and_Hex']
    153 
    154 DefinitionSet['LI_with_MarkupPass'] = DefinitionSet['LexicalItems_with_Digit'] + [CharSetDef('AmpHashSlash', ['&', '#', '/'])]
    155 
    156 #
    157 # Byte classifications in UTF-8 validation.
    158 DefinitionSet['UTF8'] =         [
    159                                 CharSetDef('u8.unibyte', ['\x00-\x7F']),
    160                                 CharSetDef('u8.prefix', ['\xC0-\xFF']),
    161                                 CharSetDef('u8.prefix2', ['\xC0-\xDF']),
    162                                 CharSetDef('u8.prefix3', ['\xE0-\xEF']),
    163                                 CharSetDef('u8.prefix4', ['\xF0-\xFF']),
    164                                 CharSetDef('u8.suffix', ['\x80-\xBF']),
    165                                 CharSetDef('u8.badprefix', ['\xC0-\xC1', '\xF5-\xFF']),
    166                                 CharDef('u8.xE0', '\xE0'),
    167                                 CharDef('u8.xED', '\xED'),
    168                                 CharDef('u8.xF0', '\xF0'),
    169                                 CharDef('u8.xF4', '\xF4'),
    170                                 CharSetDef('u8.xA0_xBF', ['\xA0-\xBF']),
    171                                 CharSetDef('u8.x80_x9F', ['\x80-\x9F']),
    172                                 CharSetDef('u8.x90_xBF', ['\x90-\xBF']),
    173                                 CharSetDef('u8.x80_x8F', ['\x80-\x8F']) 
    174                                 ]
    175 
    176 DefinitionSet['JSON_Control'] = [
    177                                 #Control characters
    178                                 CharSetDef('Ctrl.x00_x1F', ['\x00-\x1F']),
    179                                 CharDef('Ctrl.CR', '\x0D'),
    180                                 CharDef('Ctrl.LF', '\x0A'),
    181                                 CharDef('Ctrl.HT', '\x09'),
    182                                 CharDef('Ctrl.SP', ' '),
    183                                 ]
    184 
    185 DefinitionSet['JSON_Lexical'] = [
    186                                 # Object
    187                                 CharDef('Lex.LCurlyBrace','{'),
    188                                 CharDef('Lex.Colon',':'),
    189                                 CharDef('Lex.Comma',','),
    190                                 CharDef('Lex.RCurlyBrace','}'),
    191                                
    192                                 # Array
    193                                 CharDef('Lex.LSquareBracket','['),
    194                                 CharDef('Lex.RSquareBracket',']'),
    195                                
    196                                 # Number
    197                                 CharDef('Lex.Minus', '-'),
    198                                 CharDef('Lex.Zero', '0'),
    199                                 CharSetDef('Lex.Digit1_9', ['1-9']),
    200                                 CharSetDef('Lex.Digit0_9', ['0-9']),
    201                                 CharDef('Lex.DecimalPoint', '.'),
    202                                 CharSetDef('Lex.Ee', ['E','e']),
    203                                 CharSetDef('Lex.PlusMinus', ['+','-']),
    204                                 CharSetDef('Lex.Number',['-','0-9','.','E','e','+','-']),
    205                                
    206                                 # String
    207                                 CharDef('Lex.DQuote','\"'),
    208                                 CharDef('Lex.RSolidus','\\'),
    209                                 #CharDef('Lex.Solidus','/'),
    210                                 #CharDef('Lex.b','b'),
    211                                 #CharDef('Lex.f','f'),
    212                                 #CharDef('Lex.n','n'),
    213                                 #CharDef('Lex.r','r'),
    214                                 #CharDef('Lex.t','t'),
    215                                 CharDef('Lex.u','u'),
    216                                 CharSetDef('Lex.Escape', ['\"','\\','/','b','f','n','r','t','u']),
    217                                 CharSetDef('Lex.HexDigit', ['0-9','a-f','A-F']),
    218                                                                
    219                                 # WS
    220                                 CharSetDef('Lex.WS', ['\x0D', '\x0A', '\x09', ' ']),
    221                                
    222                                 # true
    223                                 CharDef('Lex.t','t'),
    224                                 CharDef('Lex.r','r'),
    225                                 #CharDef('Lex.u','u'),
    226                                 CharDef('Lex.e','e'),
    227                                 CharSetDef('Lex.True', ['t','r','u','e']),
    228                                
    229                                 # false
    230                                 CharDef('Lex.f','f'),
    231                                 CharDef('Lex.a','a'),
    232                                 CharDef('Lex.l','l'),
    233                                 CharDef('Lex.s','s'),
    234                                 #CharDef('Lex.e','e'),
    235                                 CharSetDef('Lex.False', ['f','a','l','s','e']),
    236                                
    237                                 # null
    238                                 CharDef('Lex.n','n'),
    239                                 #CharDef('Lex.u','u'),
    240                                 #CharDef('Lex.l','l'),
    241                                 #CharDef('Lex.l','l')                           
    242                                 CharSetDef('Lex.Null', ['n','u','l'])
    243 ]
    244 
    245 
    246 DefinitionSet['JSON'] = DefinitionSet['UTF8'] + DefinitionSet['JSON_Control'] + DefinitionSet['JSON_Lexical']
    247 
    248 #
    249 # Following definitions for the parabix2 unbounded bitstream prototype
    250 #
    251 # First all the special characters in the XML delimiters.
    252 
    253 xml_marks =    [CharDef('lex.RefStart', '&'),
    254                 CharDef('lex.Semicolon', ';'),
    255                 CharDef('lex.LAngle', '<'),
    256                 CharDef('lex.RAngle', '>'),
    257                 CharDef('lex.LBracket', '['),
    258                 CharDef('lex.RBracket', ']'),
    259                 CharDef('lex.Exclam', '!'),
    260                 CharDef('lex.QMark', '?'),
    261                 CharDef('lex.Hyphen', '-'),
    262                 CharDef('lex.Equals', "="),
    263                 CharDef('lex.SQuote', "'"),
    264                 CharDef('lex.DQuote', '"'),
    265                 CharDef('lex.Slash', '/'),
    266                 CharDef('lex.Hash', '#'),
    267                 CharDef('lex.x', 'x'),
    268                 CharDef('lex.Colon', ':')
    269                 ]
    270 #
    271 # NameFollow: all characters that may legally follow an XML name, plus
    272 # any others that may not be used in names.
    273 # 1. All non-WS characters that may legally follow an XML name.
    274 namefollow = [CharSetDef('lex.NameFollow', [';', '=', '/', '>', '?', ')', '[', '|', '?', '*', '+', ','])]
    275 #
    276 # NameScan: all ASCII characters that may legally occur in a Name,
    277 # plus all UTF-8 prefix and suffix bytes.
    278 namescan = [CharSetDef('lex.NameScan', ['_', '-', '.', '0-:', 'A-Z', 'a-z', '\x80-\xFF'])]
    279 
    280 #
    281 namelex = [CharSetDef('lex.ASCII_name_start', ['_', ':', 'A-Z', 'a-z']),
    282            CharSetDef('lex.ASCII_name_char', ['_', '-', '.', '0-:', 'A-Z', 'a-z']),
    283            CharSetDef('lex.NameScan', ['_', '-', '.', '0-:', 'A-Z', 'a-z', '\x80-\xFF'])]
    284 
    285 #
    286 UTF8_BOM_bytes = [CharDef('u8.xEF', '\xEF'), CharDef('u8.xBF', '\xBF'), CharDef('u8.xBE', '\xBE')]
    287 
    288 DefinitionSet['parabix2'] = (xml_marks + namelex + DefinitionSet['WS_Control_10']
    289                              + DefinitionSet['Digit_and_Hex'] + DefinitionSet['UTF8'] + UTF8_BOM_bytes)
    290 
    291 DefinitionSet['CSV'] = [CharDef('BackSlash', '\\'),
    292                         CharDef('DQuote', '"'),
    293                         CharDef('SQuote', '\''),
    294                         CharDef('CR', '\x0D'),
    295                         CharDef('LF', '\x0A'),
    296                         CharDef('Comma', ','),
    297                         CharDef('HT', '\x09'),
    298                         CharDef('Period', '.')]
    299 
     35import charset_def
     36CharDef = charset_def.CharDef
     37CharSetDef = charset_def.CharSetDef
     38
     39import charsets
     40DefinitionSet = charsets.DefinitionSet
     41
     42import charset_input_parser
    30043
    30144#
     
    604347        return make_sel(make_bitv(8-N), lo_test, hi_test)
    605348
    606 
    607 
    608 
    609349BadCharSetItem = Exception()
    610350
     
    625365    if chardef.complemented: return make_not(e1)
    626366    else: return e1
    627 
    628 
    629367
    630368#
     
    655393        for stmt in self.generated_code: s += stmt
    656394        return s
    657 
    658 
    659395
    660396def expr2simd(genobj, expr):
     
    704440    return cgo.showcode()
    705441
    706 
    707 
    708442def expr2py(genobj, expr):
    709443    """Translate a Boolean expression into three-address python code
     
    835569    return CharSetDef(chardef.name, cdefs, chardef.complemented)
    836570
    837 import charset_input_parser
    838 def input_chardef(filename):
    839     """
    840     Returns a list of declared CharSet from the declarations in the input file
    841     """
    842     defs = []
    843     charset_declaration_list = charset_input_parser.processCharsetInput(filename)
    844    
    845     for charset_declaration in charset_declaration_list:
    846         defs.append(CharSetDef (charset_declaration[0], charset_declaration[1]))
    847 
    848     return defs
    849                                  
    850 import sys
    851571def main():
    852572    if len(sys.argv) == 2:
     
    854574        if sys.argv[1] not in DefinitionSet:
    855575            #define the characters in the list
    856             defs = input_chardef(sys.argv[1])
     576            defs = charset_input_parser.input_chardef(sys.argv[1])
     577                                               
    857578            #print chardeflist2simd(defs)
    858579            print chardeflist2py(defs)
  • proto/charsetcompiler/charset_input_parser.py

    r854 r915  
    55# of the form 'character class name = []' and produces (character class name, character class item list).
    66#
     7import charset_def
    78
    89debug = False
     
    126127            return ()
    127128
    128 
    129129def processCharsetInput(input_filename):
    130130        """
     
    165165                report_CharSetDef(charset_declaration_list)
    166166        return charset_declaration_list
     167
     168def input_chardef(filename):
     169    """
     170    Returns a list of declared CharSet from the declarations in the input file
     171    """
     172    defs = []
     173    charset_declaration_list = processCharsetInput(filename)
     174   
     175    for charset_declaration in charset_declaration_list:
     176        defs.append(charset_def.CharSetDef (charset_declaration[0], charset_declaration[1]))
     177
     178    return defs
     179
Note: See TracChangeset for help on using the changeset viewer.