[GRASS-SVN] r68348 - in grass/trunk/lib/python/ctypes: . ctypesgencore ctypesgencore/parser ctypesgencore/printer ctypesgencore/processor

svn_grass at osgeo.org svn_grass at osgeo.org
Mon May 2 09:06:25 PDT 2016


Author: zarch
Date: 2016-05-02 09:06:24 -0700 (Mon, 02 May 2016)
New Revision: 68348

Modified:
   grass/trunk/lib/python/ctypes/__init__.py
   grass/trunk/lib/python/ctypes/ctypesgen.py
   grass/trunk/lib/python/ctypes/ctypesgencore/__init__.py
   grass/trunk/lib/python/ctypes/ctypesgencore/ctypedescs.py
   grass/trunk/lib/python/ctypes/ctypesgencore/descriptions.py
   grass/trunk/lib/python/ctypes/ctypesgencore/expressions.py
   grass/trunk/lib/python/ctypes/ctypesgencore/libraryloader.py
   grass/trunk/lib/python/ctypes/ctypesgencore/messages.py
   grass/trunk/lib/python/ctypes/ctypesgencore/options.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/__init__.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/cdeclarations.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/cgrammar.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/cparser.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/ctypesparser.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/datacollectingparser.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/lex.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/lextab.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/parsetab.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/pplexer.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/preprocessor.py
   grass/trunk/lib/python/ctypes/ctypesgencore/parser/yacc.py
   grass/trunk/lib/python/ctypes/ctypesgencore/printer/__init__.py
   grass/trunk/lib/python/ctypes/ctypesgencore/printer/defaultheader.py
   grass/trunk/lib/python/ctypes/ctypesgencore/printer/preamble.py
   grass/trunk/lib/python/ctypes/ctypesgencore/printer/printer.py
   grass/trunk/lib/python/ctypes/ctypesgencore/printer/test.py
   grass/trunk/lib/python/ctypes/ctypesgencore/processor/__init__.py
   grass/trunk/lib/python/ctypes/ctypesgencore/processor/dependencies.py
   grass/trunk/lib/python/ctypes/ctypesgencore/processor/operations.py
   grass/trunk/lib/python/ctypes/ctypesgencore/processor/pipeline.py
   grass/trunk/lib/python/ctypes/fix.sed
   grass/trunk/lib/python/ctypes/loader.py
   grass/trunk/lib/python/ctypes/preamble.py
Log:
ctypes: apply pep8

Modified: grass/trunk/lib/python/ctypes/__init__.py
===================================================================
--- grass/trunk/lib/python/ctypes/__init__.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/__init__.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -16,4 +16,4 @@
     'stats',
     'vector',
     'vedit'
-    ]
+]

Modified: grass/trunk/lib/python/ctypes/ctypesgen.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgen.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgen.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 
+
 def find_names_in_modules(modules):
     names = set()
     for module in modules:
@@ -11,8 +12,13 @@
             names.union(dir(module))
     return names
 
-import optparse, sys
+import optparse
+import sys
 
+import ctypesgencore
+import ctypesgencore.messages as msgs
+
+
 def option_callback_W(option, opt, value, parser):
     # Options preceded by a "-Wl," are simply treated as though the "-Wl,"
     # is not there? I don't understand the purpose of this code...
@@ -26,6 +32,7 @@
     # Push the linker option onto the list for further parsing.
     parser.rargs.insert(0, value)
 
+
 def option_callback_libdir(option, opt, value, parser):
     # There are two sets of linker search paths: those for use at compile time
     # and those for use at runtime. Search paths specified with -L, -R, or
@@ -33,91 +40,89 @@
     parser.values.compile_libdirs.append(value)
     parser.values.runtime_libdirs.append(value)
 
-import ctypesgencore
-import ctypesgencore.messages as msgs
 
-if __name__=="__main__":
+if __name__ == "__main__":
     usage = 'usage: %prog [options] /path/to/header.h ...'
     op = optparse.OptionParser(usage=usage)
-    
+
     # Parameters
     op.add_option('-o', '--output', dest='output', metavar='FILE',
-        help='write wrapper to FILE')
+                  help='write wrapper to FILE')
     op.add_option('-l', '--library', dest='libraries', action='append',
-        default=[], metavar='LIBRARY', help='link to LIBRARY')
+                  default=[], metavar='LIBRARY', help='link to LIBRARY')
     op.add_option('', '--include', dest='other_headers', action='append',
-        default=[], metavar='HEADER',
-        help='include system header HEADER (e.g. stdio.h or stdlib.h)')
+                  default=[], metavar='HEADER',
+                  help='include system header HEADER (e.g. stdio.h or stdlib.h)')
     op.add_option('-m', '--module', '--link-module', action='append',
-        dest='modules', metavar='MODULE', default=[],
-        help='use symbols from Python module MODULE')
+                  dest='modules', metavar='MODULE', default=[],
+                  help='use symbols from Python module MODULE')
     op.add_option('-I', '--includedir', dest='include_search_paths',
-        action='append', default=[], metavar='INCLUDEDIR',
-        help='add INCLUDEDIR as a directory to search for headers')
+                  action='append', default=[], metavar='INCLUDEDIR',
+                  help='add INCLUDEDIR as a directory to search for headers')
     op.add_option('-W', action="callback", callback=option_callback_W,
-        metavar="l,OPTION", type="str",
-        help="where OPTION is -L, -R, or --rpath")
+                  metavar="l,OPTION", type="str",
+                  help="where OPTION is -L, -R, or --rpath")
     op.add_option("-L", "-R", "--rpath", "--libdir", action="callback",
-        callback=option_callback_libdir, metavar="LIBDIR", type="str",
-        help="Add LIBDIR to the search path (both compile-time and run-time)")
+                  callback=option_callback_libdir, metavar="LIBDIR", type="str",
+                  help="Add LIBDIR to the search path (both compile-time and run-time)")
     op.add_option('', "--compile-libdir", action="append",
-        dest="compile_libdirs", metavar="LIBDIR", default=[],
-        help="Add LIBDIR to the compile-time library search path.")
+                  dest="compile_libdirs", metavar="LIBDIR", default=[],
+                  help="Add LIBDIR to the compile-time library search path.")
     op.add_option('', "--runtime-libdir", action="append",
-        dest="runtime_libdirs", metavar="LIBDIR", default=[],
-        help="Add LIBDIR to the run-time library search path.")
-    
+                  dest="runtime_libdirs", metavar="LIBDIR", default=[],
+                  help="Add LIBDIR to the run-time library search path.")
+
     # Parser options
     op.add_option('', '--cpp', dest='cpp', default='gcc -E',
-        help='The command to invoke the c preprocessor, including any ' \
-             'necessary options (default: gcc -E)')
+                  help='The command to invoke the c preprocessor, including any '
+                  'necessary options (default: gcc -E)')
     op.add_option('', '--save-preprocessed-headers', metavar='FILENAME',
-        dest='save_preprocessed_headers', default=None,
-        help='Save the preprocessed headers to the specified FILENAME')
-    
+                  dest='save_preprocessed_headers', default=None,
+                  help='Save the preprocessed headers to the specified FILENAME')
+
     # Processor options
     op.add_option('-a', '--all-headers', action='store_true',
-        dest='all_headers', default=False,
-        help='include symbols from all headers, including system headers')
+                  dest='all_headers', default=False,
+                  help='include symbols from all headers, including system headers')
     op.add_option('', '--builtin-symbols', action='store_true',
-        dest='builtin_symbols', default=False,
-        help='include symbols automatically generated by the preprocessor')
+                  dest='builtin_symbols', default=False,
+                  help='include symbols automatically generated by the preprocessor')
     op.add_option('', '--no-macros', action='store_false', dest='include_macros',
-        default=True, help="Don't output macros.")
+                  default=True, help="Don't output macros.")
     op.add_option('-i', '--include-symbols', dest='include_symbols',
-        default=None, help='regular expression for symbols to always include')
+                  default=None, help='regular expression for symbols to always include')
     op.add_option('-x', '--exclude-symbols', dest='exclude_symbols',
-        default=None, help='regular expression for symbols to exclude')
-    
+                  default=None, help='regular expression for symbols to exclude')
+
     # Printer options
     op.add_option('', '--header-template', dest='header_template', default=None,
-        metavar='TEMPLATE',
-        help='Use TEMPLATE as the header template in the output file.')
+                  metavar='TEMPLATE',
+                  help='Use TEMPLATE as the header template in the output file.')
     op.add_option('', '--strip-build-path', dest='strip_build_path',
-        default=None, metavar='BUILD_PATH',
-        help='Strip build path from header paths in the wrapper file.')
+                  default=None, metavar='BUILD_PATH',
+                  help='Strip build path from header paths in the wrapper file.')
     op.add_option('', '--insert-file', dest='inserted_files', default=[],
-        action='append', metavar='FILENAME',
-        help='Add the contents of FILENAME to the end of the wrapper file.')
-    
+                  action='append', metavar='FILENAME',
+                  help='Add the contents of FILENAME to the end of the wrapper file.')
+
     # Error options
     op.add_option('', "--all-errors", action="store_true", default=False,
-        dest="show_all_errors", help="Display all warnings and errors even " \
-             "if they would not affect output.")
+                  dest="show_all_errors", help="Display all warnings and errors even "
+                  "if they would not affect output.")
     op.add_option('', "--show-long-errors", action="store_true", default=False,
-        dest="show_long_errors", help="Display long error messages " \
-            "instead of abbreviating error messages.")
+                  dest="show_long_errors", help="Display long error messages "
+                  "instead of abbreviating error messages.")
     op.add_option('', "--no-macro-warnings", action="store_false", default=True,
-        dest="show_macro_warnings", help="Do not print macro warnings.")
+                  dest="show_macro_warnings", help="Do not print macro warnings.")
 
     op.set_defaults(**ctypesgencore.options.default_values)
-    
+
     (options, args) = op.parse_args(list(sys.argv[1:]))
     options.headers = args
 
     # Figure out what names will be defined by imported Python modules
     options.other_known_names = find_names_in_modules(options.modules)
-    
+
     # Required parameters
     if len(args) < 1:
         msgs.error_message('No header files specified', cls='usage')
@@ -129,22 +134,22 @@
 
     if len(options.libraries) == 0:
         msgs.warning_message('No libraries specified', cls='usage')
-    
+
     # Step 1: Parse
-    descriptions=ctypesgencore.parser.parse(options.headers,options)
-    
+    descriptions = ctypesgencore.parser.parse(options.headers, options)
+
     # Step 2: Process
-    ctypesgencore.processor.process(descriptions,options)
-    
+    ctypesgencore.processor.process(descriptions, options)
+
     # Step 3: Print
-    ctypesgencore.printer.WrapperPrinter(options.output,options,descriptions)
-    
+    ctypesgencore.printer.WrapperPrinter(options.output, options, descriptions)
+
     msgs.status_message("Wrapping complete.")
-    
+
     # Correct what may be a common mistake
     if descriptions.all == []:
         if not options.all_headers:
-            msgs.warning_message("There wasn't anything of use in the " \
-                "specified header file(s). Perhaps you meant to run with " \
-                "--all-headers to include objects from included sub-headers? ",
-                cls = 'usage')
+            msgs.warning_message("There wasn't anything of use in the "
+                                 "specified header file(s). Perhaps you meant to run with "
+                                 "--all-headers to include objects from included sub-headers? ",
+                                 cls='usage')

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/__init__.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/__init__.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/__init__.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -43,9 +43,9 @@
 """
 
 
-__all__ = ["parser","processor","printer",
-           "descriptions","ctypedescs","expressions",
-           "messages","options"]
+__all__ = ["parser", "processor", "printer",
+           "descriptions", "ctypedescs", "expressions",
+           "messages", "options"]
 
 # Workhorse modules
 import parser

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/ctypedescs.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/ctypedescs.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/ctypedescs.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -24,68 +24,77 @@
 __docformat__ = 'restructuredtext'
 
 ctypes_type_map = {
-   # typename   signed  longs
-    ('void',    True,   0): 'None',
-    ('int',     True,   0): 'c_int',
-    ('int',     False,  0): 'c_uint',
-    ('int',     True,   1): 'c_long',
-    ('int',     False,  1): 'c_ulong',
-    ('int',     True,   2): 'c_longlong',
-    ('int',     False,  2): 'c_ulonglong',
-    ('char',    True,   0): 'c_char',
-    ('char',    False,  0): 'c_ubyte',
-    ('short',   True,   0): 'c_short',
-    ('short',   False,  0): 'c_ushort',
-    ('float',   True,   0): 'c_float',
-    ('double',  True,   0): 'c_double',
-    ('size_t',  True,   0): 'c_size_t',
-    ('int8_t',  True,   0): 'c_int8',
-    ('int16_t', True,   0): 'c_int16',
-    ('int32_t', True,   0): 'c_int32',
-    ('int64_t', True,   0): 'c_int64',
-    ('apr_int64_t',True,0): 'c_int64',
-    ('off64_t', True,   0): 'c_int64',
-    ('uint8_t', True,   0): 'c_uint8',
-    ('uint16_t',True,   0): 'c_uint16',
-    ('uint32_t',True,   0): 'c_uint32',
-    ('uint64_t',True,   0): 'c_uint64',
-    ('apr_uint64_t',True,0): 'c_uint64',
-    ('wchar_t', True,   0): 'c_wchar',
-    ('ptrdiff_t',True,  0): 'c_ptrdiff_t',  # Requires definition in preamble
-    ('ssize_t', True,   0): 'c_ptrdiff_t',  # Requires definition in preamble
-    ('va_list', True,   0): 'c_void_p',
+    # typename   signed  longs
+    ('void', True, 0): 'None',
+    ('int', True, 0): 'c_int',
+    ('int', False, 0): 'c_uint',
+    ('int', True, 1): 'c_long',
+    ('int', False, 1): 'c_ulong',
+    ('int', True, 2): 'c_longlong',
+    ('int', False, 2): 'c_ulonglong',
+    ('char', True, 0): 'c_char',
+    ('char', False, 0): 'c_ubyte',
+    ('short', True, 0): 'c_short',
+    ('short', False, 0): 'c_ushort',
+    ('float', True, 0): 'c_float',
+    ('double', True, 0): 'c_double',
+    ('size_t', True, 0): 'c_size_t',
+    ('int8_t', True, 0): 'c_int8',
+    ('int16_t', True, 0): 'c_int16',
+    ('int32_t', True, 0): 'c_int32',
+    ('int64_t', True, 0): 'c_int64',
+    ('apr_int64_t', True, 0): 'c_int64',
+    ('off64_t', True, 0): 'c_int64',
+    ('uint8_t', True, 0): 'c_uint8',
+    ('uint16_t', True, 0): 'c_uint16',
+    ('uint32_t', True, 0): 'c_uint32',
+    ('uint64_t', True, 0): 'c_uint64',
+    ('apr_uint64_t', True, 0): 'c_uint64',
+    ('wchar_t', True, 0): 'c_wchar',
+    ('ptrdiff_t', True, 0): 'c_ptrdiff_t',  # Requires definition in preamble
+    ('ssize_t', True, 0): 'c_ptrdiff_t',  # Requires definition in preamble
+    ('va_list', True, 0): 'c_void_p',
 }
 
 # This protocol is used for walking type trees.
+
+
 class CtypesTypeVisitor(object):
+
     def visit_struct(self, struct):
         pass
 
     def visit_enum(self, enum):
         pass
-    
+
     def visit_typedef(self, name):
         pass
-    
+
     def visit_error(self, error, cls):
         pass
-    
+
     def visit_identifier(self, identifier):
         # This one comes from inside ExpressionNodes. There may be
         # ExpressionNode objects in array count expressions.
         pass
 
+
 def visit_type_and_collect_info(ctype):
     class Visitor(CtypesTypeVisitor):
-        def visit_struct(self,struct):
+
+        def visit_struct(self, struct):
             structs.append(struct)
-        def visit_enum(self,enum):
+
+        def visit_enum(self, enum):
             enums.append(enum)
-        def visit_typedef(self,typedef):
+
+        def visit_typedef(self, typedef):
             typedefs.append(typedef)
-        def visit_error(self,error,cls):
-            errors.append((error,cls))
-        def visit_identifier(self,identifier):
+
+        def visit_error(self, error, cls):
+            errors.append((error, cls))
+
+        def visit_identifier(self, identifier):
             identifiers.append(identifier)
     structs = []
     enums = []
@@ -94,35 +103,41 @@
     identifiers = []
     v = Visitor()
     ctype.visit(v)
-    return structs,enums,typedefs,errors,identifiers
+    return structs, enums, typedefs, errors, identifiers
 
 # Remove one level of indirection from funtion pointer; needed for typedefs
 # and function parameters.
+
+
 def remove_function_pointer(t):
-    if type(t) == CtypesPointer and type(t.destination) == CtypesFunction:
+    if isinstance(t, CtypesPointer) and isinstance(t.destination, CtypesFunction):
         return t.destination
-    elif type(t) == CtypesPointer:
+    elif isinstance(t, CtypesPointer):
         t.destination = remove_function_pointer(t.destination)
         return t
     else:
         return t
 
+
 class CtypesType(object):
+
     def __init__(self):
-        self.errors=[]
-    
+        self.errors = []
+
     def __repr__(self):
         return "<Ctype \"%s\">" % self.py_string()
-    
-    def error(self,message,cls=None):
-        self.errors.append((message,cls))
-    
-    def visit(self,visitor):
-        for error,cls in self.errors:
-            visitor.visit_error(error,cls)
 
+    def error(self, message, cls=None):
+        self.errors.append((message, cls))
+
+    def visit(self, visitor):
+        for error, cls in self.errors:
+            visitor.visit_error(error, cls)
+
+
 class CtypesSimple(CtypesType):
     """Represents a builtin type, like "char" or "int"."""
+
     def __init__(self, name, signed, longs):
         CtypesType.__init__(self)
         self.name = name
@@ -130,80 +145,92 @@
         self.longs = longs
 
     def py_string(self):
-        return ctypes_type_map[(self.name,self.signed,self.longs)]
+        return ctypes_type_map[(self.name, self.signed, self.longs)]
 
+
 class CtypesSpecial(CtypesType):
-    def __init__(self,name):
+
+    def __init__(self, name):
         CtypesType.__init__(self)
         self.name = name
-    
+
     def py_string(self):
         return self.name
 
+
 class CtypesTypedef(CtypesType):
     """Represents a type defined by a typedef."""
+
     def __init__(self, name):
         CtypesType.__init__(self)
         self.name = name
-    
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         if not self.errors:
             visitor.visit_typedef(self.name)
-        CtypesType.visit(self,visitor)
-    
+        CtypesType.visit(self, visitor)
+
     def py_string(self):
         return self.name
 
+
 class CtypesBitfield(CtypesType):
+
     def __init__(self, base, bitfield):
         CtypesType.__init__(self)
         self.base = base
         self.bitfield = bitfield
-    
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         self.base.visit(visitor)
-        CtypesType.visit(self,visitor)
-    
+        CtypesType.visit(self, visitor)
+
     def py_string(self):
         return self.base.py_string()
 
+
 class CtypesPointer(CtypesType):
+
     def __init__(self, destination, qualifiers):
         CtypesType.__init__(self)
         self.destination = destination
         self.qualifiers = qualifiers
-    
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         if self.destination:
             self.destination.visit(visitor)
-        CtypesType.visit(self,visitor)
+        CtypesType.visit(self, visitor)
 
     def py_string(self):
         return 'POINTER(%s)' % self.destination.py_string()
 
+
 class CtypesArray(CtypesType):
+
     def __init__(self, base, count):
         CtypesType.__init__(self)
         self.base = base
         self.count = count
-    
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         self.base.visit(visitor)
         if self.count:
             self.count.visit(visitor)
-        CtypesType.visit(self,visitor)
-    
+        CtypesType.visit(self, visitor)
+
     def py_string(self):
         if self.count is None:
             return 'POINTER(%s)' % self.base.py_string()
-        if type(self.base) == CtypesArray:
+        if isinstance(self.base, CtypesArray):
             return '(%s) * %s' % (self.base.py_string(),
                                   self.count.py_string(False))
         else:
             return '%s * %s' % (self.base.py_string(),
                                 self.count.py_string(False))
 
+
 class CtypesFunction(CtypesType):
+
     def __init__(self, restype, parameters, variadic=False):
         CtypesType.__init__(self)
         self.restype = restype
@@ -212,8 +239,8 @@
         # when ctypes automagically returns it as an int.
         # Instead, convert to POINTER(c_void).  c_void is not a ctypes type,
         # you can make it any arbitrary type.
-        if type(self.restype) == CtypesPointer and \
-           type(self.restype.destination) == CtypesSimple and \
+        if isinstance(self.restype, CtypesPointer) and \
+           isinstance(self.restype.destination, CtypesSimple) and \
            self.restype.destination.name == 'None':
             self.restype = CtypesPointer(CtypesSpecial('c_void'), ())
 
@@ -223,55 +250,59 @@
 
         self.argtypes = [remove_function_pointer(p) for p in parameters]
         self.variadic = variadic
-    
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         self.restype.visit(visitor)
         for a in self.argtypes:
             a.visit(visitor)
-        CtypesType.visit(self,visitor)
+        CtypesType.visit(self, visitor)
 
     def py_string(self):
         return 'CFUNCTYPE(UNCHECKED(%s), %s)' % (self.restype.py_string(),
-            ', '.join([a.py_string() for a in self.argtypes]))
+                                                 ', '.join([a.py_string() for a in self.argtypes]))
 
 last_tagnum = 0
+
+
 def anonymous_struct_tag():
     global last_tagnum
     last_tagnum += 1
     return 'anon_%d' % last_tagnum
 
+
 class CtypesStruct(CtypesType):
+
     def __init__(self, tag, variety, members, src=None):
         CtypesType.__init__(self)
         self.tag = tag
-        self.variety = variety # "struct" or "union"
+        self.variety = variety  # "struct" or "union"
         self.members = members
-        
+
         if not self.tag:
             self.tag = anonymous_struct_tag()
             self.anonymous = True
         else:
             self.anonymous = False
-        
-        if self.members==None:
+
+        if self.members is None:
             self.opaque = True
         else:
             self.opaque = False
-        
-        self.src = src        
-    
+
+        self.src = src
+
     def get_required_types(self):
         types = CtypesType.get_required_types(self)
-        types.add((self.variety,self.tag))
+        types.add((self.variety, self.tag))
         return types
-    
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         visitor.visit_struct(self)
         if not self.opaque:
-            for name,ctype in self.members:
+            for name, ctype in self.members:
                 ctype.visit(visitor)
-        CtypesType.visit(self,visitor)
-    
+        CtypesType.visit(self, visitor)
+
     def get_subtypes(self):
         if self.opaque:
             return set()
@@ -279,36 +310,40 @@
             return set([m[1] for m in self.members])
 
     def py_string(self):
-        return "%s_%s" % (self.variety,self.tag)
+        return "%s_%s" % (self.variety, self.tag)
 
 last_tagnum = 0
+
+
 def anonymous_enum_tag():
     global last_tagnum
     last_tagnum += 1
     return 'anon_%d' % last_tagnum
 
+
 class CtypesEnum(CtypesType):
+
     def __init__(self, tag, enumerators, src=None):
         CtypesType.__init__(self)
         self.tag = tag
         self.enumerators = enumerators
-        
+
         if not self.tag:
             self.tag = anonymous_enum_tag()
             self.anonymous = True
         else:
             self.anonymous = False
-        
-        if self.enumerators==None:
+
+        if self.enumerators is None:
             self.opaque = True
         else:
             self.opaque = False
-        
+
         self.src = src
-        
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         visitor.visit_enum(self)
-        CtypesType.visit(self,visitor)
+        CtypesType.visit(self, visitor)
 
     def py_string(self):
         return 'enum_%s' % self.tag

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/descriptions.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/descriptions.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/descriptions.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -8,182 +8,224 @@
 lists of Description objects.
 """
 
+
 class DescriptionCollection(object):
     """Represents a collection of Descriptions."""
-    def __init__(self,constants,typedefs,structs,enums,functions,variables,
-                 macros,all,output_order):
-        self.constants=constants
-        self.typedefs=typedefs
-        self.structs=structs
-        self.enums=enums
-        self.functions=functions
-        self.variables=variables
-        self.macros=macros
-        self.all=all
-        self.output_order=output_order
 
+    def __init__(self, constants, typedefs, structs, enums, functions, variables,
+                 macros, all, output_order):
+        self.constants = constants
+        self.typedefs = typedefs
+        self.structs = structs
+        self.enums = enums
+        self.functions = functions
+        self.variables = variables
+        self.macros = macros
+        self.all = all
+        self.output_order = output_order
+
+
 class Description(object):
     """Represents a constant, typedef, struct, function, variable, enum,
     or macro description. Description is an abstract base class."""
-    def __init__(self,src=None):
-        self.src=src # A tuple of (filename, lineno)
-        
+
+    def __init__(self, src=None):
+        self.src = src  # A tuple of (filename, lineno)
+
         # If object will be included in output file. Values are "yes", "never",
         # and "if_needed".
-        self.include_rule="yes" 
-        
+        self.include_rule = "yes"
+
         # A word about requirements, and dependents:
         # If X requires Y, Y is in X.requirements.
         # If X is in Y.requirements, then Y is in X.dependents.
-        self.requirements=set()
-        self.dependents=set()
-        
+        self.requirements = set()
+        self.dependents = set()
+
         # If the processor module finds a fatal error that prevents a
         # a description from being output, then it appends a string describing
         # the problem to 'errors'. If it finds a nonfatal error, it appends a
         # string to 'warnings'. If the description would have been output, then
         # the errors and warnings are printed.
-        
+
         # If there is anything in 'errors' after processing is complete, the
         # description is not output.
-        
-        self.errors=[] 
-        self.warnings=[]
-    
-    def add_requirements(self,reqs):
+
+        self.errors = []
+        self.warnings = []
+
+    def add_requirements(self, reqs):
         self.requirements = self.requirements.union(reqs)
         for req in reqs:
             req.dependents.add(self)
-    
-    def error(self,msg,cls = None):
-        self.errors.append((msg,cls))
-    def warning(self,msg,cls = None):
-        self.warnings.append((msg,cls))
-    
+
+    def error(self, msg, cls=None):
+        self.errors.append((msg, cls))
+
+    def warning(self, msg, cls=None):
+        self.warnings.append((msg, cls))
+
     def __repr__(self):
         return "<Description: %s>" % self.casual_name()
-    
+
     def casual_name(self):
         """Return a name to show the user."""
+
     def py_name(self):
         """Return the name associated with this description in Python code."""
+
     def c_name(self):
         """Return the name associated with this description in C code."""
 
+
 class ConstantDescription(Description):
     """Simple class to contain information about a constant."""
-    def __init__(self,name,value,src=None):
-        Description.__init__(self,src)
+
+    def __init__(self, name, value, src=None):
+        Description.__init__(self, src)
         # Name of constant, a string
-        self.name=name 
+        self.name = name
         # Value of constant, as an ExpressionNode object
-        self.value=value 
+        self.value = value
+
     def casual_name(self):
-        return "Constant \"%s\""%self.name
+        return "Constant \"%s\"" % self.name
+
     def py_name(self):
         return self.name
+
     def c_name(self):
         return self.name
 
+
 class TypedefDescription(Description):
     """Simple container class for a type definition."""
-    def __init__(self,name,ctype,src=None):
-        Description.__init__(self,src)
-        self.name=name # Name, a string
-        self.ctype=ctype # The base type as a ctypedescs.CtypeType object
+
+    def __init__(self, name, ctype, src=None):
+        Description.__init__(self, src)
+        self.name = name  # Name, a string
+        self.ctype = ctype  # The base type as a ctypedescs.CtypeType object
+
     def casual_name(self):
-        return "Typedef \"%s\""%self.name
+        return "Typedef \"%s\"" % self.name
+
     def py_name(self):
         return self.name
+
     def c_name(self):
         return self.name
 
+
 class StructDescription(Description):
     """Simple container class for a structure or union definition."""
-    def __init__(self,tag,variety,members,opaque,ctype,src=None):
-        Description.__init__(self,src)
+
+    def __init__(self, tag, variety, members, opaque, ctype, src=None):
+        Description.__init__(self, src)
         # The name of the structure minus the "struct" or "union"
-        self.tag=tag 
+        self.tag = tag
         # A string "struct" or "union"
-        self.variety=variety 
+        self.variety = variety
         # A list of pairs of (name,ctype)
-        self.members=members 
+        self.members = members
         # True if struct body was not specified in header file
-        self.opaque=opaque 
+        self.opaque = opaque
         # The original CtypeStruct that created the struct
-        self.ctype=ctype 
+        self.ctype = ctype
+
     def casual_name(self):
-        return "%s \"%s\""%(self.variety.capitalize(),self.tag)
+        return "%s \"%s\"" % (self.variety.capitalize(), self.tag)
+
     def py_name(self):
-        return "%s_%s"%(self.variety,self.tag)
+        return "%s_%s" % (self.variety, self.tag)
+
     def c_name(self):
-        return "%s %s"%(self.variety,self.tag)
+        return "%s %s" % (self.variety, self.tag)
 
+
 class EnumDescription(Description):
     """Simple container class for an enum definition."""
-    def __init__(self,tag,members,ctype,src=None):
-        Description.__init__(self,src)
+
+    def __init__(self, tag, members, ctype, src=None):
+        Description.__init__(self, src)
         # The name of the enum, minus the "enum"
-        self.tag=tag 
+        self.tag = tag
         # A list of (name,value) pairs where value is a number
-        self.members=members 
+        self.members = members
         # The original CtypeEnum that created the enum
-        self.ctype=ctype 
+        self.ctype = ctype
+
     def casual_name(self):
-        return "Enum \"%s\""%self.tag
+        return "Enum \"%s\"" % self.tag
+
     def py_name(self):
-        return "enum_%s"%self.tag
+        return "enum_%s" % self.tag
+
     def c_name(self):
-        return "enum %s"%self.tag
+        return "enum %s" % self.tag
 
+
 class FunctionDescription(Description):
     """Simple container class for a C function."""
-    def __init__(self,name,restype,argtypes,variadic=False,src=None):
-        Description.__init__(self,src)
+
+    def __init__(self, name, restype, argtypes, variadic=False, src=None):
+        Description.__init__(self, src)
         # Name, a string
-        self.name=name 
+        self.name = name
         # Name according to C - stored in case description is renamed
-        self.cname=name 
+        self.cname = name
         # A ctype representing return type
-        self.restype=restype 
+        self.restype = restype
         # A list of ctypes representing the argument types
-        self.argtypes=argtypes 
+        self.argtypes = argtypes
         # Does this function accept a variable number of arguments?
-        self.variadic=variadic 
+        self.variadic = variadic
+
     def casual_name(self):
-        return "Function \"%s\""%self.name
+        return "Function \"%s\"" % self.name
+
     def py_name(self):
         return self.name
+
     def c_name(self):
         return self.cname
 
+
 class VariableDescription(Description):
     """Simple container class for a C variable declaration."""
-    def __init__(self,name,ctype,src=None):
-        Description.__init__(self,src)
+
+    def __init__(self, name, ctype, src=None):
+        Description.__init__(self, src)
         # Name, a string
-        self.name=name 
+        self.name = name
         # Name according to C - stored in case description is renamed
-        self.cname=name 
+        self.cname = name
         # The type of the variable
-        self.ctype=ctype 
+        self.ctype = ctype
+
     def casual_name(self):
-        return "Variable \"%s\""%self.name
+        return "Variable \"%s\"" % self.name
+
     def py_name(self):
         return self.name
+
     def c_name(self):
         return self.cname
 
+
 class MacroDescription(Description):
     """Simple container class for a C macro."""
-    def __init__(self,name,params,expr,src=None):
-        Description.__init__(self,src)
+
+    def __init__(self, name, params, expr, src=None):
+        Description.__init__(self, src)
         self.name = name
         self.params = params
-        self.expr = expr # ExpressionNode for the macro's body
+        self.expr = expr  # ExpressionNode for the macro's body
+
     def casual_name(self):
-        return "Macro \"%s\""%self.name
+        return "Macro \"%s\"" % self.name
+
     def py_name(self):
         return self.name
+
     def c_name(self):
-        return self.name
\ No newline at end of file
+        return self.name

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/expressions.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/expressions.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/expressions.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -23,9 +23,11 @@
 #
 # On the other hand, this would be a challenge to write.
 
+
 class EvaluationContext(object):
     '''Interface for evaluating expression nodes.
     '''
+
     def evaluate_identifier(self, name):
         warnings.warn('Attempt to evaluate identifier "%s" failed' % name)
         return 0
@@ -33,38 +35,42 @@
     def evaluate_sizeof(self, type):
         warnings.warn('Attempt to evaluate sizeof "%s" failed' % str(type))
         return 0
-    
+
     def evaluate_sizeof(self, object):
         warnings.warn('Attempt to evaluate sizeof object "%s" failed' % str(object))
         return 0
-    
+
     def evaluate_parameter(self, name):
         warnings.warn('Attempt to evaluate parameter "%s" failed' % name)
         return 0
 
+
 class ExpressionNode(object):
+
     def __init__(self):
         self.errors = []
-    
-    def error(self,message,cls = None):
-        self.errors.append((message,cls))
-    
+
+    def error(self, message, cls=None):
+        self.errors.append((message, cls))
+
     def __repr__(self):
         try:
             string = repr(self.py_string(True))
         except ValueError:
             string = "<error in expression node>"
         return "<ExpressionNode: %s>" % string
-    
-    def visit(self,visitor):
-        for error,cls in self.errors:
-            visitor.visit_error(error,cls)
 
+    def visit(self, visitor):
+        for error, cls in self.errors:
+            visitor.visit_error(error, cls)
+
+
 class ConstantExpressionNode(ExpressionNode):
+
     def __init__(self, value):
         ExpressionNode.__init__(self)
         self.value = value
-    
+
     def evaluate(self, context):
         return self.value
 
@@ -82,40 +88,46 @@
             return "float('-inf')"
         return repr(self.value)
 
+
 class IdentifierExpressionNode(ExpressionNode):
+
     def __init__(self, name):
         ExpressionNode.__init__(self)
         self.name = name
 
     def evaluate(self, context):
         return context.evaluate_identifier(self.name)
-    
+
     def visit(self, visitor):
         visitor.visit_identifier(self.name)
-        ExpressionNode.visit(self,visitor)
-    
+        ExpressionNode.visit(self, visitor)
+
     def py_string(self, can_be_ctype):
         # Errors will be thrown in generated code if identifier evaluates
         # to a ctypes object, and can_be_ctype is False.
         return self.name
 
+
 class ParameterExpressionNode(ExpressionNode):
+
     def __init__(self, name):
         ExpressionNode.__init__(self)
         self.name = name
-    
+
     def evaluate(self, context):
         return context.evaluate_parameter(self.name)
-    
+
     def visit(self, visitor):
-        ExpressionNode.visit(self,visitor)
-    
+        ExpressionNode.visit(self, visitor)
+
     def py_string(self, can_be_ctype):
         # Errors will be thrown in generated code if parameter is
         # a ctypes object, and can_be_ctype is False.
         return self.name
 
+
 class UnaryExpressionNode(ExpressionNode):
+
     def __init__(self, name, op, format, child_can_be_ctype, child):
         ExpressionNode.__init__(self)
         self.name = name
@@ -123,31 +135,33 @@
         self.format = format
         self.child_can_be_ctype = child_can_be_ctype
         self.child = child
-    
+
     def visit(self, visitor):
         self.child.visit(visitor)
-        ExpressionNode.visit(self,visitor)
-    
+        ExpressionNode.visit(self, visitor)
+
     def evaluate(self, context):
         if self.op:
             return self.op(self.child.evaluate(context))
         else:
-            raise ValueError,"The C operator \"%s\" can't be evaluated right " \
-                "now" % self.name
+            raise ValueError("The C operator \"%s\" can't be evaluated right "
+                             "now" % self.name)
 
     def py_string(self, can_be_ctype):
         return self.format % \
             self.child.py_string(self.child_can_be_ctype and can_be_ctype)
 
+
 class SizeOfExpressionNode(ExpressionNode):
+
     def __init__(self, child):
         ExpressionNode.__init__(self)
         self.child = child
-    
+
     def visit(self, visitor):
         self.child.visit(visitor)
-        ExpressionNode.visit(self,visitor)
-    
+        ExpressionNode.visit(self, visitor)
+
     def evaluate(self, context):
         if isinstance(self.child, CtypesType):
             return context.evaluate_sizeof(self.child)
@@ -160,7 +174,9 @@
         else:
             return 'sizeof(%s)' % self.child.py_string(True)
 
+
 class BinaryExpressionNode(ExpressionNode):
+
     def __init__(self, name, op, format, can_be_ctype, left, right):
         ExpressionNode.__init__(self)
         self.name = name
@@ -169,38 +185,40 @@
         self.can_be_ctype = can_be_ctype
         self.left = left
         self.right = right
-    
+
     def visit(self, visitor):
         self.left.visit(visitor)
         self.right.visit(visitor)
-        ExpressionNode.visit(self,visitor)
-    
+        ExpressionNode.visit(self, visitor)
+
     def evaluate(self, context):
         if self.op:
-           return self.op(self.left.evaluate(context), 
-                          self.right.evaluate(context))
+            return self.op(self.left.evaluate(context),
+                           self.right.evaluate(context))
         else:
-            raise ValueError,"The C operator \"%s\" can't be evaluated right " \
-                "now" % self.name
+            raise ValueError("The C operator \"%s\" can't be evaluated right "
+                             "now" % self.name)
 
     def py_string(self, can_be_ctype):
         return self.format % \
             (self.left.py_string(self.can_be_ctype[0] and can_be_ctype),
              self.right.py_string(self.can_be_ctype[0] and can_be_ctype))
 
+
 class ConditionalExpressionNode(ExpressionNode):
+
     def __init__(self, cond, yes, no):
         ExpressionNode.__init__(self)
         self.cond = cond
         self.yes = yes
         self.no = no
-    
+
     def visit(self, visitor):
         self.cond.visit(visitor)
         self.yes.visit(visitor)
         self.no.visit(visitor)
-        ExpressionNode.visit(self,visitor)
-    
+        ExpressionNode.visit(self, visitor)
+
     def evaluate(self, context):
         if self.cond.evaluate(context):
             return self.yes.evaluate(context)
@@ -213,100 +231,109 @@
              self.cond.py_string(True),
              self.no.py_string(can_be_ctype))
 
+
 class AttributeExpressionNode(ExpressionNode):
+
     def __init__(self, op, format, base, attribute):
         ExpressionNode.__init__(self)
         self.op = op
         self.format = format
         self.base = base
         self.attribute = attribute
-        
-        # Attribute access will raise parse errors if you don't do this. 
-        # Fortunately, the processor module does the same thing to 
+
+        # Attribute access will raise parse errors if you don't do this.
+        # Fortunately, the processor module does the same thing to
         # the struct member name.
         if self.attribute in keyword.kwlist:
-            self.attribute = "_"+self.attribute
-    
-    def visit(self,visitor):
+            self.attribute = "_" + self.attribute
+
+    def visit(self, visitor):
         self.base.visit(visitor)
-        ExpressionNode.visit(self,visitor)
-    
+        ExpressionNode.visit(self, visitor)
+
     def evaluate(self, context):
-        return self.op(self.base.evalute(context),self.attribute)
-    
+        return self.op(self.base.evalute(context), self.attribute)
+
     def py_string(self, can_be_ctype):
         if can_be_ctype:
             return self.format % (self.base.py_string(can_be_ctype),
                                   self.attribute)
         else:
-            return "(%s.value)" % (self.format % \
-                    (self.base.py_string(can_be_ctype), self.attribute))
+            return "(%s.value)" % (self.format %
+                                   (self.base.py_string(can_be_ctype), self.attribute))
 
+
 class CallExpressionNode(ExpressionNode):
-    def __init__(self,function,arguments):
+
+    def __init__(self, function, arguments):
         ExpressionNode.__init__(self)
         self.function = function
         self.arguments = arguments
-    
-    def visit(self,visitor):
+
+    def visit(self, visitor):
         self.function.visit(visitor)
         for arg in self.arguments:
             arg.visit(visitor)
-        ExpressionNode.visit(self,visitor)
-    
-    def evaluate(self,context):
+        ExpressionNode.visit(self, visitor)
+
+    def evaluate(self, context):
         arguments = [arg.evaluate(context) for arg in self.arguments]
         return self.function.evaluate(context)(*arguments)
-    
+
     def py_string(self, can_be_ctype):
         function = self.function.py_string(can_be_ctype)
         arguments = [x.py_string(can_be_ctype) for x in self.arguments]
         if can_be_ctype:
-            return '(%s (%s))' % (function,", ".join(arguments))
+            return '(%s (%s))' % (function, ", ".join(arguments))
         else:
-            return '((%s (%s)).value)' % (function,", ".join(arguments))
+            return '((%s (%s)).value)' % (function, ", ".join(arguments))
 
 # There seems not to be any reasonable way to translate C typecasts
 # into Python. Ctypesgen doesn't try, except for the special case of NULL.
+
+
 class TypeCastExpressionNode(ExpressionNode):
+
     def __init__(self, base, ctype):
         ExpressionNode.__init__(self)
         self.base = base
         self.ctype = ctype
         self.isnull = isinstance(ctype, CtypesPointer) and \
-                      isinstance(base, ConstantExpressionNode) and \
-                      base.value == 0
-    
-    def visit(self,visitor):
+            isinstance(base, ConstantExpressionNode) and \
+            base.value == 0
+
+    def visit(self, visitor):
         # No need to visit ctype because it isn't actually used
         self.base.visit(visitor)
-        ExpressionNode.visit(self,visitor)
-    
-    def evaluate(self,context):
+        ExpressionNode.visit(self, visitor)
+
+    def evaluate(self, context):
         if self.isnull:
             return None
         else:
             return self.base.evaluate(context)
-    
+
     def py_string(self, can_be_ctype):
         if self.isnull:
             return "None"
         else:
             return self.base.py_string(can_be_ctype)
 
+
 class UnsupportedExpressionNode(ExpressionNode):
-    def __init__(self,message):
+
+    def __init__(self, message):
         ExpressionNode.__init__(self)
         self.message = message
-        self.error(message,'unsupported-type')
-    
-    def evaluate(self,context):
-        raise ValueError, "Tried to evaluate an unsupported expression " \
-            "node: %s" % self.message
-    
+        self.error(message, 'unsupported-type')
+
+    def evaluate(self, context):
+        raise ValueError("Tried to evaluate an unsupported expression "
+                         "node: %s" % self.message)
+
     def __repr__(self):
         return "<UnsupportedExpressionNode>"
-    
+
     def py_string(self, can_be_ctype):
-        raise ValueError, "Called py_string() an unsupported expression " \
-            "node: %s" % self.message
+        raise ValueError("Called py_string() an unsupported expression "
+                         "node: %s" % self.message)

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/libraryloader.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/libraryloader.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/libraryloader.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -2,14 +2,14 @@
 # Copyright (c) 2008 David James
 # Copyright (c) 2006-2008 Alex Holkner
 # All rights reserved.
-# 
+#
 # Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions 
+# modification, are permitted provided that the following conditions
 # are met:
 #
 #  * Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
-#  * Redistributions in binary form must reproduce the above copyright 
+#  * Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in
 #    the documentation and/or other materials provided with the
 #    distribution.
@@ -32,31 +32,37 @@
 # POSSIBILITY OF SUCH DAMAGE.
 # ----------------------------------------------------------------------------
 
-import os.path, re, sys, glob
+import os.path
+import re
+import sys
+import glob
 import ctypes
 import ctypes.util
 
+
 def _environ_path(name):
     if name in os.environ:
         return os.environ[name].split(":")
     else:
         return []
 
+
 class LibraryLoader(object):
+
     def __init__(self):
-        self.other_dirs=[]
-    
-    def load_library(self,libname):
+        self.other_dirs = []
+
+    def load_library(self, libname):
         """Given the name of a library, load it."""
         paths = self.getpaths(libname)
-        
+
         for path in paths:
             if os.path.exists(path):
                 return self.load(path)
-        
-        raise ImportError,"%s not found." % libname
-    
-    def load(self,path):
+
+        raise ImportError("%s not found." % libname)
+
+    def load(self, path):
         """Given a path to a library, load it."""
         try:
             # Darwin requires dlopen to be called with mode RTLD_GLOBAL instead
@@ -68,42 +74,44 @@
             else:
                 return ctypes.cdll.LoadLibrary(path)
         except OSError as e:
-            raise ImportError,e
-    
-    def getpaths(self,libname):
+            raise ImportError(e)
+
+    def getpaths(self, libname):
         """Return a list of paths where the library might be found."""
         if os.path.isabs(libname):
             yield libname
-        
+
         else:
             for path in self.getplatformpaths(libname):
                 yield path
-            
+
             path = ctypes.util.find_library(libname)
-            if path: yield path
-    
+            if path:
+                yield path
+
     def getplatformpaths(self, libname):
         return []
 
 # Darwin (Mac OS X)
 
+
 class DarwinLibraryLoader(LibraryLoader):
     name_formats = ["lib%s.dylib", "lib%s.so", "lib%s.bundle", "%s.dylib",
-                "%s.so", "%s.bundle", "%s"]
-    
-    def getplatformpaths(self,libname):
+                    "%s.so", "%s.bundle", "%s"]
+
+    def getplatformpaths(self, libname):
         if os.path.pathsep in libname:
             names = [libname]
         else:
             names = [format % libname for format in self.name_formats]
-        
+
         for dir in self.getdirs(libname):
             for name in names:
-                yield os.path.join(dir,name)
-    
-    def getdirs(self,libname):
+                yield os.path.join(dir, name)
+
+    def getdirs(self, libname):
         '''Implements the dylib search as specified in Apple documentation:
-        
+
         http://developer.apple.com/documentation/DeveloperTools/Conceptual/
             DynamicLibraries/Articles/DynamicLibraryUsageGuidelines.html
 
@@ -116,9 +124,9 @@
         if not dyld_fallback_library_path:
             dyld_fallback_library_path = [os.path.expanduser('~/lib'),
                                           '/usr/local/lib', '/usr/lib']
-        
+
         dirs = []
-        
+
         if '/' in libname:
             dirs.extend(_environ_path("DYLD_LIBRARY_PATH"))
         else:
@@ -127,7 +135,7 @@
 
         dirs.extend(self.other_dirs)
         dirs.append(".")
-        
+
         if hasattr(sys, 'frozen') and sys.frozen == 'macosx_app':
             dirs.append(os.path.join(
                 os.environ['RESOURCEPATH'],
@@ -135,14 +143,15 @@
                 'Frameworks'))
 
         dirs.extend(dyld_fallback_library_path)
-        
+
         return dirs
 
 # Posix
 
+
 class PosixLibraryLoader(LibraryLoader):
     _ld_so_cache = None
-    
+
     def _create_ld_so_cache(self):
         # Recreate search path followed by ld.so.  This is going to be
         # slow to build, and incorrect (ld.so uses ld.so.cache, which may
@@ -153,17 +162,19 @@
 
         directories = []
         for name in ("LD_LIBRARY_PATH",
-                     "SHLIB_PATH", # HPUX
-                     "LIBPATH", # OS/2, AIX
-                     "LIBRARY_PATH", # BE/OS
-                    ):
+                     "SHLIB_PATH",  # HPUX
+                     "LIBPATH",  # OS/2, AIX
+                     "LIBRARY_PATH",  # BE/OS
+                     ):
             if name in os.environ:
                 directories.extend(os.environ[name].split(os.pathsep))
         directories.extend(self.other_dirs)
         directories.append(".")
 
-        try: directories.extend([dir.strip() for dir in open('/etc/ld.so.conf')])
-        except IOError: pass
+        try:
+            directories.extend([dir.strip() for dir in open('/etc/ld.so.conf')])
+        except IOError:
+            pass
 
         directories.extend(['/lib', '/usr/lib', '/lib64', '/usr/lib64'])
 
@@ -178,7 +189,7 @@
                     # Index by filename
                     if file not in cache:
                         cache[file] = path
-                    
+
                     # Index by library name
                     match = lib_re.match(file)
                     if match:
@@ -189,37 +200,44 @@
                 pass
 
         self._ld_so_cache = cache
-    
+
     def getplatformpaths(self, libname):
         if self._ld_so_cache is None:
             self._create_ld_so_cache()
 
         result = self._ld_so_cache.get(libname)
-        if result: yield result
+        if result:
+            yield result
 
         path = ctypes.util.find_library(libname)
-        if path: yield os.path.join("/lib",path)
+        if path:
+            yield os.path.join("/lib", path)
 
 # Windows
 
+
 class _WindowsLibrary(object):
+
     def __init__(self, path):
         self.cdll = ctypes.cdll.LoadLibrary(path)
         self.windll = ctypes.windll.LoadLibrary(path)
 
     def __getattr__(self, name):
-        try: return getattr(self.cdll,name)
+        try:
+            return getattr(self.cdll, name)
         except AttributeError:
-            try: return getattr(self.windll,name)
+            try:
+                return getattr(self.windll, name)
             except AttributeError:
                 raise
 
+
 class WindowsLibraryLoader(LibraryLoader):
     name_formats = ["%s.dll", "lib%s.dll"]
-    
+
     def load(self, path):
         return _WindowsLibrary(path)
-    
+
     def getplatformpaths(self, libname):
         if os.path.sep not in libname:
             for name in self.name_formats:
@@ -233,13 +251,14 @@
 # the Ctypesgen maintainers.
 
 loaderclass = {
-    "darwin":   DarwinLibraryLoader,
-    "cygwin":   WindowsLibraryLoader,
-    "win32":    WindowsLibraryLoader
+    "darwin": DarwinLibraryLoader,
+    "cygwin": WindowsLibraryLoader,
+    "win32": WindowsLibraryLoader
 }
 
 loader = loaderclass.get(sys.platform, PosixLibraryLoader)()
 
+
 def add_library_search_dirs(other_dirs):
     loader.other_dirs = other_dirs
 

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/messages.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/messages.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/messages.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -22,13 +22,16 @@
 
 import sys
 
-__all__ = ["error_message","warning_message","status_message"]
+__all__ = ["error_message", "warning_message", "status_message"]
 
-def error_message(msg,cls=None):
+
+def error_message(msg, cls=None):
     print "Error: %s" % msg
 
-def warning_message(msg,cls=None):
+
+def warning_message(msg, cls=None):
     print "Warning: %s" % msg
 
+
 def status_message(msg):
     print "Status: %s" % msg

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/options.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/options.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/options.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -8,9 +8,10 @@
 for convenience.
 """
 
-import optparse, copy
+import optparse
+import copy
 
-default_values={
+default_values = {
     "other_headers": [],
     "modules": [],
     "include_search_paths": [],
@@ -33,5 +34,6 @@
     "strip_build_path": None
 }
 
+
 def get_default_options():
     return optparse.Values(copy.deepcopy(default_values))

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/__init__.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/__init__.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/__init__.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -16,9 +16,10 @@
 
 from datacollectingparser import DataCollectingParser
 
+
 def parse(headers, options):
-    parser=DataCollectingParser(headers, options)
+    parser = DataCollectingParser(headers, options)
     parser.parse()
     return parser.data()
 
-__all__ = ["parse"]
\ No newline at end of file
+__all__ = ["parse"]

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/cdeclarations.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/cdeclarations.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/cdeclarations.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -12,7 +12,9 @@
 # C Object Model
 # --------------------------------------------------------------------------
 
+
 class Declaration(object):
+
     def __init__(self):
         self.declarator = None
         self.type = Type()
@@ -28,8 +30,10 @@
         l = ['%s=%r' % (k, v) for k, v in d.items()]
         return 'Declaration(%s)' % ', '.join(l)
 
+
 class Declarator(object):
     pointer = None
+
     def __init__(self):
         self.identifier = None
         self.initializer = None
@@ -52,8 +56,10 @@
             s += '(' + ', '.join([repr(p) for p in self.parameters]) + ')'
         return s
 
+
 class Pointer(Declarator):
     pointer = None
+
     def __init__(self):
         super(Pointer, self).__init__()
         self.qualifiers = []
@@ -65,14 +71,16 @@
         return 'POINTER%s(%r)' % (q, self.pointer) + \
             super(Pointer, self).__repr__()
 
+
 class Array(object):
+
     def __init__(self):
         self.size = None
         self.array = None
 
     def __repr__(self):
         if self.size:
-            a =  '[%r]' % self.size
+            a = '[%r]' % self.size
         else:
             a = '[]'
         if self.array:
@@ -80,7 +88,9 @@
         else:
             return a
 
+
 class Parameter(object):
+
     def __init__(self):
         self.type = Type()
         self.storage = None
@@ -99,6 +109,7 @@
 
 
 class Type(object):
+
     def __init__(self):
         self.qualifiers = []
         self.specifiers = []
@@ -108,13 +119,17 @@
 
 # These are used only internally.
 
+
 class StorageClassSpecifier(str):
     pass
 
+
 class TypeSpecifier(str):
     pass
 
+
 class StructTypeSpecifier(object):
+
     def __init__(self, is_union, tag, declarations):
         self.is_union = is_union
         self.tag = tag
@@ -131,11 +146,13 @@
             s += ' {%s}' % '; '.join([repr(d) for d in self.declarations])
         return s
 
+
 class EnumSpecifier(object):
+
     def __init__(self, tag, enumerators, src=None):
         self.tag = tag
         self.enumerators = enumerators
-        self.src=src
+        self.src = src
 
     def __repr__(self):
         s = 'enum'
@@ -145,7 +162,9 @@
             s += ' {%s}' % ', '.join([repr(e) for e in self.enumerators])
         return s
 
+
 class Enumerator(object):
+
     def __init__(self, name, expression):
         self.name = name
         self.expression = expression
@@ -156,19 +175,21 @@
             s += ' = %r' % self.expression
         return s
 
+
 class TypeQualifier(str):
     pass
 
+
 def apply_specifiers(specifiers, declaration):
     '''Apply specifiers to the declaration (declaration may be
     a Parameter instead).'''
     for s in specifiers:
-        if type(s) == StorageClassSpecifier:
+        if isinstance(s, StorageClassSpecifier):
             if declaration.storage:
                 # Multiple storage classes, technically an error... ignore it
                 pass
             declaration.storage = s
         elif type(s) in (TypeSpecifier, StructTypeSpecifier, EnumSpecifier):
             declaration.type.specifiers.append(s)
-        elif type(s) == TypeQualifier:
+        elif isinstance(s, TypeQualifier):
             declaration.type.qualifiers.append(s)

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/cgrammar.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/cgrammar.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/cgrammar.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -34,9 +34,9 @@
     'PTR_OP', 'INC_OP', 'DEC_OP', 'LEFT_OP', 'RIGHT_OP', 'LE_OP', 'GE_OP',
     'EQ_OP', 'NE_OP', 'AND_OP', 'OR_OP', 'MUL_ASSIGN', 'DIV_ASSIGN',
     'MOD_ASSIGN', 'ADD_ASSIGN', 'SUB_ASSIGN', 'LEFT_ASSIGN', 'RIGHT_ASSIGN',
-    'AND_ASSIGN', 'XOR_ASSIGN', 'OR_ASSIGN',  'PERIOD', 'TYPE_NAME', 
-    
-    'TYPEDEF', 'EXTERN', 'STATIC', 'AUTO', 'REGISTER', 
+    'AND_ASSIGN', 'XOR_ASSIGN', 'OR_ASSIGN', 'PERIOD', 'TYPE_NAME',
+
+    'TYPEDEF', 'EXTERN', 'STATIC', 'AUTO', 'REGISTER',
     'CHAR', 'SHORT', 'INT', 'LONG', 'SIGNED', 'UNSIGNED', 'FLOAT', 'DOUBLE',
     'CONST', 'VOLATILE', 'VOID',
     'STRUCT', 'UNION', 'ENUM', 'ELLIPSIS',
@@ -53,8 +53,9 @@
     'while', '__asm__'
 ]
 
+
 def p_translation_unit(p):
-    '''translation_unit : 
+    '''translation_unit :
                         | translation_unit external_declaration
                         | translation_unit define
     '''
@@ -63,6 +64,7 @@
     #    valid.
     # Intentionally empty
 
+
 def p_identifier(p):
     '''identifier : IDENTIFIER
                   | IDENTIFIER PP_IDENTIFIER_PASTE identifier
@@ -70,7 +72,7 @@
                   | IDENTIFIER PP_IDENTIFIER_PASTE PP_MACRO_PARAM
                   | PP_MACRO_PARAM PP_IDENTIFIER_PASTE PP_MACRO_PARAM
     '''
-    if len(p)==2:
+    if len(p) == 2:
         p[0] = expressions.IdentifierExpressionNode(p[1])
     else:
         # Should it be supported? It wouldn't be very hard to add support.
@@ -80,16 +82,17 @@
         # "locals()['%s' + '%s' + ...]" where %s was substituted with the
         # elements of the list. I haven't supported it yet because I think
         # it's unnecessary and a little too powerful.
-        p[0] = expressions.UnsupportedExpressionNode("Identifier pasting is " \
-            "not supported by ctypesgen.")
+        p[0] = expressions.UnsupportedExpressionNode("Identifier pasting is "
+                                                     "not supported by ctypesgen.")
 
+
 def p_constant(p):
     '''constant : CONSTANT
                 | CHARACTER_CONSTANT
     '''
     constant = p[1]
-    
-    if constant[0]=="'":
+
+    if constant[0] == "'":
         # Character constant
         value = constant[1:-1]
     else:
@@ -98,40 +101,47 @@
         # if it should be converted into an integer, long or float.
         prefix = constant[0]
         constant = constant[1:]
-        if prefix=="i":
+        if prefix == "i":
             value = int(constant)
-        elif prefix=="l":
+        elif prefix == "l":
             value = long(constant)
         else:
             value = float(constant)
-    
+
     p[0] = expressions.ConstantExpressionNode(value)
 
+
 def p_string_literal(p):
     '''string_literal : STRING_LITERAL'''
     p[0] = expressions.ConstantExpressionNode(p[1])
 
+
 def p_multi_string_literal(p):
     '''multi_string_literal : string_literal
                             | macro_param
                             | multi_string_literal string_literal
                             | multi_string_literal macro_param
     '''
-    if len(p)==2:
+    if len(p) == 2:
         p[0] = p[1]
     else:
-        p[0] = expressions.BinaryExpressionNode("string concatenation",
-            (lambda x,y: x+y), "(%s + %s)", (False,False), p[1], p[2])
+        p[0] = expressions.BinaryExpressionNode(
+            "string concatenation", (lambda x, y: x + y),
+            "(%s + %s)", (False, False),
+            p[1],
+            p[2])
 
+
 def p_macro_param(p):
     '''macro_param : PP_MACRO_PARAM
                    | PP_STRINGIFY PP_MACRO_PARAM
     '''
-    if len(p)==2:
+    if len(p) == 2:
         p[0] = expressions.ParameterExpressionNode(p[1])
     else:
         p[0] = expressions.ParameterExpressionNode(p[2])
 
+
 def p_primary_expression(p):
     '''primary_expression : identifier
                           | constant
@@ -143,6 +153,7 @@
     else:
         p[0] = p[1]
 
+
 def p_postfix_expression(p):
     '''postfix_expression : primary_expression
                   | postfix_expression '[' expression ']'
@@ -153,36 +164,40 @@
                   | postfix_expression INC_OP
                   | postfix_expression DEC_OP
     '''
-    
-    if len(p)==2:
+
+    if len(p) == 2:
         p[0] = p[1]
-    
-    elif p[2]=='[':
-        p[0] = expressions.BinaryExpressionNode("array access",
-            (lambda a,b: a[b]), "(%s [%s])", (True,False), p[1], p[3])
-    
-    elif p[2]=='(':
-        if p[3]==')':
-            p[0] = expressions.CallExpressionNode(p[1],[])
+
+    elif p[2] == '[':
+        p[0] = expressions.BinaryExpressionNode(
+            "array access", (lambda a, b: a[b]),
+            "(%s [%s])", (True, False),
+            p[1],
+            p[3])
+
+    elif p[2] == '(':
+        if p[3] == ')':
+            p[0] = expressions.CallExpressionNode(p[1], [])
         else:
-            p[0] = expressions.CallExpressionNode(p[1],p[3])
-    
-    elif p[2]=='.':
-        p[0] = expressions.AttributeExpressionNode( \
-            (lambda x,a: getattr(x,a)), "(%s.%s)", p[1],p[3])
-    
-    elif p[2]=='->':
-        p[0] = expressions.AttributeExpressionNode( \
-            (lambda x,a: getattr(x.contents,a)), "(%s.contents.%s)", p[1],p[3])
-    
-    elif p[2]=='++':
-        p[0] = expressions.UnaryExpressionNode("increment",(lambda x: x+1),
-                                               "(%s + 1)", False,p[1])
-    
-    elif p[2]=='--':
-        p[0] = expressions.UnaryExpressionNode("decrement",(lambda x: x-1),
-                                               "(%s - 1)", False,p[1])
+            p[0] = expressions.CallExpressionNode(p[1], p[3])
 
+    elif p[2] == '.':
+        p[0] = expressions.AttributeExpressionNode(
+            (lambda x, a: getattr(x, a)), "(%s.%s)", p[1], p[3])
+
+    elif p[2] == '->':
+        p[0] = expressions.AttributeExpressionNode(
+            (lambda x, a: getattr(x.contents, a)), "(%s.contents.%s)", p[1], p[3])
+
+    elif p[2] == '++':
+        p[0] = expressions.UnaryExpressionNode("increment", (lambda x: x + 1),
+                                               "(%s + 1)", False, p[1])
+
+    elif p[2] == '--':
+        p[0] = expressions.UnaryExpressionNode("decrement", (lambda x: x - 1),
+                                               "(%s - 1)", False, p[1])
+
+
 def p_argument_expression_list(p):
     '''argument_expression_list : assignment_expression
                         | argument_expression_list ',' assignment_expression
@@ -193,6 +208,7 @@
     else:
         p[0] = [p[1]]
 
+
 def p_asm_expression(p):
     '''asm_expression : __ASM__ volatile_opt '(' string_literal ')'
                       | __ASM__ volatile_opt '(' string_literal ':' str_opt_expr_pair_list ')'
@@ -208,33 +224,37 @@
 
     p[0] = expressions.UnsupportedExpressionNode("This node is ASM assembler.")
 
+
 def p_str_opt_expr_pair_list(p):
-    '''str_opt_expr_pair_list : 
+    '''str_opt_expr_pair_list :
                               | str_opt_expr_pair
                               | str_opt_expr_pair_list ',' str_opt_expr_pair
     '''
 
+
 def p_str_opt_expr_pair(p):
-   '''str_opt_expr_pair : string_literal
-                        | string_literal '(' expression ')'
-    '''
+    '''str_opt_expr_pair : string_literal
+                         | string_literal '(' expression ')'
+     '''
 
+
 def p_volatile_opt(p):
-    '''volatile_opt : 
+    '''volatile_opt :
                     | VOLATILE
     '''
 
 prefix_ops_dict = {
-    "++": ("increment",(lambda x: x+1),"(%s + 1)",False),
-    "--": ("decrement",(lambda x: x-1),"(%s - 1)",False),
-    '&': ("reference ('&')",None,"pointer(%s)",True),
-    '*': ("dereference ('*')",None,"(%s[0])",True),
-    '+': ("unary '+'",(lambda x: x),"%s",True),
-    '-': ("negation",(lambda x: -x),"(-%s)",False),
-    '~': ("inversion",(lambda x: ~x),"(~%s)",False),
-    '!': ("logical not",(lambda x: not x),"(not %s)",True)
+    "++": ("increment", (lambda x: x + 1), "(%s + 1)", False),
+    "--": ("decrement", (lambda x: x - 1), "(%s - 1)", False),
+    '&': ("reference ('&')", None, "pointer(%s)", True),
+    '*': ("dereference ('*')", None, "(%s[0])", True),
+    '+': ("unary '+'", (lambda x: x), "%s", True),
+    '-': ("negation", (lambda x: -x), "(-%s)", False),
+    '~': ("inversion", (lambda x: ~x), "(~%s)", False),
+    '!': ("logical not", (lambda x: not x), "(not %s)", True)
 }
 
+
 def p_unary_expression(p):
     '''unary_expression : postfix_expression
                         | INC_OP unary_expression
@@ -246,18 +266,19 @@
     '''
     if len(p) == 2:
         p[0] = p[1]
-    
+
     elif p[1] == 'sizeof':
-        if len(p)==5:
+        if len(p) == 5:
             p[0] = expressions.SizeOfExpressionNode(p[3])
         else:
             p[0] = expressions.SizeOfExpressionNode(p[2])
-    
+
     else:
-        name,op,format,can_be_ctype = prefix_ops_dict[p[1]]
+        name, op, format, can_be_ctype = prefix_ops_dict[p[1]]
         p[0] = expressions.UnaryExpressionNode(name, op, format, can_be_ctype,
                                                p[2])
 
+
 def p_unary_operator(p):
     '''unary_operator : '&'
                       | '*'
@@ -268,6 +289,7 @@
     '''
     p[0] = p[1]
 
+
 def p_cast_expression(p):
     '''cast_expression : unary_expression
                        | '(' type_name ')' cast_expression
@@ -275,14 +297,15 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        p[0] = expressions.TypeCastExpressionNode(p[4],p[2])
+        p[0] = expressions.TypeCastExpressionNode(p[4], p[2])
 
 mult_ops_dict = {
-    '*': ("multiplication", (lambda x,y: x*y), "(%s * %s)"),
-    '/': ("division", (lambda x,y: x/y), "(%s / %s)"),
-    '%': ("modulo", (lambda x,y: x%y), "(%s %% %s)")
+    '*': ("multiplication", (lambda x, y: x * y), "(%s * %s)"),
+    '/': ("division", (lambda x, y: x / y), "(%s / %s)"),
+    '%': ("modulo", (lambda x, y: x % y), "(%s %% %s)")
 }
 
+
 def p_multiplicative_expression(p):
     '''multiplicative_expression : cast_expression
                                  | multiplicative_expression '*' cast_expression
@@ -291,16 +314,17 @@
     '''
     if len(p) == 2:
         p[0] = p[1]
-    else:        
-        name,op,format = mult_ops_dict[p[2]]
-        p[0] = expressions.BinaryExpressionNode(name, op, format, (False,False),
-            p[1], p[3])
+    else:
+        name, op, format = mult_ops_dict[p[2]]
+        p[0] = expressions.BinaryExpressionNode(name, op, format, (False, False),
+                                                p[1], p[3])
 
 add_ops_dict = {
-    '+': ("addition", (lambda x,y: x+y), "(%s + %s)"),
-    '-': ("subtraction", (lambda x,y: x-y), "(%s - %s)")
+    '+': ("addition", (lambda x, y: x + y), "(%s + %s)"),
+    '-': ("subtraction", (lambda x, y: x - y), "(%s - %s)")
 }
 
+
 def p_additive_expression(p):
     '''additive_expression : multiplicative_expression
                            | additive_expression '+' multiplicative_expression
@@ -309,15 +333,16 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        name,op,format = add_ops_dict[p[2]]
-        p[0] = expressions.BinaryExpressionNode(name, op, format, (False,False),
-            p[1], p[3])
+        name, op, format = add_ops_dict[p[2]]
+        p[0] = expressions.BinaryExpressionNode(name, op, format, (False, False),
+                                                p[1], p[3])
 
 shift_ops_dict = {
-    '>>': ("right shift", (lambda x,y: x>>y), "(%s >> %s)"),
-    '<<': ("left shift", (lambda x,y: x<<y), "(%s << %s)")
+    '>>': ("right shift", (lambda x, y: x >> y), "(%s >> %s)"),
+    '<<': ("left shift", (lambda x, y: x << y), "(%s << %s)")
 }
 
+
 def p_shift_expression(p):
     '''shift_expression : additive_expression
                         | shift_expression LEFT_OP additive_expression
@@ -326,19 +351,20 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        name,op,format = shift_ops_dict[p[2]]
-        p[0] = expressions.BinaryExpressionNode(name, op, format, (False,False),
-            p[1], p[3])
+        name, op, format = shift_ops_dict[p[2]]
+        p[0] = expressions.BinaryExpressionNode(name, op, format, (False, False),
+                                                p[1], p[3])
 
 rel_ops_dict = {
-    '>': ("greater-than", (lambda x,y: x>y), "(%s > %s)"),
-    '<': ("less-than", (lambda x,y: x<y), "(%s < %s)"),
-    '>=': ("greater-than-equal", (lambda x,y: x>=y), "(%s >= %s)"),
-    '<=': ("less-than-equal", (lambda x,y: x<=y), "(%s <= %s)")
+    '>': ("greater-than", (lambda x, y: x > y), "(%s > %s)"),
+    '<': ("less-than", (lambda x, y: x < y), "(%s < %s)"),
+    '>=': ("greater-than-equal", (lambda x, y: x >= y), "(%s >= %s)"),
+    '<=': ("less-than-equal", (lambda x, y: x <= y), "(%s <= %s)")
 }
 
+
 def p_relational_expression(p):
-    '''relational_expression : shift_expression 
+    '''relational_expression : shift_expression
                              | relational_expression '<' shift_expression
                              | relational_expression '>' shift_expression
                              | relational_expression LE_OP shift_expression
@@ -347,15 +373,16 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        name,op,format = rel_ops_dict[p[2]]
-        p[0] = expressions.BinaryExpressionNode(name, op, format, (False,False),
-            p[1], p[3])
+        name, op, format = rel_ops_dict[p[2]]
+        p[0] = expressions.BinaryExpressionNode(name, op, format, (False, False),
+                                                p[1], p[3])
 
 equality_ops_dict = {
-    '==': ("equals", (lambda x,y: x==y), "(%s == %s)"),
-    '!=': ("not equals", (lambda x,y: x!=y), "(%s != %s)")
+    '==': ("equals", (lambda x, y: x == y), "(%s == %s)"),
+    '!=': ("not equals", (lambda x, y: x != y), "(%s != %s)")
 }
 
+
 def p_equality_expression(p):
     '''equality_expression : relational_expression
                            | equality_expression EQ_OP relational_expression
@@ -364,10 +391,11 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        name,op,format = equality_ops_dict[p[2]]
-        p[0] = expressions.BinaryExpressionNode(name, op, format, (False,False),
-            p[1], p[3])
+        name, op, format = equality_ops_dict[p[2]]
+        p[0] = expressions.BinaryExpressionNode(name, op, format, (False, False),
+                                                p[1], p[3])
 
+
 def p_and_expression(p):
     '''and_expression : equality_expression
                       | and_expression '&' equality_expression
@@ -375,19 +403,27 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        p[0] = expressions.BinaryExpressionNode("bitwise and",
-            (lambda x,y: x&y), "(%s & %s)", (False,False), p[1], p[3])
+        p[0] = expressions.BinaryExpressionNode(
+            "bitwise and", (lambda x, y: x & y),
+            "(%s & %s)", (False, False),
+            p[1],
+            p[3])
 
+
 def p_exclusive_or_expression(p):
     '''exclusive_or_expression : and_expression
                                | exclusive_or_expression '^' and_expression
-    ''' 
+    '''
     if len(p) == 2:
         p[0] = p[1]
     else:
-        p[0] = expressions.BinaryExpressionNode("bitwise xor",
-            (lambda x,y: x^y), "(%s ^ %s)", (False,False), p[1], p[3])
+        p[0] = expressions.BinaryExpressionNode(
+            "bitwise xor", (lambda x, y: x ^ y),
+            "(%s ^ %s)", (False, False),
+            p[1],
+            p[3])
 
+
 def p_inclusive_or_expression(p):
     '''inclusive_or_expression : exclusive_or_expression
                    | inclusive_or_expression '|' exclusive_or_expression
@@ -395,9 +431,13 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        p[0] = expressions.BinaryExpressionNode("bitwise or",
-            (lambda x,y: x|y), "(%s | %s)", (False,False), p[1], p[3])
+        p[0] = expressions.BinaryExpressionNode(
+            "bitwise or", (lambda x, y: x | y),
+            "(%s | %s)", (False, False),
+            p[1],
+            p[3])
 
+
 def p_logical_and_expression(p):
     '''logical_and_expression : inclusive_or_expression
                   | logical_and_expression AND_OP inclusive_or_expression
@@ -405,9 +445,13 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        p[0] = expressions.BinaryExpressionNode("logical and",
-            (lambda x,y: x and y), "(%s and %s)", (True,True), p[1], p[3])
+        p[0] = expressions.BinaryExpressionNode(
+            "logical and", (lambda x, y: x and y),
+            "(%s and %s)", (True, True),
+            p[1],
+            p[3])
 
+
 def p_logical_or_expression(p):
     '''logical_or_expression : logical_and_expression
                   | logical_or_expression OR_OP logical_and_expression
@@ -415,9 +459,13 @@
     if len(p) == 2:
         p[0] = p[1]
     else:
-        p[0] = expressions.BinaryExpressionNode("logical and",
-            (lambda x,y: x or y), "(%s or %s)", (True,True), p[1], p[3])
+        p[0] = expressions.BinaryExpressionNode(
+            "logical and", (lambda x, y: x or y),
+            "(%s or %s)", (True, True),
+            p[1],
+            p[3])
 
+
 def p_conditional_expression(p):
     '''conditional_expression : logical_or_expression
           | logical_or_expression '?' expression ':' conditional_expression
@@ -428,18 +476,19 @@
         p[0] = expressions.ConditionalExpressionNode(p[1], p[3], p[5])
 
 assign_ops_dict = {
-    '*=': ("multiply", (lambda x,y: x*y), "(%s * %s)"),
-    '/=': ("divide", (lambda x,y: x/y), "(%s / %s)"),
-    '%=': ("modulus", (lambda x,y: x%y), "(%s % %s)"),
-    '+=': ("addition", (lambda x,y: x+y), "(%s + %s)"),
-    '-=': ("subtraction", (lambda x,y: x-y), "(%s - %s)"),
-    '<<=': ("left shift", (lambda x,y: x<<y), "(%s << %s)"),
-    '>>=': ("right shift",(lambda x,y: x>>y),"(%s >> %s)"),
-    '&=': ("bitwise and", (lambda x,y: x&y), "(%s & %s)"),
-    '^=': ("bitwise xor", (lambda x,y: x^y), "(%s ^ %s)"),
-    '|=': ("bitwise or", (lambda x,y: x|y), "(%s | %s)")
+    '*=': ("multiply", (lambda x, y: x * y), "(%s * %s)"),
+    '/=': ("divide", (lambda x, y: x / y), "(%s / %s)"),
+    '%=': ("modulus", (lambda x, y: x % y), "(%s % %s)"),
+    '+=': ("addition", (lambda x, y: x + y), "(%s + %s)"),
+    '-=': ("subtraction", (lambda x, y: x - y), "(%s - %s)"),
+    '<<=': ("left shift", (lambda x, y: x << y), "(%s << %s)"),
+    '>>=': ("right shift", (lambda x, y: x >> y), "(%s >> %s)"),
+    '&=': ("bitwise and", (lambda x, y: x & y), "(%s & %s)"),
+    '^=': ("bitwise xor", (lambda x, y: x ^ y), "(%s ^ %s)"),
+    '|=': ("bitwise or", (lambda x, y: x | y), "(%s | %s)")
 }
 
+
 def p_assignment_expression(p):
     '''assignment_expression : conditional_expression
                  | unary_expression assignment_operator assignment_expression
@@ -449,13 +498,14 @@
     else:
         # In C, the value of (x*=3) is the same as (x*3). We support that here.
         # However, we don't support the change in the value of x.
-        if p[2]=='=':
+        if p[2] == '=':
             p[0] = p[3]
         else:
-            name,op,format = assign_ops_dict[p[2]]
-            p[0] = expressions.BinaryExpressionNode(name,op,format,(True,True),
-                p[1],p[3])
+            name, op, format = assign_ops_dict[p[2]]
+            p[0] = expressions.BinaryExpressionNode(name, op, format, (True, True),
+                                                    p[1], p[3])
 
+
 def p_assignment_operator(p):
     '''assignment_operator : '='
                            | MUL_ASSIGN
@@ -470,7 +520,8 @@
                            | OR_ASSIGN
     '''
     p[0] = p[1]
-    
+
+
 def p_expression(p):
     '''expression : assignment_expression
                   | expression ',' assignment_expression
@@ -478,11 +529,13 @@
     p[0] = p[1]
     # We don't need to support sequence expressions...
 
+
 def p_constant_expression(p):
     '''constant_expression : conditional_expression
     '''
     p[0] = p[1]
 
+
 def p_declaration(p):
     '''declaration : declaration_impl ';'
     '''
@@ -490,6 +543,7 @@
     # be executed before the ';' is shifted (otherwise the next lookahead will
     # be read, which may be affected by this declaration if its a typedef.
 
+
 def p_declaration_impl(p):
     '''declaration_impl : declaration_specifiers
                         | declaration_specifiers init_declarator_list
@@ -510,11 +564,12 @@
         p.parser.cparser.impl_handle_declaration(declaration, filename, lineno)
 
 # shift/reduce conflict with p_statement_error.
-#def p_declaration_error(p):
+# def p_declaration_error(p):
 #    '''declaration : error ';'
 #    '''
 #    # Error resynchronisation catch-all
 
+
 def p_declaration_specifiers(p):
     '''declaration_specifiers : storage_class_specifier
                               | storage_class_specifier declaration_specifiers
@@ -528,6 +583,7 @@
     else:
         p[0] = (p[1],)
 
+
 def p_init_declarator_list(p):
     '''init_declarator_list : init_declarator
                             | init_declarator_list ',' init_declarator
@@ -537,6 +593,7 @@
     else:
         p[0] = (p[1],)
 
+
 def p_init_declarator(p):
     '''init_declarator : declarator
                        | declarator '=' initializer
@@ -545,6 +602,7 @@
     if len(p) > 2:
         p[0].initializer = p[2]
 
+
 def p_storage_class_specifier(p):
     '''storage_class_specifier : TYPEDEF
                                | EXTERN
@@ -554,6 +612,7 @@
     '''
     p[0] = cdeclarations.StorageClassSpecifier(p[1])
 
+
 def p_type_specifier(p):
     '''type_specifier : VOID
                       | CHAR
@@ -574,6 +633,7 @@
     else:
         p[0] = cdeclarations.TypeSpecifier(p[1])
 
+
 def p_struct_or_union_specifier(p):
     '''struct_or_union_specifier : struct_or_union IDENTIFIER '{' struct_declaration_list '}'
          | struct_or_union TYPE_NAME '{' struct_declaration_list '}'
@@ -590,16 +650,18 @@
         p[0] = cdeclarations.StructTypeSpecifier(p[1], '', p[3])
     else:
         p[0] = cdeclarations.StructTypeSpecifier(p[1], p[2], p[4])
-    
+
     p[0].filename = p.slice[0].filename
     p[0].lineno = p.slice[0].lineno
 
+
 def p_struct_or_union(p):
     '''struct_or_union : STRUCT
                        | UNION
     '''
     p[0] = p[1] == 'union'
 
+
 def p_struct_declaration_list(p):
     '''struct_declaration_list : struct_declaration
                                | struct_declaration_list struct_declaration
@@ -609,6 +671,7 @@
     else:
         p[0] = p[1] + p[2]
 
+
 def p_struct_declaration(p):
     '''struct_declaration : specifier_qualifier_list struct_declarator_list ';'
                           | specifier_qualifier_list ';'
@@ -624,6 +687,7 @@
             r += (declaration,)
     p[0] = r
 
+
 def p_specifier_qualifier_list(p):
     '''specifier_qualifier_list : type_specifier specifier_qualifier_list
                                 | type_specifier
@@ -636,6 +700,7 @@
     else:
         p[0] = (p[1],)
 
+
 def p_struct_declarator_list(p):
     '''struct_declarator_list : struct_declarator
                               | struct_declarator_list ',' struct_declarator
@@ -645,19 +710,21 @@
     else:
         p[0] = p[1] + (p[3],)
 
+
 def p_struct_declarator(p):
     '''struct_declarator : declarator
                          | ':' constant_expression
                          | declarator ':' constant_expression
     '''
-    if p[1]==':':
+    if p[1] == ':':
         p[0] = cdeclarations.Declarator()
     else:
         p[0] = p[1]
         # Bitfield support
-        if len(p)==4:
+        if len(p) == 4:
             p[0].bitfield = p[3]
 
+
 def p_enum_specifier(p):
     '''enum_specifier : ENUM '{' enumerator_list '}'
                       | ENUM IDENTIFIER '{' enumerator_list '}'
@@ -669,10 +736,11 @@
         p[0] = cdeclarations.EnumSpecifier(p[2], p[4])
     else:
         p[0] = cdeclarations.EnumSpecifier(p[2], ())
-    
+
     p[0].filename = p.slice[0].filename
     p[0].lineno = p.slice[0].lineno
 
+
 def p_enumerator_list(p):
     '''enumerator_list : enumerator_list_iso
                        | enumerator_list_iso ','
@@ -681,6 +749,7 @@
     # not ISO C.
     p[0] = p[1]
 
+
 def p_enumerator_list_iso(p):
     '''enumerator_list_iso : enumerator
                            | enumerator_list_iso ',' enumerator
@@ -690,6 +759,7 @@
     else:
         p[0] = p[1] + (p[3],)
 
+
 def p_enumerator(p):
     '''enumerator : IDENTIFIER
                   | IDENTIFIER '=' constant_expression
@@ -699,12 +769,14 @@
     else:
         p[0] = cdeclarations.Enumerator(p[1], p[3])
 
+
 def p_type_qualifier(p):
     '''type_qualifier : CONST
                       | VOLATILE
     '''
     p[0] = cdeclarations.TypeQualifier(p[1])
 
+
 def p_declarator(p):
     '''declarator : pointer direct_declarator
                   | direct_declarator
@@ -718,6 +790,7 @@
     else:
         p[0] = p[1]
 
+
 def p_direct_declarator(p):
     '''direct_declarator : IDENTIFIER
                          | '(' declarator ')'
@@ -728,7 +801,7 @@
                          | direct_declarator '(' ')'
     '''
     if isinstance(p[1], cdeclarations.Declarator):
-        p[0] = p[1] 
+        p[0] = p[1]
         if p[2] == '[':
             a = cdeclarations.Array()
             a.array = p[0].array
@@ -762,7 +835,7 @@
     if len(p) == 2:
         p[0] = cdeclarations.Pointer()
     elif len(p) == 3:
-        if type(p[2]) == cdeclarations.Pointer:
+        if isinstance(p[2], cdeclarations.Pointer):
             p[0] = cdeclarations.Pointer()
             p[0].pointer = p[2]
         else:
@@ -773,6 +846,7 @@
         p[0].qualifiers = p[2]
         p[0].pointer = p[3]
 
+
 def p_type_qualifier_list(p):
     '''type_qualifier_list : type_qualifier
                            | type_qualifier_list type_qualifier
@@ -782,6 +856,7 @@
     else:
         p[0] = (p[1],)
 
+
 def p_parameter_type_list(p):
     '''parameter_type_list : parameter_list
                            | parameter_list ',' ELLIPSIS
@@ -801,6 +876,7 @@
     else:
         p[0] = (p[1],)
 
+
 def p_parameter_declaration(p):
     '''parameter_declaration : declaration_specifiers declarator
                              | declaration_specifiers abstract_declarator
@@ -811,6 +887,7 @@
     if len(p) > 2:
         p[0].declarator = p[2]
 
+
 def p_identifier_list(p):
     '''identifier_list : IDENTIFIER
                        | identifier_list ',' IDENTIFIER
@@ -824,23 +901,25 @@
         param.declarator.identifier = p[1]
         p[0] = (param,)
 
+
 def p_type_name(p):
     '''type_name : specifier_qualifier_list
                  | specifier_qualifier_list abstract_declarator
     '''
-    typ=p[1]
-    if len(p)==3:
+    typ = p[1]
+    if len(p) == 3:
         declarator = p[2]
     else:
         declarator = None
-        
+
     declaration = cdeclarations.Declaration()
     declaration.declarator = declarator
-    cdeclarations.apply_specifiers(typ,declaration)
+    cdeclarations.apply_specifiers(typ, declaration)
     ctype = ctypesparser.get_ctypes_type(declaration.type,
-                                            declaration.declarator)
+                                         declaration.declarator)
     p[0] = ctype
 
+
 def p_abstract_declarator(p):
     '''abstract_declarator : pointer
                            | direct_abstract_declarator
@@ -848,12 +927,12 @@
     '''
     if len(p) == 2:
         p[0] = p[1]
-        if type(p[0]) == cdeclarations.Pointer:
+        if isinstance(p[0], cdeclarations.Pointer):
             ptr = p[0]
             while ptr.pointer:
                 ptr = ptr.pointer
             # Only if doesn't already terminate in a declarator
-            if type(ptr) == cdeclarations.Pointer:
+            if isinstance(ptr, cdeclarations.Pointer):
                 ptr.pointer = cdeclarations.Declarator()
     else:
         p[0] = p[1]
@@ -862,6 +941,7 @@
             ptr = ptr.pointer
         ptr.pointer = p[2]
 
+
 def p_direct_abstract_declarator(p):
     '''direct_abstract_declarator : '(' abstract_declarator ')'
                       | '[' ']'
@@ -900,24 +980,27 @@
                     p[0].parameters = ()
                 else:
                     p[0].parameters = p[2]
-    
+
     # Check parameters for (void) and simplify to empty tuple.
     if p[0].parameters and len(p[0].parameters) == 1:
         param = p[0].parameters[0]
         if param.type.specifiers == ['void'] and not param.declarator:
             p[0].parameters = ()
 
+
 def p_initializer(p):
     '''initializer : assignment_expression
                    | '{' initializer_list '}'
                    | '{' initializer_list ',' '}'
     '''
 
+
 def p_initializer_list(p):
     '''initializer_list : initializer
                         | initializer_list ',' initializer
     '''
 
+
 def p_statement(p):
     '''statement : labeled_statement
                  | compound_statement
@@ -927,12 +1010,14 @@
                  | jump_statement
     '''
 
+
 def p_labeled_statement(p):
     '''labeled_statement : IDENTIFIER ':' statement
                          | CASE constant_expression ':' statement
                          | DEFAULT ':' statement
     '''
 
+
 def p_compound_statement(p):
     '''compound_statement : '{' '}'
                           | '{' statement_list '}'
@@ -940,43 +1025,52 @@
                           | '{' declaration_list statement_list '}'
     '''
 
+
 def p_compound_statement_error(p):
     '''compound_statement : '{' error '}'
     '''
     # Error resynchronisation catch-all
 
+
 def p_declaration_list(p):
     '''declaration_list : declaration
                         | declaration_list declaration
     '''
 
+
 def p_statement_list(p):
     '''statement_list : statement
                       | statement_list statement
     '''
 
+
 def p_expression_statement(p):
     '''expression_statement : ';'
                             | expression ';'
     '''
+
+
 def p_expression_statement_error(p):
     '''expression_statement : error ';'
     '''
     # Error resynchronisation catch-all
 
+
 def p_selection_statement(p):
     '''selection_statement : IF '(' expression ')' statement
                            | IF '(' expression ')' statement ELSE statement
                            | SWITCH '(' expression ')' statement
     '''
 
+
 def p_iteration_statement(p):
     '''iteration_statement : WHILE '(' expression ')' statement
     | DO statement WHILE '(' expression ')' ';'
     | FOR '(' expression_statement expression_statement ')' statement
     | FOR '(' expression_statement expression_statement expression ')' statement
-    '''	
+    '''
 
+
 def p_jump_statement(p):
     '''jump_statement : GOTO IDENTIFIER ';'
                       | CONTINUE ';'
@@ -985,13 +1079,15 @@
                       | RETURN expression ';'
     '''
 
+
 def p_external_declaration(p):
-    '''external_declaration : declaration 
+    '''external_declaration : declaration
                             | function_definition
     '''
 
     # Intentionally empty
 
+
 def p_function_definition(p):
     '''function_definition : declaration_specifiers declarator declaration_list compound_statement
                         | declaration_specifiers declarator compound_statement
@@ -999,6 +1095,7 @@
                         | declarator compound_statement
     '''
 
+
 def p_define(p):
     '''define : PP_DEFINE PP_DEFINE_NAME PP_END_DEFINE
               | PP_DEFINE PP_DEFINE_NAME type_name PP_END_DEFINE
@@ -1008,14 +1105,14 @@
               | PP_DEFINE PP_DEFINE_MACRO_NAME '(' macro_parameter_list ')' PP_END_DEFINE
               | PP_DEFINE PP_DEFINE_MACRO_NAME '(' macro_parameter_list ')' constant_expression PP_END_DEFINE
     '''
-    
+
     filename = p.slice[1].filename
     lineno = p.slice[1].lineno
-    
+
     if p[3] != '(':
         if len(p) == 4:
-           p.parser.cparser.handle_define_constant(p[2], None, filename,
-                                                   lineno)
+            p.parser.cparser.handle_define_constant(p[2], None, filename,
+                                                    lineno)
         else:
             p.parser.cparser.handle_define_constant(p[2], p[3], filename,
                                                     lineno)
@@ -1032,12 +1129,13 @@
                 expr = None
             elif len(p) == 8:
                 expr = p[6]
-        
+
         filename = p.slice[1].filename
         lineno = p.slice[1].lineno
-        
+
         p.parser.cparser.handle_define_macro(p[2], params, expr, filename, lineno)
 
+
 def p_define_error(p):
     '''define : PP_DEFINE error PP_END_DEFINE'''
     lexer = p[2].lexer
@@ -1047,47 +1145,49 @@
         start -= 1
     while clexdata[end].type != 'PP_END_DEFINE':
         end += 1
-        
-    name = clexdata[start+1].value
-    if clexdata[start+1].type == 'PP_DEFINE_NAME':
+
+    name = clexdata[start + 1].value
+    if clexdata[start + 1].type == 'PP_DEFINE_NAME':
         params = None
-        contents = [t.value for t in clexdata[start+2:end]]
+        contents = [t.value for t in clexdata[start + 2:end]]
     else:
         end_of_param_list = start
         while clexdata[end_of_param_list].value != ')' and \
-              end_of_param_list<end:
+                end_of_param_list < end:
             end_of_param_list += 1
-        params = [t.value for t in clexdata[start+3:end_of_param_list] if \
-                    t.value != ',']
-        contents = [t.value for t in clexdata[end_of_param_list+1:end]]
-    
+        params = [t.value for t in clexdata[start + 3:end_of_param_list] if
+                  t.value != ',']
+        contents = [t.value for t in clexdata[end_of_param_list + 1:end]]
+
     filename = p.slice[1].filename
     lineno = p.slice[1].lineno
-    
-    p[2].lexer.cparser.handle_define_unparseable(name, params, contents, \
+
+    p[2].lexer.cparser.handle_define_unparseable(name, params, contents,
                                                  filename, lineno)
 
+
 def p_macro_parameter_list(p):
     '''macro_parameter_list : PP_MACRO_PARAM
                             | macro_parameter_list ',' PP_MACRO_PARAM
     '''
-    if len(p)==2:
+    if len(p) == 2:
         p[0] = [p[1]]
     else:
         p[1].append(p[3])
         p[0] = p[1]
 
+
 def p_error(t):
     if t.lexer.in_define:
         # p_define_error will generate an error message.
         pass
     else:
         if t.type == '$end':
-            t.parser.cparser.handle_error('Syntax error at end of file.', 
-                 t.filename, 0)
+            t.parser.cparser.handle_error('Syntax error at end of file.',
+                                          t.filename, 0)
         else:
-            t.lexer.cparser.handle_error('Syntax error at %r' % t.value, 
-                 t.filename, t.lineno)
+            t.lexer.cparser.handle_error('Syntax error at %r' % t.value,
+                                         t.filename, t.lineno)
     # Don't alter lexer: default behaviour is to pass error production
     # up until it hits the catch-all at declaration, at which point
     # parsing continues (synchronisation).

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/cparser.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/cparser.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/cparser.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -25,7 +25,9 @@
 # Lexer
 # --------------------------------------------------------------------------
 
+
 class CLexer(object):
+
     def __init__(self, cparser):
         self.cparser = cparser
         self.type_names = set()
@@ -38,17 +40,17 @@
     def token(self):
         while self.pos < len(self.tokens):
             t = self.tokens[self.pos]
-            
+
             self.pos += 1
 
             if not t:
                 break
-            
+
             if t.type == 'PP_DEFINE':
                 self.in_define = True
             elif t.type == 'PP_END_DEFINE':
                 self.in_define = False
-            
+
             # Transform PP tokens into C tokens
             elif t.type == 'LPAREN':
                 t.type = '('
@@ -57,36 +59,38 @@
             elif t.type == 'IDENTIFIER' and t.value in cgrammar.keywords:
                 t.type = t.value.upper()
             elif t.type == 'IDENTIFIER' and t.value in self.type_names:
-                if (self.pos < 2 or self.tokens[self.pos-2].type not in
-                    ('ENUM', 'STRUCT', 'UNION')):
+                if (self.pos < 2 or self.tokens[self.pos - 2].type not in
+                        ('ENUM', 'STRUCT', 'UNION')):
                     t.type = 'TYPE_NAME'
-            
+
             t.lexer = self
             t.clexpos = self.pos - 1
-            
+
             return t
         return None
-        
+
 # --------------------------------------------------------------------------
 # Parser
 # --------------------------------------------------------------------------
 
+
 class CParser(object):
     '''Parse a C source file.
 
     Subclass and override the handle_* methods.  Call `parse` with a string
     to parse.
     '''
+
     def __init__(self, options, stddef_types=True, gnu_types=True):
-        self.preprocessor_parser = preprocessor.PreprocessorParser(options,self)
+        self.preprocessor_parser = preprocessor.PreprocessorParser(options, self)
         self.parser = yacc.Parser()
-        prototype = yacc.yacc(method        = 'LALR',
-                              debug         = False,
-                              module        = cgrammar,
-                              write_tables  = True,
-                              outputdir     = os.path.dirname(__file__),
-                              optimize      = True)
-        
+        prototype = yacc.yacc(method='LALR',
+                              debug=False,
+                              module=cgrammar,
+                              write_tables=True,
+                              outputdir=os.path.dirname(__file__),
+                              optimize=True)
+
         # If yacc is reading tables from a file, then it won't find the error
         # function... need to set it manually
         prototype.errorfunc = cgrammar.p_error
@@ -102,7 +106,7 @@
             self.lexer.type_names.add('__builtin_va_list')
         if sys.platform == 'win32':
             self.lexer.type_names.add('__int64')
-        
+
     def parse(self, filename, debug=False):
         '''Parse a file.
 
@@ -120,22 +124,22 @@
     # ----------------------------------------------------------------------
 
     def handle_error(self, message, filename, lineno):
-        '''A parse error occurred.  
-        
+        '''A parse error occurred.
+
         The default implementation prints `lineno` and `message` to stderr.
         The parser will try to recover from errors by synchronising at the
         next semicolon.
         '''
         print >> sys.stderr, '%s:%s %s' % (filename, lineno, message)
-    
+
     def handle_pp_error(self, message):
         '''The C preprocessor emitted an error.
-        
+
         The default implementatin prints the error to stderr. If processing
         can continue, it will.
         '''
         print >> sys.stderr, 'Preprocessor:', message
-    
+
     def handle_status(self, message):
         '''Progress information.
 
@@ -144,7 +148,7 @@
         print >> sys.stderr, message
 
     def handle_define(self, name, params, value, filename, lineno):
-        '''#define `name` `value` 
+        '''#define `name` `value`
         or #define `name`(`params`) `value`
 
         name is a string
@@ -154,19 +158,19 @@
 
     def handle_define_constant(self, name, value, filename, lineno):
         '''#define `name` `value`
-        
+
         name is a string
         value is an ExpressionNode or None
         '''
-    
+
     def handle_define_macro(self, name, params, value, filename, lineno):
         '''#define `name`(`params`) `value`
-        
+
         name is a string
         params is a list of strings
         value is an ExpressionNode or None
         '''
-    
+
     def impl_handle_declaration(self, declaration, filename, lineno):
         '''Internal method that calls `handle_declaration`.  This method
         also adds any new type definitions to the lexer's list of valid type
@@ -183,13 +187,14 @@
         self.handle_declaration(declaration, filename, lineno)
 
     def handle_declaration(self, declaration, filename, lineno):
-        '''A declaration was encountered.  
-        
+        '''A declaration was encountered.
+
         `declaration` is an instance of Declaration.  Where a declaration has
         multiple initialisers, each is returned as a separate declaration.
         '''
         pass
 
+
 class DebugCParser(CParser):
     '''A convenience class that prints each invocation of a handle_* method to
     stdout.
@@ -203,6 +208,6 @@
 
     def handle_declaration(self, declaration, filename, lineno):
         print declaration
-        
+
 if __name__ == '__main__':
     DebugCParser().parse(sys.argv[1], debug=True)

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/ctypesparser.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/ctypesparser.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/ctypesparser.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -17,12 +17,13 @@
 from cdeclarations import *
 from ctypesgencore.expressions import *
 
-def get_ctypes_type(typ, declarator, check_qualifiers=False):       
+
+def get_ctypes_type(typ, declarator, check_qualifiers=False):
     signed = True
     typename = 'int'
     longs = 0
     t = None
-    
+
     for specifier in typ.specifiers:
         if isinstance(specifier, StructTypeSpecifier):
             t = make_struct_from_specifier(specifier)
@@ -36,15 +37,15 @@
             longs += 1
         else:
             typename = str(specifier)
-    
+
     if not t:
         # It is a numeric type of some sort
-        if (typename,signed,longs) in ctypes_type_map:
-            t = CtypesSimple(typename,signed,longs)
-        
+        if (typename, signed, longs) in ctypes_type_map:
+            t = CtypesSimple(typename, signed, longs)
+
         elif signed and not longs:
             t = CtypesTypedef(typename)
-        
+
         else:
             name = " ".join(typ.specifiers)
             if typename in [x[0] for x in ctypes_type_map.keys()]:
@@ -54,10 +55,10 @@
                 error = "Ctypes does not support adding additional " \
                     "specifiers to typedefs, such as \"%s\"" % name
             t = CtypesTypedef(name)
-            t.error(error,cls='unsupported-type')
-        
+            t.error(error, cls='unsupported-type')
+
         if declarator and declarator.bitfield:
-            t = CtypesBitfield(t,declarator.bitfield)
+            t = CtypesBitfield(t, declarator.bitfield)
 
     qualifiers = []
     qualifiers.extend(typ.qualifiers)
@@ -67,50 +68,51 @@
 
             params = []
             for param in declarator.parameters:
-                if param=="...":
+                if param == "...":
                     break
                 params.append(get_ctypes_type(param.type, param.declarator))
             t = CtypesFunction(t, params, variadic)
-        
+
         a = declarator.array
         while a:
             t = CtypesArray(t, a.size)
             a = a.array
 
         qualifiers.extend(declarator.qualifiers)
-        
+
         t = CtypesPointer(t, declarator.qualifiers)
-        
+
         declarator = declarator.pointer
-    
+
     if declarator and declarator.parameters is not None:
         variadic = "..." in declarator.parameters
 
         params = []
         for param in declarator.parameters:
-            if param=="...":
+            if param == "...":
                 break
             params.append(get_ctypes_type(param.type, param.declarator))
         t = CtypesFunction(t, params, variadic)
-    
+
     if declarator:
         a = declarator.array
         while a:
             t = CtypesArray(t, a.size)
             a = a.array
-    
+
     if isinstance(t, CtypesPointer) and \
        isinstance(t.destination, CtypesSimple) and \
-       t.destination.name=="char" and \
+       t.destination.name == "char" and \
        t.destination.signed:
-       t = CtypesSpecial("String")
+        t = CtypesSpecial("String")
 
     return t
 
+
 def make_struct_from_specifier(specifier):
-    variety = {True:"union", False:"struct"}[specifier.is_union]
+    variety = {True: "union", False: "struct"}[specifier.is_union]
     tag = specifier.tag
-    
+
     if specifier.declarations:
         members = []
         for declaration in specifier.declarations:
@@ -127,13 +129,14 @@
             members.append((name, remove_function_pointer(t)))
     else:
         members = None
-    
-    return CtypesStruct(tag,variety,members,
-                        src=(specifier.filename,specifier.lineno))
 
+    return CtypesStruct(tag, variety, members,
+                        src=(specifier.filename, specifier.lineno))
+
+
 def make_enum_from_specifier(specifier):
     tag = specifier.tag
-    
+
     enumerators = []
     last_name = None
     for e in specifier.enumerators:
@@ -141,32 +144,33 @@
             value = e.expression
         else:
             if last_name:
-                value = BinaryExpressionNode("addition", (lambda x,y:x+y),
-                    "(%s + %s)", (False,False),
-                    IdentifierExpressionNode(last_name),
-                    ConstantExpressionNode(1))
+                value = BinaryExpressionNode("addition", (lambda x, y: x + y),
+                                             "(%s + %s)", (False, False),
+                                             IdentifierExpressionNode(last_name),
+                                             ConstantExpressionNode(1))
             else:
                 value = ConstantExpressionNode(0)
-        
-        enumerators.append((e.name,value))
+
+        enumerators.append((e.name, value))
         last_name = e.name
-    
+
     return CtypesEnum(tag, enumerators,
-                      src=(specifier.filename,specifier.lineno))
+                      src=(specifier.filename, specifier.lineno))
 
+
 class CtypesParser(CParser):
     '''Parse a C file for declarations that can be used by ctypes.
-    
+
     Subclass and override the handle_ctypes_* methods.
     '''
 
     def handle_declaration(self, declaration, filename, lineno):
         t = get_ctypes_type(declaration.type, declaration.declarator)
-        
+
         if type(t) in (CtypesStruct, CtypesEnum):
             self.handle_ctypes_new_type(
                 remove_function_pointer(t), filename, lineno)
-        
+
         declarator = declaration.declarator
         if declarator is None:
             # XXX TEMPORARY while struct with no typedef not filled in
@@ -177,17 +181,17 @@
         if declaration.storage == 'typedef':
             self.handle_ctypes_typedef(
                 name, remove_function_pointer(t), filename, lineno)
-        elif type(t) == CtypesFunction:
+        elif isinstance(t, CtypesFunction):
             self.handle_ctypes_function(
                 name, t.restype, t.argtypes, t.variadic, filename, lineno)
         elif declaration.storage != 'static':
             self.handle_ctypes_variable(name, t, filename, lineno)
 
     # ctypes parser interface.  Override these methods in your subclass.
-    
+
     def handle_ctypes_new_type(self, ctype, filename, lineno):
         pass
-    
+
     def handle_ctypes_typedef(self, name, ctype, filename, lineno):
         pass
 

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/datacollectingparser.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/datacollectingparser.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/datacollectingparser.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -4,7 +4,7 @@
 DataCollectingParser subclasses ctypesparser.CtypesParser and builds Description
 objects from the CtypesType objects and other information from CtypesParser.
 After parsing is complete, a DescriptionCollection object can be retrieved by
-calling DataCollectingParser.data(). 
+calling DataCollectingParser.data().
 """
 
 import ctypesparser
@@ -15,6 +15,7 @@
 from tempfile import mkstemp
 import os
 
+
 class DataCollectingParser(ctypesparser.CtypesParser,
                            ctypesparser.CtypesTypeVisitor):
     """Main class for the Parser component. Steps for use:
@@ -22,41 +23,42 @@
     p.parse()
     data=p.data() #A dictionary of constants, enums, structs, functions, etc.
     """
-    def __init__(self,headers,options):
-        ctypesparser.CtypesParser.__init__(self,options)
-        self.headers=headers
-        self.options=options
-        
-        self.constants=[]
-        self.typedefs=[]
-        self.structs=[]
-        self.enums=[]
-        self.functions=[]
-        self.variables=[]
-        self.macros=[]
-        
-        self.all=[]
-        self.output_order=[]
-        
+
+    def __init__(self, headers, options):
+        ctypesparser.CtypesParser.__init__(self, options)
+        self.headers = headers
+        self.options = options
+
+        self.constants = []
+        self.typedefs = []
+        self.structs = []
+        self.enums = []
+        self.functions = []
+        self.variables = []
+        self.macros = []
+
+        self.all = []
+        self.output_order = []
+
         # NULL is a useful macro to have defined
         null = ConstantExpressionNode(None)
-        nullmacro = ConstantDescription("NULL",null,("<built-in>",1))
+        nullmacro = ConstantDescription("NULL", null, ("<built-in>", 1))
         self.constants.append(nullmacro)
         self.all.append(nullmacro)
         self.output_order.append(("constant", nullmacro))
-        
+
         # A list of tuples describing macros; saved to be processed after
         # everything else has been parsed
         self.saved_macros = []
         # A set of structs that are already known
-        self.already_seen_structs=set() 
+        self.already_seen_structs = set()
         # A dict of structs that have only been seen in opaque form
-        self.already_seen_opaque_structs={} 
+        self.already_seen_opaque_structs = {}
         # A set of enums that are already known
-        self.already_seen_enums=set() 
+        self.already_seen_enums = set()
         # A dict of enums that have only been seen in opaque form
-        self.already_seen_opaque_enums={}
-            
+        self.already_seen_opaque_enums = {}
+
     def parse(self):
         fd, fname = mkstemp(suffix=".h")
         f = os.fdopen(fd, 'w+b')
@@ -66,17 +68,17 @@
             print >>f, '#include "%s"' % os.path.abspath(header)
         f.flush()
         f.close()
-        ctypesparser.CtypesParser.parse(self,fname,None)
+        ctypesparser.CtypesParser.parse(self, fname, None)
         os.remove(fname)
 
-        for name, params, expr, (filename,lineno) in self.saved_macros:
+        for name, params, expr, (filename, lineno) in self.saved_macros:
             self.handle_macro(name, params, expr, filename, lineno)
-            
+
     def handle_define_constant(self, name, expr, filename, lineno):
         # Called by CParser
         # Save to handle later
         self.saved_macros.append((name, None, expr, (filename, lineno)))
-    
+
     def handle_define_unparseable(self, name, params, value, filename, lineno):
         # Called by CParser
         if params:
@@ -86,66 +88,66 @@
             original_string = "#define %s %s" % \
                 (name, " ".join(value))
         macro = MacroDescription(name, params, None,
-                                 src = (filename,lineno))
+                                 src=(filename, lineno))
         macro.error("Could not parse macro \"%s\"" % original_string,
-                    cls = 'macro')
+                    cls='macro')
         macro.original_string = original_string
         self.macros.append(macro)
         self.all.append(macro)
-        self.output_order.append(('macro',macro))
-    
+        self.output_order.append(('macro', macro))
+
     def handle_define_macro(self, name, params, expr, filename, lineno):
         # Called by CParser
         # Save to handle later
-        self.saved_macros.append((name, params, expr, (filename,lineno)))
-    
+        self.saved_macros.append((name, params, expr, (filename, lineno)))
+
     def handle_ctypes_typedef(self, name, ctype, filename, lineno):
         # Called by CtypesParser
         ctype.visit(self)
-        
-        typedef=TypedefDescription(name,
-                                   ctype,
-                                   src=(filename,repr(lineno)))
-        
+
+        typedef = TypedefDescription(name,
+                                     ctype,
+                                     src=(filename, repr(lineno)))
+
         self.typedefs.append(typedef)
         self.all.append(typedef)
-        self.output_order.append(('typedef',typedef))
-    
+        self.output_order.append(('typedef', typedef))
+
     def handle_ctypes_new_type(self, ctype, filename, lineno):
         # Called by CtypesParser
-        if isinstance(ctype,ctypesparser.CtypesEnum):
+        if isinstance(ctype, ctypesparser.CtypesEnum):
             self.handle_enum(ctype, filename, lineno)
         else:
             self.handle_struct(ctype, filename, lineno)
-    
+
     def handle_ctypes_function(self, name, restype, argtypes, variadic,
                                filename, lineno):
         # Called by CtypesParser
         restype.visit(self)
         for argtype in argtypes:
             argtype.visit(self)
-        
-        function=FunctionDescription(name,
-                                     restype,
-                                     argtypes,
-                                     variadic = variadic,
-                                     src=(filename,repr(lineno)))
-        
+
+        function = FunctionDescription(name,
+                                       restype,
+                                       argtypes,
+                                       variadic=variadic,
+                                       src=(filename, repr(lineno)))
+
         self.functions.append(function)
         self.all.append(function)
-        self.output_order.append(('function',function))
+        self.output_order.append(('function', function))
 
     def handle_ctypes_variable(self, name, ctype, filename, lineno):
         # Called by CtypesParser
         ctype.visit(self)
-        
-        variable=VariableDescription(name,
-                                     ctype,
-                                     src=(filename,repr(lineno)))
-        
+
+        variable = VariableDescription(name,
+                                       ctype,
+                                       src=(filename, repr(lineno)))
+
         self.variables.append(variable)
         self.all.append(variable)
-        self.output_order.append(('variable',variable))
+        self.output_order.append(('variable', variable))
 
     def handle_struct(self, ctypestruct, filename, lineno):
         # Called from within DataCollectingParser
@@ -155,79 +157,79 @@
         # find a transparent struct with the same tag, we fill in the
         # opaque struct with the information from the transparent struct and
         # move the opaque struct to the end of the struct list.
-        
-        name = "%s %s"%(ctypestruct.variety,ctypestruct.tag)
-        
+
+        name = "%s %s" % (ctypestruct.variety, ctypestruct.tag)
+
         if name in self.already_seen_structs:
             return
-        
+
         if ctypestruct.opaque:
             if name not in self.already_seen_opaque_structs:
                 struct = StructDescription(ctypestruct.tag,
                                            ctypestruct.variety,
-                                           None, # No members
-                                           True, # Opaque
+                                           None,  # No members
+                                           True,  # Opaque
                                            ctypestruct,
-                                           src=(filename,str(lineno)))
-                
-                self.already_seen_opaque_structs[name]=struct
+                                           src=(filename, str(lineno)))
+
+                self.already_seen_opaque_structs[name] = struct
                 self.structs.append(struct)
                 self.all.append(struct)
-                self.output_order.append(('struct',struct))
-        
+                self.output_order.append(('struct', struct))
+
         else:
-            for (membername,ctype) in ctypestruct.members:
+            for (membername, ctype) in ctypestruct.members:
                 ctype.visit(self)
-            
+
             if name in self.already_seen_opaque_structs:
                 # Fill in older version
-                struct=self.already_seen_opaque_structs[name]
+                struct = self.already_seen_opaque_structs[name]
                 struct.opaque = False
                 struct.members = ctypestruct.members
                 struct.ctype = ctypestruct
                 struct.src = ctypestruct.src
-                
-                self.output_order.append(('struct-body',struct))
-                
+
+                self.output_order.append(('struct-body', struct))
+
                 del self.already_seen_opaque_structs[name]
-            
+
             else:
                 struct = StructDescription(ctypestruct.tag,
                                            ctypestruct.variety,
                                            ctypestruct.members,
-                                           False, # Not opaque
-                                           src=(filename,str(lineno)),
-                                           ctype=ctypestruct)                
+                                           False,  # Not opaque
+                                           src=(filename, str(lineno)),
+                                           ctype=ctypestruct)
                 self.structs.append(struct)
                 self.all.append(struct)
-                self.output_order.append(('struct',struct))
-                self.output_order.append(('struct-body',struct))
-            
+                self.output_order.append(('struct', struct))
+                self.output_order.append(('struct-body', struct))
+
             self.already_seen_structs.add(name)
-    
+
     def handle_enum(self, ctypeenum, filename, lineno):
         # Called from within DataCollectingParser.
-        
+
         # Process for handling opaque enums is the same as process for opaque
         # structs. See handle_struct() for more details.
-        
+
         tag = ctypeenum.tag
         if tag in self.already_seen_enums:
             return
-            
+
         if ctypeenum.opaque:
             if tag not in self.already_seen_opaque_enums:
-                enum=EnumDescription(ctypeenum.tag,
-                             ctypeenum.enumerators,
-                             ctypeenum,
-                             src = (filename,str(lineno)))
+                enum = EnumDescription(ctypeenum.tag,
+                                       ctypeenum.enumerators,
+                                       ctypeenum,
+                                       src=(filename, str(lineno)))
                 enum.opaque = True
-                
-                self.already_seen_opaque_enums[tag]=enum
+
+                self.already_seen_opaque_enums[tag] = enum
                 self.enums.append(enum)
                 self.all.append(enum)
-                self.output_order.append(('enum',enum))
-                
+                self.output_order.append(('enum', enum))
+
         else:
             if tag in self.already_seen_opaque_enums:
                 # Fill in older opaque version
@@ -235,87 +237,87 @@
                 enum.opaque = False
                 enum.ctype = ctypeenum
                 enum.src = ctypeenum.src
-            
+
                 del self.already_seen_opaque_enums[tag]
-            
+
             else:
-                enum=EnumDescription(ctypeenum.tag,
-                                None,
-                                src=(filename,str(lineno)),
-                                ctype=ctypeenum)
+                enum = EnumDescription(ctypeenum.tag,
+                                       None,
+                                       src=(filename, str(lineno)),
+                                       ctype=ctypeenum)
                 enum.opaque = False
-                
+
                 self.enums.append(enum)
                 self.all.append(enum)
-                self.output_order.append(('enum',enum))
-            
+                self.output_order.append(('enum', enum))
+
             self.already_seen_enums.add(tag)
-            
-            for (enumname,expr) in ctypeenum.enumerators:                
-                constant=ConstantDescription(enumname, expr,
-                                             src=(filename,lineno))
-                
+
+            for (enumname, expr) in ctypeenum.enumerators:
+                constant = ConstantDescription(enumname, expr,
+                                               src=(filename, lineno))
+
                 self.constants.append(constant)
                 self.all.append(constant)
-                self.output_order.append(('constant',constant))
-    
+                self.output_order.append(('constant', constant))
+
     def handle_macro(self, name, params, expr, filename, lineno):
         # Called from within DataCollectingParser
-        src = (filename,lineno)
-        
-        if expr==None:
+        src = (filename, lineno)
+
+        if expr is None:
             expr = ConstantExpressionNode(True)
             constant = ConstantDescription(name, expr, src)
             self.constants.append(constant)
             self.all.append(constant)
             return
-        
+
         expr.visit(self)
-        
-        if isinstance(expr,CtypesType):
+
+        if isinstance(expr, CtypesType):
             if params:
                 macro = MacroDescription(name, "", src)
-                macro.error("%s has parameters but evaluates to a type. " \
-                    "Ctypesgen does not support it." % macro.casual_name(),
-                    cls = 'macro')
+                macro.error("%s has parameters but evaluates to a type. "
+                            "Ctypesgen does not support it." % macro.casual_name(),
+                            cls='macro')
                 self.macros.append(macro)
                 self.all.append(macro)
-                self.output_order.append(('macro',macro))
-            
+                self.output_order.append(('macro', macro))
+
             else:
                 typedef = TypedefDescription(name, expr, src)
                 self.typedefs.append(typedef)
                 self.all.append(typedef)
-                self.output_order.append(('typedef',typedef))
-        
+                self.output_order.append(('typedef', typedef))
+
         else:
             macro = MacroDescription(name, params, expr, src)
             self.macros.append(macro)
             self.all.append(macro)
-            self.output_order.append(('macro',macro))
-        
+            self.output_order.append(('macro', macro))
+
         # Macros could possibly contain things like __FILE__, __LINE__, etc...
         # This could be supported, but it would be a lot of work. It would
         # probably also bloat the Preamble considerably.
-        
+
     def handle_error(self, message, filename, lineno):
         # Called by CParser
-        error_message("%s:%d: %s" % (filename,lineno,message), cls='cparser')
-    
+        error_message("%s:%d: %s" % (filename, lineno, message), cls='cparser')
+
     def handle_pp_error(self, message):
         # Called by PreprocessorParser
-        error_message("%s: %s" % (self.options.cpp, message), cls = 'cparser')
-    
+        error_message("%s: %s" % (self.options.cpp, message), cls='cparser')
+
     def handle_status(self, message):
         # Called by CParser
         status_message(message)
-    
+
     def visit_struct(self, struct):
         self.handle_struct(struct, struct.src[0], struct.src[1])
-    
-    def visit_enum(self,enum):
+
+    def visit_enum(self, enum):
         self.handle_enum(enum, enum.src[0], enum.src[1])
-    
+
     def data(self):
         return DescriptionCollection(self.constants,
                                      self.typedefs,

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/lex.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/lex.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/lex.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -11,22 +11,25 @@
 # modify it under the terms of the GNU Lesser General Public
 # License as published by the Free Software Foundation; either
 # version 2.1 of the License, or (at your option) any later version.
-# 
+#
 # This library is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 # Lesser General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU Lesser General Public
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-# 
+#
 # See the file LICENSE for a complete copy of the LGPL.
 #-----------------------------------------------------------------------------
 
 __version__ = "2.2"
 
-import re, sys, types, os.path
+import re
+import sys
+import types
+import os.path
 
 # Regular expression used to match valid token names
 _is_identifier = re.compile(r'^[a-zA-Z0-9_]+$')
@@ -36,25 +39,35 @@
 # with Python 2.0 where types.ObjectType is undefined.
 
 try:
-   _INSTANCETYPE = (types.InstanceType, types.ObjectType)
+    _INSTANCETYPE = (types.InstanceType, types.ObjectType)
 except AttributeError:
-   _INSTANCETYPE = types.InstanceType
-   class object: pass       # Note: needed if no new-style classes present
+    _INSTANCETYPE = types.InstanceType
 
+    class object:
+        pass       # Note: needed if no new-style classes present
+
 # Exception thrown when invalid token encountered and no default error
 # handler is defined.
+
+
 class LexError(Exception):
-    def __init__(self,message,s):
-         self.args = (message,)
-         self.text = s
 
+    def __init__(self, message, s):
+        self.args = (message,)
+        self.text = s
+
 # Token class
+
+
 class LexToken(object):
+
     def __str__(self):
-        return "LexToken(%s,%r,%d,%d)" % (self.type,self.value,self.lineno,self.lexpos)
+        return "LexToken(%s,%r,%d,%d)" % (self.type, self.value, self.lineno, self.lexpos)
+
     def __repr__(self):
         return str(self)
-    def skip(self,n):
+
+    def skip(self, n):
         self.lexer.skip(n)
 
 # -----------------------------------------------------------------------------
@@ -66,12 +79,14 @@
 #    token()          -  Get the next token
 # -----------------------------------------------------------------------------
 
+
 class Lexer:
+
     def __init__(self):
-        self.lexre = None             # Master regular expression. This is a list of 
-                                      # tuples (re,findex) where re is a compiled
-                                      # regular expression and findex is a list
-                                      # mapping regex group numbers to rules
+        self.lexre = None             # Master regular expression. This is a list of
+        # tuples (re,findex) where re is a compiled
+        # regular expression and findex is a list
+        # mapping regex group numbers to rules
         self.lexretext = None         # Current regular expression strings
         self.lexstatere = {}          # Dictionary mapping lexer states to master regexs
         self.lexstateretext = {}      # Dictionary mapping lexer states to regex strings
@@ -93,7 +108,7 @@
         self.lexdebug = 0             # Debugging mode
         self.lexoptimize = 0          # Optimized mode
 
-    def clone(self,object=None):
+    def clone(self, object=None):
         c = Lexer()
         c.lexstatere = self.lexstatere
         c.lexstateinfo = self.lexstateinfo
@@ -111,29 +126,29 @@
         c.lineno = self.lineno
         c.lexoptimize = self.lexoptimize
         c.lexliterals = self.lexliterals
-        c.lexmodule   = self.lexmodule
+        c.lexmodule = self.lexmodule
 
         # If the object parameter has been supplied, it means we are attaching the
         # lexer to a new object.  In this case, we have to rebind all methods in
         # the lexstatere and lexstateerrorf tables.
 
         if object:
-            newtab = { }
+            newtab = {}
             for key, ritem in self.lexstatere.items():
                 newre = []
                 for cre, findex in ritem:
-                     newfindex = []
-                     for f in findex:
-                         if not f or not f[0]:
-                             newfindex.append(f)
-                             continue
-                         newfindex.append((getattr(object,f[0].__name__),f[1]))
-                newre.append((cre,newfindex))
+                    newfindex = []
+                    for f in findex:
+                        if not f or not f[0]:
+                            newfindex.append(f)
+                            continue
+                        newfindex.append((getattr(object, f[0].__name__), f[1]))
+                newre.append((cre, newfindex))
                 newtab[key] = newre
             c.lexstatere = newtab
-            c.lexstateerrorf = { }
+            c.lexstateerrorf = {}
             for key, ef in self.lexstateerrorf.items():
-                c.lexstateerrorf[key] = getattr(object,ef.__name__)
+                c.lexstateerrorf[key] = getattr(object, ef.__name__)
             c.lexmodule = object
 
         # Set up other attributes
@@ -144,64 +159,69 @@
     # writetab() - Write lexer information to a table file
     # ------------------------------------------------------------
     # <tm> 25 June 2008 added 'outputdir'
-    def writetab(self,tabfile,outputdir=''):
-        tf = open(os.path.join(outputdir,tabfile)+".py","w")
-        tf.write("# %s.py. This file automatically created by PLY (version %s). Don't edit!\n" % (tabfile,__version__))
+    def writetab(self, tabfile, outputdir=''):
+        tf = open(os.path.join(outputdir, tabfile) + ".py", "w")
+        tf.write(
+            "# %s.py. This file automatically created by PLY (version %s). Don't edit!\n" %
+            (tabfile, __version__))
         tf.write("_lextokens    = %s\n" % repr(self.lextokens))
         tf.write("_lexreflags   = %s\n" % repr(self.lexreflags))
         tf.write("_lexliterals  = %s\n" % repr(self.lexliterals))
         tf.write("_lexstateinfo = %s\n" % repr(self.lexstateinfo))
-        
-        tabre = { }
+
+        tabre = {}
         for key, lre in self.lexstatere.items():
-             titem = []
-             for i in range(len(lre)):
-                  titem.append((self.lexstateretext[key][i],_funcs_to_names(lre[i][1])))
-             tabre[key] = titem
+            titem = []
+            for i in range(len(lre)):
+                titem.append((self.lexstateretext[key][i], _funcs_to_names(lre[i][1])))
+            tabre[key] = titem
 
         tf.write("_lexstatere   = %s\n" % repr(tabre))
         tf.write("_lexstateignore = %s\n" % repr(self.lexstateignore))
 
-        taberr = { }
+        taberr = {}
         for key, ef in self.lexstateerrorf.items():
-             if ef:
-                  taberr[key] = ef.__name__
-             else:
-                  taberr[key] = None
+            if ef:
+                taberr[key] = ef.__name__
+            else:
+                taberr[key] = None
         tf.write("_lexstateerrorf = %s\n" % repr(taberr))
         tf.close()
 
     # ------------------------------------------------------------
     # readtab() - Read lexer information from a tab file
     # ------------------------------------------------------------
-    def readtab(self,tabfile,fdict):
+    def readtab(self, tabfile, fdict):
         exec "import %s as lextab" % tabfile
-        self.lextokens      = lextab._lextokens
-        self.lexreflags     = lextab._lexreflags
-        self.lexliterals    = lextab._lexliterals
-        self.lexstateinfo   = lextab._lexstateinfo
+        self.lextokens = lextab._lextokens
+        self.lexreflags = lextab._lexreflags
+        self.lexliterals = lextab._lexliterals
+        self.lexstateinfo = lextab._lexstateinfo
         self.lexstateignore = lextab._lexstateignore
-        self.lexstatere     = { }
-        self.lexstateretext = { }
-        for key,lre in lextab._lexstatere.items():
-             titem = []
-             txtitem = []
-             for i in range(len(lre)):
-                  titem.append((re.compile(lre[i][0],lextab._lexreflags),_names_to_funcs(lre[i][1],fdict)))
-                  txtitem.append(lre[i][0])
-             self.lexstatere[key] = titem
-             self.lexstateretext[key] = txtitem
-        self.lexstateerrorf = { }
-        for key,ef in lextab._lexstateerrorf.items():
-             self.lexstateerrorf[key] = fdict[ef]
+        self.lexstatere = {}
+        self.lexstateretext = {}
+        for key, lre in lextab._lexstatere.items():
+            titem = []
+            txtitem = []
+            for i in range(len(lre)):
+                titem.append(
+                    (re.compile(
+                        lre[i][0], lextab._lexreflags), _names_to_funcs(
+                        lre[i][1], fdict)))
+                txtitem.append(lre[i][0])
+            self.lexstatere[key] = titem
+            self.lexstateretext[key] = txtitem
+        self.lexstateerrorf = {}
+        for key, ef in lextab._lexstateerrorf.items():
+            self.lexstateerrorf[key] = fdict[ef]
         self.begin('INITIAL')
-         
+
     # ------------------------------------------------------------
     # input() - Push a new string into the lexer
     # ------------------------------------------------------------
-    def input(self,s):
-        if not (isinstance(s,types.StringType) or isinstance(s,types.UnicodeType)):
-            raise ValueError, "Expected a string"
+    def input(self, s):
+        if not (isinstance(s, types.StringType) or isinstance(s, types.UnicodeType)):
+            raise ValueError("Expected a string")
         self.lexdata = s
         self.lexpos = 0
         self.lexlen = len(s)
@@ -209,19 +229,19 @@
     # ------------------------------------------------------------
     # begin() - Changes the lexing state
     # ------------------------------------------------------------
-    def begin(self,state):
-        if not self.lexstatere.has_key(state):
-            raise ValueError, "Undefined state"
+    def begin(self, state):
+        if state not in self.lexstatere:
+            raise ValueError("Undefined state")
         self.lexre = self.lexstatere[state]
         self.lexretext = self.lexstateretext[state]
-        self.lexignore = self.lexstateignore.get(state,"")
-        self.lexerrorf = self.lexstateerrorf.get(state,None)
+        self.lexignore = self.lexstateignore.get(state, "")
+        self.lexerrorf = self.lexstateerrorf.get(state, None)
         self.lexstate = state
 
     # ------------------------------------------------------------
     # push_state() - Changes the lexing state and saves old on stack
     # ------------------------------------------------------------
-    def push_state(self,state):
+    def push_state(self, state):
         self.lexstatestack.append(self.lexstate)
         self.begin(state)
 
@@ -240,7 +260,7 @@
     # ------------------------------------------------------------
     # skip() - Skip ahead n characters
     # ------------------------------------------------------------
-    def skip(self,n):
+    def skip(self, n):
         self.lexpos += n
 
     # ------------------------------------------------------------
@@ -252,21 +272,23 @@
     # ------------------------------------------------------------
     def token(self):
         # Make local copies of frequently referenced attributes
-        lexpos    = self.lexpos
-        lexlen    = self.lexlen
+        lexpos = self.lexpos
+        lexlen = self.lexlen
         lexignore = self.lexignore
-        lexdata   = self.lexdata
+        lexdata = self.lexdata
 
         while lexpos < lexlen:
-            # This code provides some short-circuit code for whitespace, tabs, and other ignored characters
+            # This code provides some short-circuit code for whitespace, tabs, and
+            # other ignored characters
             if lexdata[lexpos] in lexignore:
                 lexpos += 1
                 continue
 
             # Look for a regular expression match
-            for lexre,lexindexfunc in self.lexre:
-                m = lexre.match(lexdata,lexpos)
-                if not m: continue
+            for lexre, lexindexfunc in self.lexre:
+                m = lexre.match(lexdata, lexpos)
+                if not m:
+                    continue
 
                 # Set last match in lexer so that rules can access it if they want
                 self.lexmatch = m
@@ -281,39 +303,40 @@
 
                 lexpos = m.end()
                 i = m.lastindex
-                func,tok.type = lexindexfunc[i]
+                func, tok.type = lexindexfunc[i]
                 self.lexpos = lexpos
 
                 if not func:
-                   # If no token type was set, it's an ignored token
-                   if tok.type: return tok      
-                   break
+                    # If no token type was set, it's an ignored token
+                    if tok.type:
+                        return tok
+                    break
 
-                # if func not callable, it means it's an ignored token                
+                # if func not callable, it means it's an ignored token
                 if not callable(func):
-                   break 
+                    break
 
                 # If token is processed by a function, call it
                 newtok = func(tok)
-                
+
                 # Every function must return a token, if nothing, we just move to next token
-                if not newtok: 
+                if not newtok:
                     lexpos = self.lexpos        # This is here in case user has updated lexpos.
-                    
+
                     # Added for pyglet/tools/wrapper/cparser.py by Alex
-                    # Holkner on 20/Jan/2007 
+                    # Holkner on 20/Jan/2007
                     lexdata = self.lexdata
                     break
-                
+
                 # Verify type of the token.  If not in the token map, raise an error
                 if not self.lexoptimize:
                     # Allow any single-character literal also for
                     # pyglet/tools/wrapper/cparser.py by Alex Holkner on
-                    # 20/Jan/2007 
-                    if not self.lextokens.has_key(newtok.type) and len(newtok.type) > 1:
-                        raise LexError, ("%s:%d: Rule '%s' returned an unknown token type '%s'" % (
+                    # 20/Jan/2007
+                    if newtok.type not in self.lextokens and len(newtok.type) > 1:
+                        raise LexError("%s:%d: Rule '%s' returned an unknown token type '%s'" % (
                             func.func_code.co_filename, func.func_code.co_firstlineno,
-                            func.__name__, newtok.type),lexdata[lexpos:])
+                            func.__name__, newtok.type), lexdata[lexpos:])
 
                 return newtok
             else:
@@ -327,7 +350,7 @@
                     tok.lexpos = lexpos
                     self.lexpos = lexpos + 1
                     return tok
-        
+
                 # No match. Call t_error() if defined.
                 if self.lexerrorf:
                     tok = LexToken()
@@ -340,19 +363,26 @@
                     newtok = self.lexerrorf(tok)
                     if lexpos == self.lexpos:
                         # Error method didn't change text position at all. This is an error.
-                        raise LexError, ("Scanning error. Illegal character '%s'" % (lexdata[lexpos]), lexdata[lexpos:])
+                        raise LexError(
+                            "Scanning error. Illegal character '%s'" %
+                            (lexdata[lexpos]), lexdata[
+                                lexpos:])
                     lexpos = self.lexpos
-                    if not newtok: continue
+                    if not newtok:
+                        continue
                     return newtok
 
                 self.lexpos = lexpos
-                raise LexError, ("Illegal character '%s' at index %d" % (lexdata[lexpos],lexpos), lexdata[lexpos:])
+                raise LexError(
+                    "Illegal character '%s' at index %d" %
+                    (lexdata[lexpos], lexpos), lexdata[
+                        lexpos:])
 
         self.lexpos = lexpos + 1
         if self.lexdata is None:
-             raise RuntimeError, "No input string given with input()"
+            raise RuntimeError("No input string given with input()")
         return None
-        
+
 # -----------------------------------------------------------------------------
 # _validate_file()
 #
@@ -361,10 +391,12 @@
 # match on each line in the filename.
 # -----------------------------------------------------------------------------
 
+
 def _validate_file(filename):
     import os.path
-    base,ext = os.path.splitext(filename)
-    if ext != '.py': return 1        # No idea what the file is. Return OK
+    base, ext = os.path.splitext(filename)
+    if ext != '.py':
+        return 1        # No idea what the file is. Return OK
 
     try:
         f = open(filename)
@@ -375,7 +407,7 @@
 
     fre = re.compile(r'\s*def\s+(t_[a-zA-Z_0-9]*)\(')
     sre = re.compile(r'\s*(t_[a-zA-Z_0-9]*)\s*=')
-    counthash = { }
+    counthash = {}
     linen = 1
     noerror = 1
     for l in lines:
@@ -388,7 +420,7 @@
             if not prev:
                 counthash[name] = linen
             else:
-                print "%s:%d: Rule %s redefined. Previously defined on line %d" % (filename,linen,name,prev)
+                print "%s:%d: Rule %s redefined. Previously defined on line %d" % (filename, linen, name, prev)
                 noerror = 0
         linen += 1
     return noerror
@@ -400,13 +432,14 @@
 # suitable for output to a table file
 # -----------------------------------------------------------------------------
 
+
 def _funcs_to_names(funclist):
     result = []
     for f in funclist:
-         if f and f[0]:
-             result.append((f[0].__name__,f[1]))
-         else:
-             result.append(f)
+        if f and f[0]:
+            result.append((f[0].__name__, f[1]))
+        else:
+            result.append(f)
     return result
 
 # -----------------------------------------------------------------------------
@@ -416,15 +449,16 @@
 # functions.
 # -----------------------------------------------------------------------------
 
-def _names_to_funcs(namelist,fdict):
-     result = []
-     for n in namelist:
-          if n and n[0]:
-              result.append((fdict[n[0]],n[1]))
-          else:
-              result.append(n)
-     return result
 
+def _names_to_funcs(namelist, fdict):
+    result = []
+    for n in namelist:
+        if n and n[0]:
+            result.append((fdict[n[0]], n[1]))
+        else:
+            result.append(n)
+    return result
+
 # -----------------------------------------------------------------------------
 # _form_master_re()
 #
@@ -433,34 +467,37 @@
 # module, it may be necessary to break the master regex into separate expressions.
 # -----------------------------------------------------------------------------
 
-def _form_master_re(relist,reflags,ldict):
-    if not relist: return []
+
+def _form_master_re(relist, reflags, ldict):
+    if not relist:
+        return []
     regex = "|".join(relist)
     try:
-        lexre = re.compile(regex,re.VERBOSE | reflags)
+        lexre = re.compile(regex, re.VERBOSE | reflags)
 
         # Build the index to function map for the matching engine
-        lexindexfunc = [ None ] * (max(lexre.groupindex.values())+1)
-        for f,i in lexre.groupindex.items():
-            handle = ldict.get(f,None)
+        lexindexfunc = [None] * (max(lexre.groupindex.values()) + 1)
+        for f, i in lexre.groupindex.items():
+            handle = ldict.get(f, None)
             if type(handle) in (types.FunctionType, types.MethodType):
-                lexindexfunc[i] = (handle,handle.__name__[2:])
+                lexindexfunc[i] = (handle, handle.__name__[2:])
             elif handle is not None:
                 # If rule was specified as a string, we build an anonymous
                 # callback function to carry out the action
                 if f.find("ignore_") > 0:
-                    lexindexfunc[i] = (None,None)
+                    lexindexfunc[i] = (None, None)
                     print "IGNORE", f
                 else:
                     lexindexfunc[i] = (None, f[2:])
-         
-        return [(lexre,lexindexfunc)],[regex]
+
+        return [(lexre, lexindexfunc)], [regex]
     except Exception as e:
-        m = int(len(relist)/2)
-        if m == 0: m = 1
-        llist, lre = _form_master_re(relist[:m],reflags,ldict)
-        rlist, rre = _form_master_re(relist[m:],reflags,ldict)
-        return llist+rlist, lre+rre
+        m = int(len(relist) / 2)
+        if m == 0:
+            m = 1
+        llist, lre = _form_master_re(relist[:m], reflags, ldict)
+        rlist, rre = _form_master_re(relist[m:], reflags, ldict)
+        return llist + rlist, lre + rre
 
 # -----------------------------------------------------------------------------
 # def _statetoken(s,names)
@@ -471,190 +508,202 @@
 # calling this with s = "t_foo_bar_SPAM" might return (('foo','bar'),'SPAM')
 # -----------------------------------------------------------------------------
 
-def _statetoken(s,names):
+
+def _statetoken(s, names):
     nonstate = 1
     parts = s.split("_")
-    for i in range(1,len(parts)):
-        if not names.has_key(parts[i]) and parts[i] != 'ANY': break
+    for i in range(1, len(parts)):
+        if parts[i] not in names and parts[i] != 'ANY':
+            break
     if i > 1:
-       states = tuple(parts[1:i])
+        states = tuple(parts[1:i])
     else:
-       states = ('INITIAL',)
+        states = ('INITIAL',)
 
     if 'ANY' in states:
-       states = tuple(names.keys())
-      
+        states = tuple(names.keys())
+
     tokenname = "_".join(parts[i:])
-    return (states,tokenname)
+    return (states, tokenname)
 
 # -----------------------------------------------------------------------------
 # lex(module)
 #
 # Build all of the regular expression rules from definitions in the supplied module
 # -----------------------------------------------------------------------------
-# cls added for pyglet/tools/wrapper/cparser.py by Alex Holkner on 22/Jan/2007 
+# cls added for pyglet/tools/wrapper/cparser.py by Alex Holkner on 22/Jan/2007
 # <tm> 25 June 2008 added 'outputdir'
-def lex(module=None,object=None,debug=0,optimize=0,lextab="lextab",reflags=0,nowarn=0,outputdir='',cls=Lexer):
+
+
+def lex(module=None, object=None, debug=0, optimize=0,
+        lextab="lextab", reflags=0, nowarn=0, outputdir='', cls=Lexer):
     global lexer
     ldict = None
-    stateinfo  = { 'INITIAL' : 'inclusive'}
+    stateinfo = {'INITIAL': 'inclusive'}
     error = 0
-    files = { }
+    files = {}
     lexobj = cls()
     lexobj.lexdebug = debug
     lexobj.lexoptimize = optimize
-    global token,input
+    global token, input
 
-    if nowarn: warn = 0
-    else: warn = 1
-    
-    if object: module = object
+    if nowarn:
+        warn = 0
+    else:
+        warn = 1
 
+    if object:
+        module = object
+
     if module:
         # User supplied a module object.
         if isinstance(module, types.ModuleType):
             ldict = module.__dict__
         elif isinstance(module, _INSTANCETYPE):
-            _items = [(k,getattr(module,k)) for k in dir(module)]
-            ldict = { }
-            for (i,v) in _items:
+            _items = [(k, getattr(module, k)) for k in dir(module)]
+            ldict = {}
+            for (i, v) in _items:
                 ldict[i] = v
         else:
-            raise ValueError,"Expected a module or instance"
+            raise ValueError("Expected a module or instance")
         lexobj.lexmodule = module
-        
+
     else:
         # No module given.  We might be able to get information from the caller.
         try:
             raise RuntimeError
         except RuntimeError:
-            e,b,t = sys.exc_info()
+            e, b, t = sys.exc_info()
             f = t.tb_frame
             f = f.f_back           # Walk out to our calling function
             ldict = f.f_globals    # Grab its globals dictionary
 
     if optimize and lextab:
         try:
-            lexobj.readtab(lextab,ldict)
+            lexobj.readtab(lextab, ldict)
             token = lexobj.token
             input = lexobj.input
             lexer = lexobj
             return lexobj
-        
+
         except ImportError:
             pass
-        
+
     # Get the tokens, states, and literals variables (if any)
-    if (module and isinstance(module,_INSTANCETYPE)):
-        tokens   = getattr(module,"tokens",None)
-        states   = getattr(module,"states",None)
-        literals = getattr(module,"literals","")
+    if (module and isinstance(module, _INSTANCETYPE)):
+        tokens = getattr(module, "tokens", None)
+        states = getattr(module, "states", None)
+        literals = getattr(module, "literals", "")
     else:
-        tokens   = ldict.get("tokens",None)
-        states   = ldict.get("states",None)
-        literals = ldict.get("literals","")
-        
+        tokens = ldict.get("tokens", None)
+        states = ldict.get("states", None)
+        literals = ldict.get("literals", "")
+
     if not tokens:
-        raise SyntaxError,"lex: module does not define 'tokens'"
-    if not (isinstance(tokens,types.ListType) or isinstance(tokens,types.TupleType)):
-        raise SyntaxError,"lex: tokens must be a list or tuple."
+        raise SyntaxError("lex: module does not define 'tokens'")
+    if not (isinstance(tokens, types.ListType) or isinstance(tokens, types.TupleType)):
+        raise SyntaxError("lex: tokens must be a list or tuple.")
 
     # Build a dictionary of valid token names
-    lexobj.lextokens = { }
+    lexobj.lextokens = {}
     if not optimize:
         for n in tokens:
             if not _is_identifier.match(n):
                 print "lex: Bad token name '%s'" % n
                 error = 1
-            if warn and lexobj.lextokens.has_key(n):
+            if warn and n in lexobj.lextokens:
                 print "lex: Warning. Token '%s' multiply defined." % n
             lexobj.lextokens[n] = None
     else:
-        for n in tokens: lexobj.lextokens[n] = None
+        for n in tokens:
+            lexobj.lextokens[n] = None
 
     if debug:
         print "lex: tokens = '%s'" % lexobj.lextokens.keys()
 
     try:
-         for c in literals:
-               if not (isinstance(c,types.StringType) or isinstance(c,types.UnicodeType)) or len(c) > 1:
-                    print "lex: Invalid literal %s. Must be a single character" % repr(c)
-                    error = 1
-                    continue
+        for c in literals:
+            if not (isinstance(c, types.StringType) or isinstance(
+                    c, types.UnicodeType)) or len(c) > 1:
+                print "lex: Invalid literal %s. Must be a single character" % repr(c)
+                error = 1
+                continue
 
     except TypeError:
-         print "lex: Invalid literals specification. literals must be a sequence of characters."
-         error = 1
+        print "lex: Invalid literals specification. literals must be a sequence of characters."
+        error = 1
 
     lexobj.lexliterals = literals
 
     # Build statemap
     if states:
-         if not (isinstance(states,types.TupleType) or isinstance(states,types.ListType)):
-              print "lex: states must be defined as a tuple or list."
-              error = 1
-         else:
-              for s in states:
-                    if not isinstance(s,types.TupleType) or len(s) != 2:
-                           print "lex: invalid state specifier %s. Must be a tuple (statename,'exclusive|inclusive')" % repr(s)
-                           error = 1
-                           continue
-                    name, statetype = s
-                    if not isinstance(name,types.StringType):
-                           print "lex: state name %s must be a string" % repr(name)
-                           error = 1
-                           continue
-                    if not (statetype == 'inclusive' or statetype == 'exclusive'):
-                           print "lex: state type for state %s must be 'inclusive' or 'exclusive'" % name
-                           error = 1
-                           continue
-                    if stateinfo.has_key(name):
-                           print "lex: state '%s' already defined." % name
-                           error = 1
-                           continue
-                    stateinfo[name] = statetype
+        if not (isinstance(states, types.TupleType) or isinstance(states, types.ListType)):
+            print "lex: states must be defined as a tuple or list."
+            error = 1
+        else:
+            for s in states:
+                if not isinstance(s, types.TupleType) or len(s) != 2:
+                    print "lex: invalid state specifier %s. Must be a tuple (statename,'exclusive|inclusive')" % repr(s)
+                    error = 1
+                    continue
+                name, statetype = s
+                if not isinstance(name, types.StringType):
+                    print "lex: state name %s must be a string" % repr(name)
+                    error = 1
+                    continue
+                if not (statetype == 'inclusive' or statetype == 'exclusive'):
+                    print "lex: state type for state %s must be 'inclusive' or 'exclusive'" % name
+                    error = 1
+                    continue
+                if name in stateinfo:
+                    print "lex: state '%s' already defined." % name
+                    error = 1
+                    continue
+                stateinfo[name] = statetype
 
     # Get a list of symbols with the t_ or s_ prefix
-    tsymbols = [f for f in ldict.keys() if f[:2] == 't_' ]
+    tsymbols = [f for f in ldict.keys() if f[:2] == 't_']
 
     # Now build up a list of functions and a list of strings
 
-    funcsym =  { }        # Symbols defined as functions
-    strsym =   { }        # Symbols defined as strings
-    toknames = { }        # Mapping of symbols to token names
+    funcsym = {}        # Symbols defined as functions
+    strsym = {}        # Symbols defined as strings
+    toknames = {}        # Mapping of symbols to token names
 
     for s in stateinfo.keys():
-         funcsym[s] = []
-         strsym[s] = []
+        funcsym[s] = []
+        strsym[s] = []
 
-    ignore   = { }        # Ignore strings by state
-    errorf   = { }        # Error functions by state
+    ignore = {}        # Ignore strings by state
+    errorf = {}        # Error functions by state
 
     if len(tsymbols) == 0:
-        raise SyntaxError,"lex: no rules of the form t_rulename are defined."
+        raise SyntaxError("lex: no rules of the form t_rulename are defined.")
 
     for f in tsymbols:
         t = ldict[f]
-        states, tokname = _statetoken(f,stateinfo)
+        states, tokname = _statetoken(f, stateinfo)
         toknames[f] = tokname
 
         if callable(t):
-            for s in states: funcsym[s].append((f,t))
-        elif (isinstance(t, types.StringType) or isinstance(t,types.UnicodeType)):
-            for s in states: strsym[s].append((f,t))
+            for s in states:
+                funcsym[s].append((f, t))
+        elif (isinstance(t, types.StringType) or isinstance(t, types.UnicodeType)):
+            for s in states:
+                strsym[s].append((f, t))
         else:
             print "lex: %s not defined as a function or string" % f
             error = 1
 
     # Sort the functions by line number
     for f in funcsym.values():
-        f.sort(lambda x,y: cmp(x[1].func_code.co_firstlineno,y[1].func_code.co_firstlineno))
+        f.sort(lambda x, y: cmp(x[1].func_code.co_firstlineno, y[1].func_code.co_firstlineno))
 
     # Sort the strings by regular expression length
     for s in strsym.values():
-        s.sort(lambda x,y: (len(x[1]) < len(y[1])) - (len(x[1]) > len(y[1])))
+        s.sort(lambda x, y: (len(x[1]) < len(y[1])) - (len(x[1]) > len(y[1])))
 
-    regexs = { }
+    regexs = {}
 
     # Build the master regular expressions
     for state in stateinfo.keys():
@@ -676,20 +725,20 @@
                 else:
                     reqargs = 1
                 if nargs > reqargs:
-                    print "%s:%d: Rule '%s' has too many arguments." % (file,line,f.__name__)
+                    print "%s:%d: Rule '%s' has too many arguments." % (file, line, f.__name__)
                     error = 1
                     continue
 
                 if nargs < reqargs:
-                    print "%s:%d: Rule '%s' requires an argument." % (file,line,f.__name__)
+                    print "%s:%d: Rule '%s' requires an argument." % (file, line, f.__name__)
                     error = 1
                     continue
 
                 if tokname == 'ignore':
-                    print "%s:%d: Rule '%s' must be defined as a string." % (file,line,f.__name__)
+                    print "%s:%d: Rule '%s' must be defined as a string." % (file, line, f.__name__)
                     error = 1
                     continue
-        
+
             if tokname == 'error':
                 errorf[state] = f
                 continue
@@ -697,78 +746,77 @@
             if f.__doc__:
                 if not optimize:
                     try:
-                        c = re.compile("(?P<%s>%s)" % (f.__name__,f.__doc__), re.VERBOSE | reflags)
+                        c = re.compile("(?P<%s>%s)" % (f.__name__, f.__doc__), re.VERBOSE | reflags)
                         if c.match(""):
-                             print "%s:%d: Regular expression for rule '%s' matches empty string." % (file,line,f.__name__)
-                             error = 1
-                             continue
+                            print "%s:%d: Regular expression for rule '%s' matches empty string." % (file, line, f.__name__)
+                            error = 1
+                            continue
                     except re.error as e:
-                        print "%s:%d: Invalid regular expression for rule '%s'. %s" % (file,line,f.__name__,e)
+                        print "%s:%d: Invalid regular expression for rule '%s'. %s" % (file, line, f.__name__, e)
                         if '#' in f.__doc__:
-                             print "%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'." % (file,line, f.__name__)                 
+                            print "%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'." % (file, line, f.__name__)
                         error = 1
                         continue
 
                     if debug:
-                        print "lex: Adding rule %s -> '%s' (state '%s')" % (f.__name__,f.__doc__, state)
+                        print "lex: Adding rule %s -> '%s' (state '%s')" % (f.__name__, f.__doc__, state)
 
                 # Okay. The regular expression seemed okay.  Let's append it to the master regular
                 # expression we're building
-  
-                regex_list.append("(?P<%s>%s)" % (f.__name__,f.__doc__))
+
+                regex_list.append("(?P<%s>%s)" % (f.__name__, f.__doc__))
             else:
-                print "%s:%d: No regular expression defined for rule '%s'" % (file,line,f.__name__)
+                print "%s:%d: No regular expression defined for rule '%s'" % (file, line, f.__name__)
 
         # Now add all of the simple rules
-        for name,r in strsym[state]:
-            tokname = toknames[name]       
+        for name, r in strsym[state]:
+            tokname = toknames[name]
 
             if tokname == 'ignore':
-                 ignore[state] = r
-                 continue
+                ignore[state] = r
+                continue
 
             if not optimize:
                 if tokname == 'error':
-                    raise SyntaxError,"lex: Rule '%s' must be defined as a function" % name
+                    raise SyntaxError("lex: Rule '%s' must be defined as a function" % name)
                     error = 1
                     continue
-        
-                if not lexobj.lextokens.has_key(tokname) and tokname.find("ignore_") < 0:
-                    print "lex: Rule '%s' defined for an unspecified token %s." % (name,tokname)
+
+                if tokname not in lexobj.lextokens and tokname.find("ignore_") < 0:
+                    print "lex: Rule '%s' defined for an unspecified token %s." % (name, tokname)
                     error = 1
                     continue
                 try:
-                    c = re.compile("(?P<%s>%s)" % (name,r),re.VERBOSE | reflags)
+                    c = re.compile("(?P<%s>%s)" % (name, r), re.VERBOSE | reflags)
                     if (c.match("")):
-                         print "lex: Regular expression for rule '%s' matches empty string." % name
-                         error = 1
-                         continue
+                        print "lex: Regular expression for rule '%s' matches empty string." % name
+                        error = 1
+                        continue
                 except re.error as e:
-                    print "lex: Invalid regular expression for rule '%s'. %s" % (name,e)
+                    print "lex: Invalid regular expression for rule '%s'. %s" % (name, e)
                     if '#' in r:
-                         print "lex: Make sure '#' in rule '%s' is escaped with '\\#'." % name
+                        print "lex: Make sure '#' in rule '%s' is escaped with '\\#'." % name
 
                     error = 1
                     continue
                 if debug:
-                    print "lex: Adding rule %s -> '%s' (state '%s')" % (name,r,state)
-                
-            regex_list.append("(?P<%s>%s)" % (name,r))
+                    print "lex: Adding rule %s -> '%s' (state '%s')" % (name, r, state)
 
+            regex_list.append("(?P<%s>%s)" % (name, r))
+
         if not regex_list:
-             print "lex: No rules defined for state '%s'" % state
-             error = 1
+            print "lex: No rules defined for state '%s'" % state
+            error = 1
 
         regexs[state] = regex_list
 
-
     if not optimize:
-        for f in files.keys(): 
-           if not _validate_file(f):
+        for f in files.keys():
+            if not _validate_file(f):
                 error = 1
 
     if error:
-        raise SyntaxError,"lex: Unable to build lexer."
+        raise SyntaxError("lex: Unable to build lexer.")
 
     # From this point forward, we're reasonably confident that we can build the lexer.
     # No more errors will be generated, but there might be some warning messages.
@@ -776,18 +824,18 @@
     # Build the master regular expressions
 
     for state in regexs.keys():
-        lexre, re_text = _form_master_re(regexs[state],reflags,ldict)
+        lexre, re_text = _form_master_re(regexs[state], reflags, ldict)
         lexobj.lexstatere[state] = lexre
         lexobj.lexstateretext[state] = re_text
         if debug:
             for i in range(len(re_text)):
-                 print "lex: state '%s'. regex[%d] = '%s'" % (state, i, re_text[i])
+                print "lex: state '%s'. regex[%d] = '%s'" % (state, i, re_text[i])
 
     # For inclusive states, we need to add the INITIAL state
-    for state,type in stateinfo.items():
+    for state, type in stateinfo.items():
         if state != "INITIAL" and type == 'inclusive':
-             lexobj.lexstatere[state].extend(lexobj.lexstatere['INITIAL'])
-             lexobj.lexstateretext[state].extend(lexobj.lexstateretext['INITIAL'])
+            lexobj.lexstatere[state].extend(lexobj.lexstatere['INITIAL'])
+            lexobj.lexstateretext[state].extend(lexobj.lexstateretext['INITIAL'])
 
     lexobj.lexstateinfo = stateinfo
     lexobj.lexre = lexobj.lexstatere["INITIAL"]
@@ -795,36 +843,35 @@
 
     # Set up ignore variables
     lexobj.lexstateignore = ignore
-    lexobj.lexignore = lexobj.lexstateignore.get("INITIAL","")
+    lexobj.lexignore = lexobj.lexstateignore.get("INITIAL", "")
 
     # Set up error functions
     lexobj.lexstateerrorf = errorf
-    lexobj.lexerrorf = errorf.get("INITIAL",None)
+    lexobj.lexerrorf = errorf.get("INITIAL", None)
     if warn and not lexobj.lexerrorf:
         print "lex: Warning. no t_error rule is defined."
 
     # Check state information for ignore and error rules
-    for s,stype in stateinfo.items():
+    for s, stype in stateinfo.items():
         if stype == 'exclusive':
-              if warn and not errorf.has_key(s):
-                   print "lex: Warning. no error rule is defined for exclusive state '%s'" % s
-              if warn and not ignore.has_key(s) and lexobj.lexignore:
-                   print "lex: Warning. no ignore rule is defined for exclusive state '%s'" % s
+            if warn and s not in errorf:
+                print "lex: Warning. no error rule is defined for exclusive state '%s'" % s
+            if warn and s not in ignore and lexobj.lexignore:
+                print "lex: Warning. no ignore rule is defined for exclusive state '%s'" % s
         elif stype == 'inclusive':
-              if not errorf.has_key(s):
-                   errorf[s] = errorf.get("INITIAL",None)
-              if not ignore.has_key(s):
-                   ignore[s] = ignore.get("INITIAL","")
-   
+            if s not in errorf:
+                errorf[s] = errorf.get("INITIAL", None)
+            if s not in ignore:
+                ignore[s] = ignore.get("INITIAL", "")
 
     # Create global versions of the token() and input() functions
     token = lexobj.token
     input = lexobj.input
     lexer = lexobj
 
-    # If in optimize mode, we write the lextab   
+    # If in optimize mode, we write the lextab
     if lextab and optimize:
-        lexobj.writetab(lextab,outputdir)
+        lexobj.writetab(lextab, outputdir)
 
     return lexobj
 
@@ -834,7 +881,8 @@
 # This runs the lexer as a main program
 # -----------------------------------------------------------------------------
 
-def runmain(lexer=None,data=None):
+
+def runmain(lexer=None, data=None):
     if not data:
         try:
             filename = sys.argv[1]
@@ -854,13 +902,14 @@
         _token = lexer.token
     else:
         _token = token
-        
-    while 1:
+
+    while True:
         tok = _token()
-        if not tok: break
-        print "(%s,%r,%d,%d)" % (tok.type, tok.value, tok.lineno,tok.lexpos)
-        
+        if not tok:
+            break
+        print "(%s,%r,%d,%d)" % (tok.type, tok.value, tok.lineno, tok.lexpos)
 
+
 # -----------------------------------------------------------------------------
 # @TOKEN(regex)
 #
@@ -876,4 +925,3 @@
 
 # Alternative spelling of the TOKEN decorator
 Token = TOKEN
-

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/lextab.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/lextab.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/lextab.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -1,8 +1,59 @@
 # lextab.py. This file automatically created by PLY (version 2.2). Don't edit!
-_lextokens    = {'RIGHT_OP': None, 'RIGHT_ASSIGN': None, 'DEC_OP': None, 'PP_MACRO_PARAM': None, 'DIV_ASSIGN': None, 'PP_DEFINE': None, 'PP_END_DEFINE': None, 'PP_DEFINE_MACRO_NAME': None, 'HEADER_NAME': None, 'NEWLINE': None, 'CHARACTER_CONSTANT': None, 'PP_STRINGIFY': None, 'AND_ASSIGN': None, 'PTR_OP': None, 'ELLIPSIS': None, 'IDENTIFIER': None, 'ADD_ASSIGN': None, 'PERIOD': None, 'AND_OP': None, 'OTHER': None, 'LPAREN': None, 'LEFT_OP': None, 'LE_OP': None, 'OR_OP': None, 'SUB_ASSIGN': None, 'MOD_ASSIGN': None, 'STRING_LITERAL': None, 'PP_IDENTIFIER_PASTE': None, 'PP_NUMBER': None, 'PP_DEFINE_NAME': None, 'XOR_ASSIGN': None, 'OR_ASSIGN': None, 'GE_OP': None, 'MUL_ASSIGN': None, 'LEFT_ASSIGN': None, 'INC_OP': None, 'NE_OP': None, 'EQ_OP': None}
-_lexreflags   = 0
-_lexliterals  = ''
+_lextokens = {
+    'RIGHT_OP': None,
+    'RIGHT_ASSIGN': None,
+    'DEC_OP': None,
+    'PP_MACRO_PARAM': None,
+    'DIV_ASSIGN': None,
+    'PP_DEFINE': None,
+    'PP_END_DEFINE': None,
+    'PP_DEFINE_MACRO_NAME': None,
+    'HEADER_NAME': None,
+    'NEWLINE': None,
+    'CHARACTER_CONSTANT': None,
+    'PP_STRINGIFY': None,
+    'AND_ASSIGN': None,
+    'PTR_OP': None,
+    'ELLIPSIS': None,
+    'IDENTIFIER': None,
+    'ADD_ASSIGN': None,
+    'PERIOD': None,
+    'AND_OP': None,
+    'OTHER': None,
+    'LPAREN': None,
+    'LEFT_OP': None,
+    'LE_OP': None,
+    'OR_OP': None,
+    'SUB_ASSIGN': None,
+    'MOD_ASSIGN': None,
+    'STRING_LITERAL': None,
+    'PP_IDENTIFIER_PASTE': None,
+    'PP_NUMBER': None,
+    'PP_DEFINE_NAME': None,
+    'XOR_ASSIGN': None,
+    'OR_ASSIGN': None,
+    'GE_OP': None,
+    'MUL_ASSIGN': None,
+    'LEFT_ASSIGN': None,
+    'INC_OP': None,
+    'NE_OP': None,
+    'EQ_OP': None}
+_lexreflags = 0
+_lexliterals = ''
 _lexstateinfo = {'INITIAL': 'inclusive', 'DEFINE': 'exclusive'}
-_lexstatere   = {'INITIAL': [('(?P<t_ANY_directive>\\#\\s+(\\d+)\\s+"([^"]+)"[ \\d]*\\n)|(?P<t_ANY_punctuator>(\\.\\.\\.|\\|\\||\\+\\+|\\*=|\\^=|<<=|>>=|\\|=|\\+=|>=|>>|<<|<=|<:|%=|:>|<%|!=|\\)|\\+|\\*|\\.|\\?|==|&=|&&|\\[|\\^|--|/=|%>|-=|->|\\||!|%|&|-|,|/|;|:|=|>|]|<|{|}|~))', [None, ('t_ANY_directive', 'ANY_directive'), None, None, ('t_ANY_punctuator', 'ANY_punctuator')]), ('(?P<t_INITIAL_identifier>[a-zA-Z_]([a-zA-Z_]|[0-9])*)', [None, ('t_INITIAL_identifier', 'INITIAL_identifier')]), ('(?P<t_ANY_float>(?P<p1>[0-9]+)?(?P<dp>[.]?)(?P<p2>(?(p1)[0-9]*|[0-9]+))(?P<exp>(?:[Ee][+-]?[0-9]+)?)(?P<suf>[FflL]?)(?!\\w))', [None, ('t_ANY_float', 'ANY_float'), None, None, None, None, None]), ('(?P<t_ANY_int>(?P<p1>(?:0x[a-fA-F0-9]+)|(?:[0-9]+))(?P<suf>[uUlL]*))', [None, ('t_ANY_int', 'ANY_int'), None, None]), ('(?P<t_ANY_character_constant>L?\'(\\\\.|[^\\\\\'])+\')|(?P<t_ANY_string_literal>L?"(\\\\.|[^\\\\"])*")|(?P<t_ANY_lparen>\\()|(?P<t_INITIAL_newline>\\n)|(?P<t_INITIAL_pp_define>\\#defi
 ne)', [None, ('t_ANY_character_constant', 'ANY_character_constant'), None, ('t_ANY_string_literal', 'ANY_string_literal'), None, ('t_ANY_lparen', 'ANY_lparen'), ('t_INITIAL_newline', 'INITIAL_newline'), ('t_INITIAL_pp_define', 'INITIAL_pp_define')])], 'DEFINE': [('(?P<t_ANY_directive>\\#\\s+(\\d+)\\s+"([^"]+)"[ \\d]*\\n)|(?P<t_ANY_punctuator>(\\.\\.\\.|\\|\\||\\+\\+|\\*=|\\^=|<<=|>>=|\\|=|\\+=|>=|>>|<<|<=|<:|%=|:>|<%|!=|\\)|\\+|\\*|\\.|\\?|==|&=|&&|\\[|\\^|--|/=|%>|-=|->|\\||!|%|&|-|,|/|;|:|=|>|]|<|{|}|~))', [None, ('t_ANY_directive', 'ANY_directive'), None, None, ('t_ANY_punctuator', 'ANY_punctuator')]), ('(?P<t_DEFINE_identifier>[a-zA-Z_]([a-zA-Z_]|[0-9])*)', [None, ('t_DEFINE_identifier', 'DEFINE_identifier')]), ('(?P<t_ANY_float>(?P<p1>[0-9]+)?(?P<dp>[.]?)(?P<p2>(?(p1)[0-9]*|[0-9]+))(?P<exp>(?:[Ee][+-]?[0-9]+)?)(?P<suf>[FflL]?)(?!\\w))', [None, ('t_ANY_float', 'ANY_float'), None, None, None, None, None]), ('(?P<t_ANY_int>(?P<p1>(?:0x[a-fA-F0-9]+)|(?:[0-9]+))(?P<suf>[uUlL]*))', [
 None, ('t_ANY_int', 'ANY_int'), None, None]), ('(?P<t_ANY_character_constant>L?\'(\\\\.|[^\\\\\'])+\')|(?P<t_ANY_string_literal>L?"(\\\\.|[^\\\\"])*")|(?P<t_ANY_lparen>\\()|(?P<t_DEFINE_newline>\\n)|(?P<t_DEFINE_pp_param_op>(\\#\\#)|(\\#))', [None, ('t_ANY_character_constant', 'ANY_character_constant'), None, ('t_ANY_string_literal', 'ANY_string_literal'), None, ('t_ANY_lparen', 'ANY_lparen'), ('t_DEFINE_newline', 'DEFINE_newline'), ('t_DEFINE_pp_param_op', 'DEFINE_pp_param_op')])]}
+_lexstatere = {
+    'INITIAL': [
+        ('(?P<t_ANY_directive>\\#\\s+(\\d+)\\s+"([^"]+)"[ \\d]*\\n)|(?P<t_ANY_punctuator>(\\.\\.\\.|\\|\\||\\+\\+|\\*=|\\^=|<<=|>>=|\\|=|\\+=|>=|>>|<<|<=|<:|%=|:>|<%|!=|\\)|\\+|\\*|\\.|\\?|==|&=|&&|\\[|\\^|--|/=|%>|-=|->|\\||!|%|&|-|,|/|;|:|=|>|]|<|{|}|~))', [
+            None, ('t_ANY_directive', 'ANY_directive'), None, None, ('t_ANY_punctuator', 'ANY_punctuator')]), ('(?P<t_INITIAL_identifier>[a-zA-Z_]([a-zA-Z_]|[0-9])*)', [
+                None, ('t_INITIAL_identifier', 'INITIAL_identifier')]), ('(?P<t_ANY_float>(?P<p1>[0-9]+)?(?P<dp>[.]?)(?P<p2>(?(p1)[0-9]*|[0-9]+))(?P<exp>(?:[Ee][+-]?[0-9]+)?)(?P<suf>[FflL]?)(?!\\w))', [
+                    None, ('t_ANY_float', 'ANY_float'), None, None, None, None, None]), ('(?P<t_ANY_int>(?P<p1>(?:0x[a-fA-F0-9]+)|(?:[0-9]+))(?P<suf>[uUlL]*))', [
+                        None, ('t_ANY_int', 'ANY_int'), None, None]), ('(?P<t_ANY_character_constant>L?\'(\\\\.|[^\\\\\'])+\')|(?P<t_ANY_string_literal>L?"(\\\\.|[^\\\\"])*")|(?P<t_ANY_lparen>\\()|(?P<t_INITIAL_newline>\\n)|(?P<t_INITIAL_pp_define>\\#define)', [
+                            None, ('t_ANY_character_constant', 'ANY_character_constant'), None, ('t_ANY_string_literal', 'ANY_string_literal'), None, ('t_ANY_lparen', 'ANY_lparen'), ('t_INITIAL_newline', 'INITIAL_newline'), ('t_INITIAL_pp_define', 'INITIAL_pp_define')])], 'DEFINE': [
+                                ('(?P<t_ANY_directive>\\#\\s+(\\d+)\\s+"([^"]+)"[ \\d]*\\n)|(?P<t_ANY_punctuator>(\\.\\.\\.|\\|\\||\\+\\+|\\*=|\\^=|<<=|>>=|\\|=|\\+=|>=|>>|<<|<=|<:|%=|:>|<%|!=|\\)|\\+|\\*|\\.|\\?|==|&=|&&|\\[|\\^|--|/=|%>|-=|->|\\||!|%|&|-|,|/|;|:|=|>|]|<|{|}|~))', [
+                                    None, ('t_ANY_directive', 'ANY_directive'), None, None, ('t_ANY_punctuator', 'ANY_punctuator')]), ('(?P<t_DEFINE_identifier>[a-zA-Z_]([a-zA-Z_]|[0-9])*)', [
+                                        None, ('t_DEFINE_identifier', 'DEFINE_identifier')]), ('(?P<t_ANY_float>(?P<p1>[0-9]+)?(?P<dp>[.]?)(?P<p2>(?(p1)[0-9]*|[0-9]+))(?P<exp>(?:[Ee][+-]?[0-9]+)?)(?P<suf>[FflL]?)(?!\\w))', [
+                                            None, ('t_ANY_float', 'ANY_float'), None, None, None, None, None]), ('(?P<t_ANY_int>(?P<p1>(?:0x[a-fA-F0-9]+)|(?:[0-9]+))(?P<suf>[uUlL]*))', [
+                                                None, ('t_ANY_int', 'ANY_int'), None, None]), ('(?P<t_ANY_character_constant>L?\'(\\\\.|[^\\\\\'])+\')|(?P<t_ANY_string_literal>L?"(\\\\.|[^\\\\"])*")|(?P<t_ANY_lparen>\\()|(?P<t_DEFINE_newline>\\n)|(?P<t_DEFINE_pp_param_op>(\\#\\#)|(\\#))', [
+                                                    None, ('t_ANY_character_constant', 'ANY_character_constant'), None, ('t_ANY_string_literal', 'ANY_string_literal'), None, ('t_ANY_lparen', 'ANY_lparen'), ('t_DEFINE_newline', 'DEFINE_newline'), ('t_DEFINE_pp_param_op', 'DEFINE_pp_param_op')])]}
 _lexstateignore = {'INITIAL': ' \t\x0b\x0c\r', 'DEFINE': ' \t\x0b\x0c\r'}
 _lexstateerrorf = {'INITIAL': 't_INITIAL_error', 'DEFINE': 't_DEFINE_error'}

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/parsetab.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/parsetab.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/parsetab.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -6,277 +6,277 @@
 
 _lr_signature = 'Oz\xa0\xf9\xf3X\xd9Mf\x00\xfa"\xb3\xb7\xce,'
 
-_lr_action_items = {'VOID':([387,15,238,332,22,3,37,359,137,64,170,286,58,51,230,353,12,2,39,73,20,60,47,54,25,65,168,56,242,81,0,13,27,72,116,278,4,133,277,231,221,9,280,279,34,186,130,169,358,227,18,123,327,1,360,117,17,36,165,205,30,8,52,196,35,356,339,140,269,235,23,283,31,167,134,260,287,87,5,6,10,32,38,66,28,163,59,49,237,26,67,172,],[-253,-2,-169,-155,-3,6,-132,-251,6,6,-141,6,-222,-104,-171,-135,-118,6,-121,-247,-167,6,6,6,-120,-138,6,-246,-219,6,-1,-133,6,6,-254,6,-163,-245,-243,6,6,-124,-136,-142,-125,6,-170,6,-134,-154,-126,-173,6,6,-252,-168,-130,-129,-244,-249,-241,-123,-156,-248,-128,-143,-220,6,-221,-172,-117,-144,-127,6,-223,-218,-250,6,-131,-122,-119,-242,-164,6,6,-217,6,-165,6,-166,-137,6,]),'DIV_ASSIGN':([309,155,363,91,179,366,182,180,316,217,313,75,317,181,211,100,102,184,388,423,77,314,420,410,99,142,78,310,318,185,213,74,90,104,292,220,84,105,110,364,368,109,],[-8,-4,-57,-19,-15,-25,-44,-16,-26,-17,-5,-18,-27,-14,-29,-22,-4,-45,-32,-35,-9,-7,-34,-33,-16,251,-5
 6,-6,-24,-47,-28,-20,-11,-10,-21,-46,-12,-13,-49,-48,-23,-43,]),'PP_DEFINE':([205,30,116,56,51,277,287,359,260,387,163,196,32,339,360,15,242,0,165,73,269,22,1,133,],[-249,-241,-254,-246,-104,-243,-250,-251,-218,-253,-217,-248,-242,-220,-252,-2,-219,-1,-244,-247,-221,-3,11,-245,]),'LE_OP':([78,310,100,368,301,184,96,311,211,90,297,309,220,298,364,75,155,318,102,182,423,305,104,91,110,74,213,99,109,299,86,185,97,105,77,410,296,179,181,363,84,295,217,420,180,312,292,366,388,317,306,308,313,316,142,314,85,307,83,300,],[-56,-6,-22,-23,-67,-45,201,201,-29,-11,-59,-8,-46,-61,-48,-18,-4,-24,-4,-44,-35,-71,-10,-19,-49,-20,-28,-16,-43,-60,-68,-47,-58,-13,-9,-33,-64,-15,-14,-57,-12,-63,-17,-34,-16,201,-21,-25,-32,-27,-69,-70,-5,-26,-56,-7,-62,-72,-65,-66,]),'(':([9,280,3,324,133,145,67,22,130,276,108,218,55,254,75,155,199,60,409,314,151,248,28,358,93,36,113,405,339,25,263,360,189,102,268,210,377,14,79,165,99,257,158,223,235,380,376,250,366,187,52,117,166,231,72,397,196,87,208,17,143,30,163,353
 ,105,13,284,57,6,141,181,193,201,260,272,379,242,46,123,44,277,289,154,247,190,255,270,135,179,114,134,84,29,228,240,49,152,82,217,331,399,5,243,316,2,91,38,213,225,387,349,15,292,357,234,35,384,198,354,171,76,186,317,23,330,0,65,8,109,211,144,342,287,41,252,61,414,293,26,140,205,249,37,51,328,137,90,408,95,34,107,261,204,381,238,47,103,346,374,183,269,382,203,10,68,80,313,262,371,413,159,94,20,32,259,221,164,176,367,73,344,153,267,197,58,372,194,230,340,393,161,338,127,207,219,136,7,104,378,195,150,215,56,100,258,180,266,369,192,1,359,45,147,402,191,188,253,415,246,332,18,74,309,256,264,31,43,370,392,174,251,116,202,39,310,396,216,318,139,4,69,16,81,227,224,394,406,12,77,348,368,42,245,200,],[-124,-136,-111,-199,-245,257,-137,-3,-170,137,-53,72,72,-94,-18,-4,-42,137,137,-7,72,-100,-109,-134,-41,-129,72,-234,-220,-120,137,-252,72,-4,-238,72,137,16,183,-244,-16,137,137,327,-172,137,-196,-91,-25,-145,-156,-168,137,231,137,-231,-248,-148,72,-130,-209,-241,-217,-135,-13,-133,72,16,-122,
 137,-14,72,72,-218,137,-215,-219,70,-173,-178,-243,72,-213,-99,72,-97,-228,-210,-15,221,-223,-12,16,72,137,54,266,-52,-17,327,-229,-131,-239,-26,-107,-19,-164,-28,221,-253,381,-2,-21,16,231,-128,137,72,72,16,183,137,-27,-117,-195,-1,-138,-123,215,-29,-226,137,-250,-108,-96,-110,-233,72,54,137,-249,-98,-132,-104,72,137,-11,137,-51,-125,-55,-227,72,137,-169,72,-54,137,-197,137,-221,137,72,-119,-179,186,-5,137,-194,-235,-211,-50,-167,-242,-225,221,16,72,137,-247,-216,-224,137,72,-222,-201,72,-171,-240,-198,272,-236,231,72,137,-212,-174,-10,137,-147,264,137,-246,-22,-237,-16,137,72,72,16,-251,-176,137,409,72,72,-90,-230,-93,-155,-126,-20,-8,137,137,-127,-175,-200,-202,72,-92,-254,72,-121,-6,-232,137,-24,-208,-163,-177,16,-146,-154,72,137,137,-118,-9,-214,-23,-112,-95,304,]),'STRUCT':([15,17,140,64,221,277,238,186,39,359,12,165,283,26,360,87,170,18,227,278,37,3,27,31,123,59,54,66,32,72,237,116,231,38,242,10,51,67,117,1,235,5,353,22,260,134,205,36,269,230,133,280,356,6,286,73,25,327,137,2
 79,169,56,339,65,358,0,4,35,387,196,47,60,130,9,13,172,20,49,81,30,332,23,58,163,167,52,34,168,287,2,8,28,],[-2,-130,33,33,33,-243,-169,33,-121,-251,-118,-244,-144,-166,-252,33,-141,-126,-154,33,-132,33,33,-127,-173,33,33,33,-242,33,33,-254,33,-164,-219,-119,-104,-137,-168,33,-172,-131,-135,-3,-218,-223,-249,-129,-221,-171,-245,-136,-143,-122,33,-247,-120,33,33,-142,33,-246,-220,-138,-134,-1,-163,-128,-253,-248,33,33,-170,-124,-133,33,-167,-165,33,-241,-155,-117,-222,-217,33,-156,-125,33,-250,33,-123,33,]),',':([182,244,274,90,39,100,300,372,313,395,185,318,390,345,386,370,311,38,403,347,65,75,234,4,45,106,421,323,355,220,92,315,376,238,110,402,321,13,74,301,362,132,117,173,127,235,34,96,314,423,280,213,295,142,85,331,121,177,8,49,126,179,296,25,337,3,180,5,31,322,52,112,366,422,119,398,330,388,77,383,101,41,67,316,416,162,86,374,128,123,417,364,230,102,68,305,281,307,9,35,352,20,306,332,61,122,308,26,78,6,401,275,392,43,389,297,418,28,317,343,148,184,358,368,97,400,129,155,36,42,10
 4,419,291,124,2,64,312,410,353,282,175,292,333,10,335,391,181,62,299,89,115,232,17,285,404,12,18,44,303,385,341,334,211,83,298,37,63,351,393,223,69,363,105,412,7,130,23,84,302,109,91,420,71,309,319,217,273,350,227,99,371,233,324,320,160,310,],[-44,262,-116,-11,-121,-22,-66,-201,-5,262,-47,-24,-31,262,-150,-200,-75,-164,-37,262,-138,-18,-191,-163,-176,-78,-36,262,-152,-46,-84,-77,-196,-169,-49,-39,262,-133,-20,-67,-256,-115,-168,-255,-186,-172,-125,-73,-7,-35,-136,-28,-63,-56,-62,-193,-161,262,-123,-165,-182,-15,-64,-120,-183,-111,-16,-131,-127,-85,-156,-86,-25,411,-159,262,-195,-32,-9,-204,-76,-108,-137,-26,262,-88,-68,-197,236,-173,-38,-48,-171,-4,-179,-71,-149,-72,-124,-128,384,-167,-69,-155,-110,229,-70,-166,-56,-122,-205,-203,-202,-175,-36,-59,411,-109,-27,-102,262,-45,-134,-23,-58,-207,237,-4,-129,-112,-10,-40,-81,-187,-107,-115,-74,-33,-135,-151,290,-21,-162,-119,-188,-87,-14,-113,-60,-80,-103,-185,-130,357,411,-118,-126,-178,-83,-153,-89,-160,-29,-65,-61,-132,164,-206,-198,-1
 92,-177,-57,-13,-36,-174,-170,-117,-12,-79,-43,-19,-34,-82,-8,-30,-17,-114,262,-154,-16,-194,-184,-199,367,-101,-6,]),'LONG':([237,286,52,51,56,31,36,353,134,205,87,9,18,287,356,67,358,17,230,130,54,123,37,27,116,35,22,10,242,137,165,231,196,278,186,277,58,3,38,283,64,23,72,238,32,47,172,59,39,4,360,117,81,140,12,260,387,168,25,5,0,167,169,66,227,327,28,280,65,8,30,339,34,73,13,279,26,6,133,359,269,49,221,170,15,20,332,235,60,2,163,1,],[18,18,-156,-104,-246,-127,-129,-135,-223,-249,18,-124,-126,-250,-143,-137,-134,-130,-171,-170,18,-173,-132,18,-254,-128,-3,-119,-219,18,-244,18,-248,18,18,-243,-222,18,-164,-144,18,-117,18,-169,-242,18,18,18,-121,-163,-252,-168,18,18,-118,-218,-253,18,-120,-131,-1,18,18,18,-154,18,18,-136,-138,-123,-241,-220,-125,-247,-133,-142,-166,-122,-245,-251,-221,-165,18,-141,-2,-167,-155,-172,18,18,-217,18,]),'ELLIPSIS':([237,],[336,]),'<':([423,217,301,364,109,366,313,420,368,295,85,77,102,305,292,388,96,90,184,314,312,181,104,363,316,297,299,317,155,99,213,1
 42,91,105,179,309,78,75,410,310,182,296,306,97,185,86,298,211,83,311,300,100,308,307,318,74,84,220,180,110,],[-35,-17,-67,-48,-43,-25,-5,-34,-23,-63,-62,-9,-4,-71,-21,-32,202,-11,-45,-7,202,-14,-10,-57,-26,-59,-60,-27,-4,-16,-28,-56,-19,-13,-15,-8,-56,-18,-33,-6,-44,-64,-69,-58,-47,-68,-61,-29,-65,202,-66,-22,-70,-72,-24,-20,-12,-46,-16,-49,]),'GOTO':([136,394,263,153,415,399,338,414,163,268,269,260,261,51,243,258,135,159,405,60,344,147,270,58,413,240,140,408,406,346,267,348,396,259,134,397,154,242,340,378,144,143,380,379,382,339,158,139,],[-212,138,138,-224,-230,-229,-236,-233,-217,-238,-221,-218,-227,-104,-239,-237,-210,-211,-234,138,-216,138,-228,-222,-235,138,138,138,138,138,138,-214,-232,-225,-223,-231,-213,-219,-240,138,-226,-209,138,-215,138,-220,138,-208,]),'ENUM':([59,3,8,327,130,72,10,260,172,169,332,13,231,9,73,279,167,163,356,81,230,137,116,47,238,269,227,133,117,37,12,170,221,237,34,87,2,360,280,66,58,168,242,277,65,23,39,28,20,22,196,5,18,32,15,31,278,1,17,205,283,123,
 52,25,51,6,67,30,358,35,287,339,235,60,36,387,38,54,0,165,26,64,56,359,140,353,4,134,186,49,27,286,],[24,24,-123,24,-170,24,-119,-218,24,24,-155,-133,24,-124,-247,-142,24,-217,-143,24,-171,24,-254,24,-169,-221,-154,-245,-168,-132,-118,-141,24,24,-125,24,24,-252,-136,24,-222,24,-219,-243,-138,-117,-121,24,-167,-3,-248,-131,-126,-242,-2,-127,24,24,-130,-249,-144,-173,-156,-120,-104,-122,-137,-241,-134,-128,-250,-220,-172,24,-129,-253,-164,24,-1,-244,-166,24,-246,-251,24,-135,-163,-223,24,-165,24,24,]),'PERIOD':([104,309,84,109,105,91,90,179,99,213,313,77,211,155,75,100,366,310,292,368,180,217,318,317,314,181,316,102,74,],[-10,-8,-12,212,-13,-19,-11,-15,-16,-28,-5,-9,-29,-4,-18,-22,-25,-6,-21,-23,-16,-17,-24,-27,-7,-14,-26,-4,-20,]),'PP_END_DEFINE':([310,306,311,100,36,101,112,91,361,115,74,292,88,114,371,307,84,289,280,65,83,331,17,318,5,330,391,308,305,316,6,368,364,110,358,195,388,96,97,44,312,332,303,315,86,322,180,302,222,288,353,223,43,291,67,220,179,370,317,7,366,423,182,181,31,
 314,4,69,106,81,71,18,372,35,309,37,217,109,313,8,75,376,187,105,393,363,52,48,211,301,298,102,184,38,185,45,77,13,68,324,227,392,420,174,104,213,225,9,90,297,410,300,47,99,374,89,85,296,92,87,34,299,78,98,295,],[-6,-69,-75,-22,-129,-76,-86,-19,387,-103,-20,-21,196,-189,-194,-72,-12,360,-136,-138,-65,-193,-130,-24,-131,-195,-87,-70,-71,-26,-122,-23,-48,-49,-134,-147,-32,-73,-58,-178,-74,-155,-83,-77,-68,-85,-16,-79,-190,359,-135,-192,-175,-81,-137,-46,-15,-200,-27,-174,-25,-35,-44,-14,-127,-7,-163,-177,-78,-146,-82,-126,-201,-128,-8,-132,-17,-43,-5,-123,-18,-196,-145,-13,-198,-57,-156,116,-29,-67,-61,-4,-45,-164,-47,-176,-9,-133,-179,-199,-154,-202,-34,287,-10,-28,-191,-124,-11,-59,-33,-66,73,-16,-197,-80,-62,-64,-84,-148,-125,-60,-56,205,-63,]),'LEFT_OP':([423,142,110,299,309,308,77,292,306,75,295,305,388,86,179,217,91,364,155,220,180,105,310,213,410,104,366,90,313,211,317,97,100,316,182,84,85,298,420,296,318,314,363,185,83,184,368,74,300,307,99,181,102,109,297,301,78,],[-35,-56,-4
 9,-60,-8,193,-9,-21,193,-18,-63,193,-32,193,-15,-17,-19,-48,-4,-46,-16,-13,-6,-28,-33,-10,-25,-11,-5,-29,-27,-58,-22,-26,-44,-12,-62,-61,-34,-64,-24,-7,-57,-47,-65,-45,-23,-20,-66,193,-16,-14,-4,-43,-59,-67,-56,]),'DOUBLE':([6,278,221,4,2,27,18,286,279,186,0,358,1,10,116,327,35,140,227,37,65,167,8,9,81,353,54,73,28,280,47,133,360,66,170,20,36,58,230,64,283,231,168,169,67,56,39,72,196,130,238,12,13,31,137,242,5,277,134,387,49,172,22,3,23,332,25,38,60,356,165,15,205,237,87,30,339,34,52,59,163,269,287,26,235,32,51,260,117,17,123,359,],[-122,35,35,-163,35,35,-126,35,-142,35,-1,-134,35,-119,-254,35,-128,35,-154,-132,-138,35,-123,-124,35,-135,35,-247,35,-136,35,-245,-252,35,-141,-167,-129,-222,-171,35,-144,35,35,35,-137,-246,-121,35,-248,-170,-169,-118,-133,-127,35,-219,-131,-243,-223,-253,-165,35,-3,35,-117,-155,-120,-164,35,-143,-244,-2,-249,35,35,-241,-220,-125,-156,35,-217,-221,-250,-166,-172,-242,-104,-218,-168,-130,-173,-251,]),'INC_OP':([210,189,255,264,159,378,188,348,366,397,245,
 270,408,328,102,252,317,399,316,174,224,213,242,267,191,99,380,109,140,134,415,284,163,192,257,181,256,249,77,381,346,396,262,55,84,215,94,135,394,384,247,217,208,377,379,166,216,74,113,259,183,91,139,251,276,155,344,180,137,413,151,266,80,190,340,405,219,248,313,47,76,141,207,153,254,79,369,338,158,318,198,197,105,204,409,269,243,60,268,176,100,202,194,143,258,51,211,90,240,144,414,228,293,107,201,367,246,179,310,58,289,339,103,218,368,382,272,261,75,104,260,253,147,309,186,72,203,82,342,136,108,250,406,154,314,193,263,292,354,95,],[76,76,-97,76,-211,76,76,-214,-25,-231,-95,-228,76,76,-4,-96,-27,-229,-26,76,76,-28,-219,76,76,-16,76,213,76,-223,-230,76,-217,76,76,-14,76,-98,-9,76,76,-232,76,76,-12,76,-50,-210,76,76,-99,-17,76,76,-215,76,76,-20,76,-225,76,-19,-208,-92,76,-4,-216,-16,76,-235,76,76,76,76,-240,-234,76,-100,-5,76,76,76,76,-224,-94,76,76,-236,76,-24,76,76,-13,76,76,-221,-239,76,-238,76,-22,76,76,-209,-237,-104,-29,-11,76,-226,-233,76,76,-55,76,76,-93,-15,-6,-222,76,-220,-
 54,76,-23,76,76,-227,-18,-10,-218,-90,76,-8,76,76,76,-52,76,-212,-53,-91,76,-213,-7,76,76,-21,76,-51,]),'|':([316,109,105,420,104,155,314,213,301,297,317,89,296,182,85,308,309,78,305,423,211,368,300,388,100,313,96,86,97,184,185,74,315,180,311,307,292,84,366,363,77,99,181,299,142,364,303,75,310,295,306,291,91,179,102,298,83,410,318,90,220,217,110,106,312,101,302,71,],[-26,-43,-13,-34,-10,-4,-7,-28,-67,-59,-27,-80,-64,-44,-62,-70,-8,-56,-71,-35,-29,-23,-66,-32,-22,-5,-73,-68,-58,-45,-47,-20,-77,-16,-75,-72,-21,-12,-25,-57,-9,-16,-14,-60,-56,-48,176,-18,-6,-63,-69,-81,-19,-15,-4,-61,-65,-33,-24,-11,-46,-17,-49,-78,-74,-76,-79,176,]),'NE_OP':([109,364,105,213,182,297,420,104,78,317,410,313,85,155,309,74,296,86,316,101,308,97,185,423,368,300,388,100,96,184,180,211,292,305,77,84,142,311,181,307,301,310,363,99,306,298,318,90,314,75,299,110,295,91,217,179,220,83,315,102,366,312,],[-43,-48,-13,-28,-44,-59,-34,-10,-56,-27,-33,-5,-62,-4,-8,-20,-64,-68,-26,207,-70,-58,-47,-35,-23,-66,-32,-22,-7
 3,-45,-16,-29,-21,-71,-9,-12,-56,-75,-14,-72,-67,-6,-57,-16,-69,-61,-24,-11,-7,-18,-60,-49,-63,-19,-17,-15,-46,-65,207,-4,-25,-74,]),'SHORT':([10,81,51,36,13,339,26,27,8,30,387,196,356,230,12,231,278,260,163,54,123,67,1,170,286,73,287,242,18,15,47,0,87,6,221,34,3,37,279,137,269,238,283,327,56,58,277,31,17,59,72,205,237,9,38,20,235,169,23,167,227,186,130,168,133,165,134,49,332,22,116,35,4,353,32,64,66,140,39,25,52,280,2,28,5,172,117,358,359,65,60,360,],[-119,9,-104,-129,-133,-220,-166,9,-123,-241,-253,-248,-143,-171,-118,9,9,-218,-217,9,-173,-137,9,-141,9,-247,-250,-219,-126,-2,9,-1,9,-122,9,-125,9,-132,-142,9,-221,-169,-144,9,-246,-222,-243,-127,-130,9,9,-249,9,-124,-164,-167,-172,9,-117,9,-154,9,-170,9,-245,-244,-223,-165,-155,-3,-254,-128,-163,-135,-242,9,9,9,-121,-120,-156,-136,9,9,-131,9,-168,-134,-251,-138,9,-252,]),'CONSTANT':([55,257,163,47,144,328,263,190,197,140,399,251,176,266,354,76,203,367,409,381,137,284,378,58,192,240,174,408,380,270,51,94,154,267,369,151,253,260,259,7
 2,250,191,258,82,242,208,248,183,202,228,60,276,194,153,166,193,136,224,159,269,158,80,396,339,204,216,377,261,107,198,346,384,188,406,338,201,141,340,147,348,186,249,215,382,219,139,207,414,394,254,262,218,247,256,344,246,415,210,143,245,413,289,135,113,79,379,252,189,272,134,293,405,255,268,264,342,103,397,243,95,108,],[77,77,-217,77,-226,77,77,77,77,77,-229,-92,77,77,77,77,77,77,77,77,77,77,77,-222,77,77,77,77,77,-228,-104,-50,-213,77,77,77,-90,-218,-225,77,-91,77,-237,-52,-219,77,-100,77,77,77,77,77,77,-224,77,77,-212,77,-211,-221,77,77,-232,-220,77,77,77,-227,-55,77,77,77,77,77,-236,77,77,-240,77,-214,77,-98,77,77,77,-208,77,-233,77,-94,77,77,-99,77,-216,-93,-230,77,-209,-95,-235,77,-210,77,77,-215,-96,77,77,-223,77,-234,-97,-238,77,77,-54,-231,-239,-51,-53,]),'DEC_OP':([397,192,190,252,258,245,109,268,90,219,246,228,211,75,250,95,409,240,249,113,270,405,256,94,310,55,316,313,100,47,276,198,269,254,259,99,354,263,314,140,379,134,208,257,266,74,108,144,76,155,215,255,210,166,193
 ,158,413,253,176,309,243,340,396,204,186,135,213,292,247,203,348,179,107,378,242,163,394,139,218,217,79,328,384,201,194,105,143,154,82,284,382,137,414,260,181,103,147,191,174,262,102,408,51,202,58,267,369,289,91,72,261,399,344,338,159,248,272,264,104,293,342,188,197,153,180,381,380,84,346,207,317,224,251,151,339,216,80,367,318,406,415,189,368,366,377,141,136,77,183,60,],[-231,79,79,-96,-237,-95,211,-238,-11,79,-93,79,-29,-18,-91,-51,79,79,-98,79,-228,-234,79,-50,-6,79,-26,-5,-22,79,79,79,-221,-94,-225,-16,79,79,-7,79,-215,-223,79,79,79,-20,-53,-226,79,-4,79,-97,79,79,79,79,-235,-90,79,-8,-239,-240,-232,79,79,-210,-28,-21,-99,79,-214,-15,-55,79,-219,-217,79,-208,79,-17,79,79,79,79,79,-13,-209,-213,-52,79,79,79,-233,-218,-14,-54,79,79,79,79,-4,79,-104,79,-222,79,79,79,-19,79,-227,-229,-216,-236,-211,-100,79,79,-10,79,79,79,79,-224,-16,79,79,-12,79,79,-27,79,-92,79,-220,79,79,79,-24,79,-230,79,-23,-25,79,79,-212,-9,79,79,]),'STATIC':([358,130,123,49,360,327,117,37,28,25,140,3,235,359,3
 0,205,0,237,230,6,58,339,9,27,31,12,4,8,22,39,35,1,134,56,242,387,18,51,238,32,13,64,38,36,163,59,10,60,5,260,2,287,167,221,20,52,332,227,73,17,15,280,54,196,26,116,23,67,269,65,277,353,34,133,165,231,],[-134,-170,-173,-165,-252,10,-168,-132,10,-120,10,10,-172,-251,-241,-249,-1,10,-171,-122,-222,-220,-124,10,-127,-118,-163,-123,-3,-121,-128,10,-223,-246,-219,-253,-126,-104,-169,-242,-133,10,-164,-129,-217,10,-119,10,-131,-218,10,-250,10,10,-167,-156,-155,-154,-247,-130,-2,-136,10,-248,-166,-254,-117,-137,-221,-138,-243,-135,-125,-245,-244,10,]),'EQ_OP':([100,308,311,314,101,301,185,423,99,307,90,142,297,77,410,220,96,78,110,295,97,298,84,184,74,363,104,83,312,299,318,315,213,366,182,305,292,364,309,300,86,316,155,180,306,109,85,388,296,313,105,91,181,179,211,310,102,217,420,317,368,75,],[-22,-70,-75,-7,208,-67,-47,-35,-16,-72,-11,-56,-59,-9,-33,-46,-73,-56,-49,-63,-58,-61,-12,-45,-20,-57,-10,-65,-74,-60,-24,208,-28,-25,-44,-71,-21,-48,-8,-66,-68,-26,-4,-16,-69,-43,-62,-32,-64,-5,-13
 ,-19,-14,-15,-29,-6,-4,-17,-34,-27,-23,-18,]),'SIZEOF':([80,203,192,268,247,107,284,191,396,219,253,249,339,95,415,406,381,60,269,346,190,264,243,82,263,259,207,151,158,405,163,147,58,197,262,141,55,218,266,76,137,51,293,204,188,270,245,79,380,193,378,72,342,134,240,413,379,255,246,369,338,367,408,143,103,144,250,414,377,153,409,272,251,113,397,139,216,94,267,210,194,215,166,384,189,140,260,183,174,108,394,276,201,136,399,261,256,252,328,135,248,242,154,254,186,159,257,208,340,47,354,198,289,228,258,224,382,348,176,344,202,],[80,80,80,-238,-99,-55,80,80,-232,80,-90,-98,-220,-51,-230,80,80,80,-221,80,80,80,-239,-52,80,-225,80,80,80,-234,-217,80,-222,80,80,80,80,80,80,80,80,-104,80,80,80,-228,-95,80,80,80,80,80,80,-223,80,-235,-215,-97,-93,80,-236,80,80,-209,-54,-226,-91,-233,80,-224,80,80,-92,80,-231,-208,80,-50,80,80,80,80,80,80,80,80,-218,80,80,-53,80,80,80,-212,-229,-227,80,-96,80,-210,-100,-219,-213,-94,80,-211,80,80,-240,80,80,80,80,80,-237,80,80,-214,80,-216,80,]),'+':([208,109
 ,289,245,191,60,110,405,147,144,293,252,183,269,409,268,217,318,354,100,94,105,192,246,314,83,295,243,317,414,310,248,420,179,107,264,363,316,298,366,377,276,134,301,79,99,136,257,256,166,55,84,140,190,253,261,260,339,186,213,210,263,266,182,193,348,378,368,242,142,408,309,51,394,215,296,197,284,249,113,153,299,155,340,396,204,344,218,254,228,194,159,211,85,75,154,82,135,313,220,247,240,181,180,97,74,369,262,47,207,384,258,381,76,103,216,90,80,143,388,415,379,410,338,342,267,141,270,78,72,201,300,108,91,176,399,382,406,292,189,297,188,95,203,77,272,413,163,380,104,174,102,397,139,346,328,202,224,251,151,259,185,184,137,58,367,423,198,364,158,255,219,250,],[82,-43,82,-95,82,82,-49,-234,82,-226,82,-96,82,-221,82,-238,-17,-24,82,-22,-50,-13,82,-93,-7,188,-63,-239,-27,-233,-6,-100,-34,-15,-55,82,-57,-26,-61,-25,82,82,-223,188,82,-16,-212,82,82,82,82,-12,82,82,-90,-227,-218,-220,82,-28,82,82,82,-44,82,-214,82,-23,-219,-56,82,-8,-104,82,82,-64,82,82,-98,82,-224,-60,-4,-240,-232,82,-216,82
 ,-94,82,82,-211,-29,-62,-18,-213,-52,-210,-5,-46,-99,82,-14,-16,-58,-20,82,82,82,82,82,-237,82,82,-54,82,-11,82,-209,-32,-230,-215,-33,-236,82,82,82,-228,-56,82,82,188,-53,-19,82,-229,82,82,-21,82,-59,82,-51,82,-9,82,-235,-217,82,-10,82,-4,-231,-208,82,82,82,82,-92,82,-225,-47,-45,82,-222,82,-35,82,-48,82,-97,82,-91,]),'UNSIGNED':([36,235,52,8,133,18,66,287,35,170,20,49,221,205,358,22,2,10,353,277,242,231,73,140,64,67,59,39,87,134,54,196,356,137,186,283,47,3,359,165,5,60,38,227,230,116,360,4,278,65,37,32,28,12,172,23,81,387,167,17,327,13,130,27,58,168,51,30,31,0,169,117,56,279,1,237,339,238,280,260,26,286,6,72,34,123,25,163,269,9,332,15,],[-129,-172,-156,-123,-245,-126,17,-250,-128,-141,-167,-165,17,-249,-134,-3,17,-119,-135,-243,-219,17,-247,17,17,-137,17,-121,17,-223,17,-248,-143,17,17,-144,17,17,-251,-244,-131,17,-164,-154,-171,-254,-252,-163,17,-138,-132,-242,17,-118,17,-117,17,-253,17,-130,17,-133,-170,17,-222,17,-104,-241,-127,-1,17,-168,-246,-142,17,17,-220,-169,-136,-218,-16
 6,17,-122,17,-125,-173,-120,-217,-221,-124,-155,-2,]),'/':([84,99,155,180,77,90,368,142,388,211,75,109,217,292,313,364,91,100,423,317,78,314,295,410,213,297,102,105,110,363,184,104,309,316,318,298,97,185,420,181,310,74,179,296,299,220,182,85,366,],[-12,-16,-4,-16,-9,-11,-23,-56,-32,-29,-18,-43,-17,-21,-5,-48,-19,-22,-35,-27,-56,-7,192,-33,-28,-59,-4,-13,-49,-57,-45,-10,-8,-26,-24,-61,-58,-47,-34,-14,-6,-20,-15,192,-60,-46,-44,192,-25,]),';':([42,130,90,285,316,341,38,77,63,401,67,312,342,134,301,5,182,75,4,348,52,309,397,280,83,12,17,240,303,60,317,148,74,405,162,25,263,298,2,385,311,257,158,185,306,241,99,28,184,136,10,235,410,353,36,302,299,243,117,261,84,144,260,35,220,49,380,181,64,269,339,268,26,57,242,105,6,160,34,413,135,296,414,143,87,3,244,382,19,292,155,29,115,132,217,146,163,37,106,346,8,123,408,211,140,85,310,154,171,65,343,153,338,391,91,386,179,364,314,230,399,156,363,394,187,61,238,275,109,407,180,300,41,388,270,89,18,100,379,308,396,322,97,213,273,96,23,58,71,159,81,
 318,281,378,142,104,258,51,102,139,62,355,112,110,147,332,20,195,420,157,297,315,13,340,274,344,291,305,78,9,358,282,313,239,86,415,31,259,295,92,307,423,39,383,267,141,406,368,227,101,366,],[-112,-170,-11,356,-26,-89,-164,-9,-106,-205,-137,-74,144,-223,-67,-131,-44,-18,-163,-214,-156,-8,-231,-136,-65,-118,-130,144,-83,144,-27,261,-20,-234,-88,-120,144,-61,-107,-153,-75,144,144,-47,-69,270,-16,-109,-45,-212,-119,-172,-33,-135,-129,-79,-60,-239,-168,-227,-12,-226,-218,-128,-46,-165,144,-14,-115,-221,-220,-238,-166,-105,-219,-13,-122,-101,-125,-235,-210,-64,-233,-209,-148,-111,340,144,51,-21,-4,-105,-103,-115,-17,258,-217,-132,-78,144,-123,-173,144,-29,144,-62,-6,-213,283,-138,-102,-224,-236,-87,-19,-150,-15,-48,-7,-171,-229,268,-57,144,-145,-110,-169,-203,-43,414,-16,-66,-108,-32,-228,-80,-126,-22,-215,-70,-232,-85,-58,-28,-114,-73,-117,-222,-82,-211,-146,-24,-149,144,-56,-10,-237,-104,-4,-208,-113,-152,-86,-49,144,-155,-167,-147,-34,270,-59,-77,-133,-240,-116,-216,-81,-71,-56,-124,-
 134,-151,-5,338,-68,-230,-127,-225,-63,-84,-72,-35,-121,-204,144,243,144,-23,-154,-76,-25,]),'?':([85,155,302,77,99,91,410,90,388,100,211,96,92,217,179,101,97,420,423,89,303,317,363,110,184,313,74,180,309,291,102,305,112,185,368,301,86,297,181,142,104,78,318,314,310,306,315,84,298,312,300,220,182,311,307,83,366,299,75,106,295,109,316,292,105,296,364,308,322,213,71,],[-62,-4,-79,-9,-16,-19,-33,-11,-32,-22,-29,-73,-84,-17,-15,-76,-58,-34,-35,-80,-83,-27,-57,-49,-45,-5,-20,-16,-8,-81,-4,-71,219,-47,-23,-67,-68,-59,-14,-56,-10,-56,-24,-7,-6,-69,-77,-12,-61,-74,-66,-46,-44,-75,-72,-65,-25,-60,-18,-78,-63,-43,-26,-21,-13,-64,-48,-70,-85,-28,-82,]),'$end':([73,339,15,165,51,359,1,0,133,387,287,116,56,32,22,277,269,242,260,196,360,30,205,163,],[-247,-220,-2,-244,-104,-251,0,-1,-245,-253,-250,-254,-246,-242,-3,-243,-221,-219,-218,-248,-252,-241,-249,-217,]),'FOR':([340,60,135,144,268,153,143,139,338,396,378,147,346,58,397,136,260,413,394,406,339,159,134,348,154,242,51,263,259,379,158,267,344
 ,405,408,380,163,140,240,382,261,243,415,269,399,258,270,414,],[-240,145,-210,-226,-238,-224,-209,-208,-236,-232,145,145,145,-222,-231,-212,-218,-235,145,145,-220,-211,-223,-214,-213,-219,-104,145,-225,-215,145,145,-216,-234,145,145,-217,145,145,145,-227,-239,-230,-221,-229,-237,-228,-233,]),'UNION':([65,242,238,37,278,287,260,13,3,23,81,137,58,387,30,34,186,56,1,140,51,66,205,38,130,116,170,269,227,64,172,72,22,17,36,286,12,280,332,39,230,353,163,0,8,60,27,35,169,5,123,231,67,10,52,20,221,47,327,32,15,358,283,73,18,26,59,167,134,235,49,168,6,9,4,359,339,237,31,277,279,360,25,133,356,165,2,87,54,28,196,117,],[-138,-219,-169,-132,21,-250,-218,-133,21,-117,21,21,-222,-253,-241,-125,21,-246,21,21,-104,21,-249,-164,-170,-254,-141,-221,-154,21,21,21,-3,-130,-129,21,-118,-136,-155,-121,-171,-135,-217,-1,-123,21,21,-128,21,-131,-173,21,-137,-119,-156,-167,21,21,21,-242,-2,-134,-144,-247,-126,-166,21,21,-223,-172,-165,21,-122,-124,-163,-251,-220,21,-127,-243,-142,-252,-120,-245,-143,-244,21
 ,21,21,21,-248,-168,]),'ELSE':([340,269,339,258,399,159,413,136,139,414,261,415,243,397,396,163,135,348,154,344,268,338,242,144,270,405,260,143,379,],[-240,-221,-220,-237,408,-211,-235,-212,-208,-233,-227,-230,-239,-231,-232,-217,-210,-214,-213,-216,-238,-236,-219,-226,-228,-234,-218,-209,-215,]),'[':([316,376,102,313,7,44,105,4,332,104,324,25,37,353,8,13,155,2,317,81,41,18,45,117,65,231,238,43,84,3,331,38,221,49,393,318,100,34,127,74,368,20,99,77,195,69,36,370,12,28,314,109,39,371,31,330,366,234,10,180,213,5,35,309,280,292,358,374,225,90,75,223,67,114,217,87,392,52,6,17,187,61,310,91,181,9,179,26,123,68,211,372,235,42,23,130,230,227,],[-26,-196,-4,-5,-174,-178,-13,-163,-155,-10,-199,-120,-132,-135,-123,-133,-4,-107,-27,-146,-108,-126,-176,-168,-138,224,-169,-175,-12,-111,328,-164,224,55,-198,-24,-22,-125,224,-20,-23,-167,-16,-9,-147,-177,-129,-200,-118,-109,-7,216,-121,-194,-127,-195,-25,224,-119,-16,-28,-131,-128,-8,-136,-21,-134,-197,224,-11,-18,328,-137,224,-17,-148,-202,-156,-1
 22,-130,-145,-110,-6,-19,-14,-124,-15,55,-173,-179,-29,-201,-172,-112,-117,-170,-171,-154,]),'OR_OP':([96,77,86,312,142,363,97,155,316,410,305,110,184,368,314,84,104,309,211,318,307,83,185,423,292,310,179,366,78,91,71,100,89,303,297,101,180,220,420,92,85,105,74,90,302,298,102,388,308,301,313,75,109,217,181,364,295,291,300,112,317,322,296,213,315,99,306,299,106,311,182,],[-73,-9,-68,-74,-56,-57,-58,-4,-26,-33,-71,-49,-45,-23,-7,-12,-10,-8,-29,-24,-72,-65,-47,-35,-21,-6,-15,-25,-56,-19,-82,-22,-80,-83,-59,-76,-16,-46,-34,-84,-62,-13,-20,-11,-79,-61,-4,-32,-70,-67,-5,-18,-43,-17,-14,-48,-63,-81,-66,218,-27,-85,-64,-28,-77,-16,-69,-60,-78,-75,-44,]),'SUB_ASSIGN':([363,105,77,318,292,366,78,213,423,109,317,368,313,211,388,185,91,314,104,142,102,310,410,420,184,99,182,316,309,179,364,75,110,74,220,180,181,90,84,155,100,217,],[-57,-13,-9,-24,-21,-25,-56,-28,-35,-43,-27,-23,-5,-29,-32,-47,-19,-7,-10,245,-4,-6,-33,-34,-45,-16,-44,-26,-8,-15,-48,-18,-49,-20,-46,-16,-14,-11,-12,-4,-22,-17,]),'
 XOR_ASSIGN':([366,102,182,91,78,388,100,309,179,185,213,420,142,313,105,292,181,74,310,104,99,423,220,410,110,84,217,77,184,316,75,180,155,109,317,368,364,90,363,314,318,211,],[-25,-4,-44,-19,-56,-32,-22,-8,-15,-47,-28,-34,247,-5,-13,-21,-14,-20,-6,-10,-16,-35,-46,-33,-49,-12,-17,-9,-45,-26,-18,-16,-4,-43,-27,-23,-48,-11,-57,-7,-24,-29,]),'INT':([2,137,47,32,358,27,59,140,5,117,65,260,227,72,221,3,9,81,283,360,332,359,18,1,28,230,279,66,163,8,30,116,170,64,280,231,238,37,13,20,133,0,58,34,73,52,54,186,56,167,169,196,205,38,49,67,287,277,36,15,327,12,387,356,339,26,39,22,51,134,235,353,165,60,130,87,168,31,172,6,17,35,269,286,123,242,4,237,10,278,23,25,],[34,34,34,-242,-134,34,34,34,-131,-168,-138,-218,-154,34,34,34,-124,34,-144,-252,-155,-251,-126,34,34,-171,-142,34,-217,-123,-241,-254,-141,34,-136,34,-169,-132,-133,-167,-245,-1,-222,-125,-247,-156,34,34,-246,34,34,-248,-249,-164,-165,-137,-250,-243,-129,-2,34,-118,-253,-143,-220,-166,-121,-3,-104,-223,-172,-135,-244,34,-170,34,34,-
 127,34,-122,-130,-128,-221,34,-173,-219,-163,34,-119,34,-117,-120,]),'SIGNED':([31,356,6,168,137,28,25,287,0,36,167,358,196,327,235,8,123,170,35,27,277,2,38,237,360,10,227,32,56,134,87,359,116,260,59,30,242,34,283,67,230,186,13,81,20,3,163,23,387,269,22,5,66,165,73,205,140,17,278,286,47,130,54,279,51,37,26,65,12,9,172,49,39,15,280,169,332,58,1,231,60,238,353,133,18,339,221,64,4,117,52,72,],[-127,-143,-122,36,36,36,-120,-250,-1,-129,36,-134,-248,36,-172,-123,-173,-141,-128,36,-243,36,-164,36,-252,-119,-154,-242,-246,-223,36,-251,-254,-218,36,-241,-219,-125,-144,-137,-171,36,-133,36,-167,36,-217,-117,-253,-221,-3,-131,36,-244,-247,-249,36,-130,36,36,36,-170,36,-142,-104,-132,-166,-138,-118,-124,36,-165,-121,-2,-136,36,-155,-222,36,36,36,-169,-135,-245,-126,-220,36,36,-163,-168,-156,36,]),'CONTINUE':([58,340,243,408,154,269,144,143,258,338,394,136,159,263,413,339,382,259,153,344,399,268,242,406,158,415,135,240,405,147,414,134,163,267,60,140,260,396,346,261,270,380,379,397,139,378,51,34
 8,],[-222,-240,-239,146,-213,-221,-226,-209,-237,-236,146,-212,-211,146,-235,-220,146,-225,-224,-216,-229,-238,-219,146,146,-230,-210,146,-234,146,-233,-223,-217,146,146,146,-218,-232,146,-227,-228,146,-215,-231,-208,146,-104,-214,]),'MUL_ASSIGN':([318,105,420,100,317,314,78,91,292,366,181,182,104,179,185,99,142,155,220,309,84,74,310,410,213,75,184,368,316,180,313,363,423,217,364,77,110,102,388,211,90,109,],[-24,-13,-34,-22,-27,-7,-56,-19,-21,-25,-14,-44,-10,-15,-47,-16,250,-4,-46,-8,-12,-20,-6,-33,-28,-18,-45,-23,-26,-16,-5,-57,-35,-17,-48,-9,-49,-4,-32,-29,-11,-43,]),'{':([267,24,346,238,408,52,379,58,159,136,258,243,405,158,339,344,276,51,139,384,380,261,144,415,64,269,26,340,406,135,163,414,140,338,67,230,134,394,270,348,154,27,60,396,33,235,397,167,240,117,260,21,263,20,40,268,378,166,413,59,147,399,49,242,153,123,382,130,143,259,65,],[60,53,60,-169,60,118,-215,-222,-211,-212,-237,-239,-234,60,-220,-216,276,-104,-208,276,60,-227,-226,-230,60,-221,-166,-240,60,-210,-217,-233,60,
 -236,172,-171,-223,60,-228,-214,-213,60,60,-232,-139,-172,-231,60,60,-168,-218,-140,60,-167,66,-238,60,276,-235,60,60,-229,-165,-219,-224,-173,60,-170,-209,-225,168,]),'RIGHT_OP':([155,363,86,74,77,307,78,313,211,317,305,308,309,296,297,104,388,300,301,213,105,109,185,97,85,179,91,182,420,83,75,410,217,220,314,366,318,306,310,364,299,110,292,99,295,102,142,90,184,298,100,180,84,316,368,423,181,],[-4,-57,194,-20,-9,194,-56,-5,-29,-27,194,194,-8,-64,-59,-10,-32,-66,-67,-28,-13,-43,-47,-58,-62,-15,-19,-44,-34,-65,-18,-33,-17,-46,-7,-25,-24,194,-6,-48,-60,-49,-21,-16,-63,-4,-56,-11,-45,-61,-22,-16,-12,-26,-23,-35,-14,]),'REGISTER':([2,260,13,17,54,39,130,360,4,387,237,205,64,280,52,167,231,238,196,49,287,0,73,133,165,123,36,65,358,58,31,6,9,20,59,227,1,277,8,27,5,163,38,67,28,140,339,22,51,230,37,235,359,25,353,23,3,26,221,10,60,117,332,134,242,116,32,30,12,34,15,35,18,327,269,56,],[39,-218,-133,-130,39,-121,-170,-252,-163,-253,39,-249,39,-136,-156,39,39,-169,-248,-165,-250,-1,-247,-245
 ,-244,-173,-129,-138,-134,-222,-127,-122,-124,-167,39,-154,39,-243,-123,39,-131,-217,-164,-137,39,39,-220,-3,-104,-171,-132,-172,-251,-120,-135,-117,39,-166,39,-119,39,-168,-155,-223,-219,-254,-242,-241,-118,-125,-2,-128,-126,39,-221,-246,]),'RIGHT_ASSIGN':([142,410,77,420,423,99,185,155,104,211,213,182,220,366,364,316,363,78,313,91,388,318,310,292,105,110,75,74,181,100,309,102,84,90,217,317,179,184,109,368,180,314,],[255,-33,-9,-34,-35,-16,-47,-4,-10,-29,-28,-44,-46,-25,-48,-26,-57,-56,-5,-19,-32,-24,-6,-21,-13,-49,-18,-20,-14,-22,-8,-4,-12,-11,-17,-27,-15,-45,-43,-23,-16,-7,]),'DEFAULT':([159,140,258,260,153,154,379,380,269,339,136,270,344,405,267,378,382,58,134,348,414,242,147,243,397,346,263,408,158,394,51,406,143,261,139,338,259,60,268,340,413,135,163,415,399,144,396,240,],[-211,149,-237,-218,-224,-213,-215,149,-221,-220,-212,-228,-216,-234,149,149,149,-222,-223,-214,-233,-219,149,-239,-231,149,149,149,149,149,-104,149,-209,-227,-208,-236,-225,149,-238,-240,-235,-210,-217,-230,
 -229,-226,-232,149,]),'CHAR':([15,18,133,137,58,4,13,31,280,231,26,60,37,387,278,49,332,66,12,1,39,165,169,5,279,9,17,269,186,23,34,140,54,130,65,20,116,47,51,230,73,81,87,172,22,67,205,163,3,170,286,38,28,134,32,8,260,59,2,356,242,360,35,287,30,25,227,52,56,235,6,10,358,0,359,27,283,72,123,238,168,237,196,36,277,117,353,221,339,327,64,167,],[-2,-126,-245,8,-222,-163,-133,-127,-136,8,-166,8,-132,-253,8,-165,-155,8,-118,8,-121,-244,8,-131,-142,-124,-130,-221,8,-117,-125,8,8,-170,-138,-167,-254,8,-104,-171,-247,8,8,8,-3,-137,-249,-217,8,-141,8,-164,8,-223,-242,-123,-218,8,8,-143,-219,-252,-128,-250,-241,-120,-154,-156,-246,-172,-122,-119,-134,-1,-251,8,-144,8,-173,-169,8,8,-248,-129,-243,-168,-135,8,-220,8,8,8,]),'WHILE':([382,147,338,413,153,259,258,344,139,405,136,134,415,397,267,339,394,379,380,396,240,159,261,399,243,348,260,140,408,154,406,51,143,270,242,378,163,58,269,268,340,414,135,60,158,271,263,346,144,],[150,150,-236,-235,-224,-225,-237,-216,-208,-234,-212,-223,-230,-231,15
 0,-220,150,-215,150,-232,150,-211,-227,-229,-239,-214,-218,150,150,-213,150,-104,-209,-228,-219,150,-217,-222,-221,-238,-240,-233,-210,150,150,349,150,150,-226,]),'EXTERN':([163,4,31,23,117,34,67,242,56,13,10,32,133,54,59,227,269,130,65,359,1,280,36,358,15,123,235,26,167,6,230,51,238,12,339,49,134,60,73,58,5,353,38,2,387,231,332,237,3,0,30,27,116,28,360,327,9,39,37,64,8,196,35,18,277,140,221,260,17,165,22,287,205,20,25,52,],[-217,-163,-127,-117,-168,-125,-137,-219,-246,-133,-119,-242,-245,12,12,-154,-221,-170,-138,-251,12,-136,-129,-134,-2,-173,-172,-166,12,-122,-171,-104,-169,-118,-220,-165,-223,12,-247,-222,-131,-135,-164,12,-253,12,-155,12,12,-1,-241,12,-254,12,-252,12,-124,-121,-132,12,-123,-248,-128,-126,-243,12,12,-218,-130,-244,-3,-250,-249,-167,-120,-156,]),'RETURN':([158,396,406,348,260,143,147,339,340,159,269,399,394,135,163,414,139,405,379,415,134,243,344,136,259,397,242,382,240,140,60,258,408,144,51,378,263,338,154,153,267,413,346,380,270,58,268,261,],[141,-232,141,-214,
 -218,-209,141,-220,-240,-211,-221,-229,141,-210,-217,-233,-208,-234,-215,-230,-223,-239,-216,-212,-225,-231,-219,141,141,141,141,-237,141,-226,-104,141,141,-236,-213,-224,141,-235,141,141,-228,-222,-238,-227,]),'__ASM__':([198,381,408,174,240,135,269,258,144,202,284,382,260,79,252,47,137,257,369,218,276,80,147,228,189,191,380,151,338,396,378,176,249,399,203,261,246,263,108,243,340,190,253,192,342,55,377,51,219,136,141,94,270,339,262,354,183,264,414,328,367,215,379,154,384,82,293,140,254,267,158,143,58,406,242,409,113,210,268,103,289,250,139,216,413,405,245,107,60,415,272,256,247,348,204,207,255,193,166,346,153,201,134,259,76,194,251,394,248,224,397,95,197,344,186,72,208,163,266,188,159,],[93,93,93,93,93,-210,-221,-237,-226,93,93,93,-218,93,-96,93,93,93,93,93,93,93,93,93,93,93,93,93,-236,-232,93,93,-98,-229,93,-227,-93,93,-53,-239,-240,93,-90,93,93,93,93,-104,93,-212,93,-50,-228,-220,93,93,93,93,-233,93,93,93,-215,-213,93,-52,93,93,-94,93,93,-209,-222,93,-219,93,93,93,-238,-54,93,-91
 ,-208,93,-235,-234,-95,-55,93,-230,93,93,-99,-214,93,93,-97,93,93,93,-224,93,-223,-225,93,93,-92,93,-100,93,-231,-51,93,-216,93,93,93,-217,93,93,-211,]),'CASE':([378,153,259,163,258,139,134,242,396,339,147,51,380,58,159,399,136,269,379,154,408,243,270,267,397,405,413,382,135,143,394,340,260,144,158,140,414,344,240,268,263,406,338,346,60,415,348,261,],[151,-224,-225,-217,-237,-208,-223,-219,-232,-220,151,-104,151,-222,-211,-229,-212,-221,-215,-213,151,-239,-228,151,-231,-234,-235,151,-210,-209,151,-240,-218,-226,151,151,-233,-216,151,-238,151,151,-236,151,151,-230,-214,-227,]),'PP_DEFINE_MACRO_NAME':([11,],[46,]),'&':([106,74,256,224,83,91,308,276,397,202,210,95,94,240,85,381,318,211,219,113,306,191,198,260,153,315,184,192,140,384,388,257,142,338,215,84,369,254,154,340,242,312,216,409,220,188,413,382,134,251,313,163,261,423,99,316,292,185,78,379,245,270,213,420,76,104,289,174,255,317,218,262,248,189,197,90,135,58,252,166,314,77,300,247,399,108,293,301,194,79,364,363,368,302,310,179,2
 98,183,190,406,414,307,250,249,253,207,299,246,267,139,180,366,342,243,264,272,60,378,144,103,284,339,102,295,258,143,408,367,96,193,296,311,354,107,75,268,137,309,141,101,109,377,82,203,396,72,80,405,158,100,186,176,348,217,410,228,204,97,105,182,51,328,269,47,55,201,344,394,86,136,181,208,147,155,266,151,159,415,305,346,259,297,263,380,110,],[210,-20,94,94,-65,-19,-70,94,-231,94,94,-51,-50,94,-62,94,-24,-29,94,94,-69,94,94,-218,-224,-77,-45,94,94,94,-32,94,-56,-236,94,-12,94,-94,-213,-240,-219,-74,94,94,-46,94,-235,94,-223,-92,-5,-217,-227,-35,-16,-26,-21,-47,-56,-215,-95,-228,-28,-34,94,-10,94,94,-97,-27,94,94,-100,94,94,-11,-210,-222,-96,94,-7,-9,-66,-99,-229,-53,94,-67,94,94,-48,-57,-23,210,-6,-15,-61,94,94,94,-233,-72,-91,-98,-90,94,-60,-93,94,-208,-16,-25,94,-239,94,94,94,94,-226,-54,94,-220,-4,-63,-237,-209,94,94,-73,94,-64,-75,94,-55,-18,-238,94,-8,94,-76,-43,94,-52,94,-232,94,94,-234,94,-22,94,94,-214,-17,-33,94,94,-58,-13,-44,-104,94,-221,94,94,94,-216,94,-68,-212,-14,94,
 94,-4,94,94,-211,-230,-71,94,-225,-59,94,94,-49,]),'*':([266,52,297,202,208,176,127,195,163,253,268,287,204,185,191,277,2,270,396,245,213,260,219,187,104,174,231,196,256,247,56,81,218,192,141,179,284,134,360,84,109,353,39,10,180,240,41,227,332,414,133,44,12,249,264,354,255,388,34,251,4,346,314,413,269,55,23,113,262,76,250,158,0,205,243,348,198,166,137,28,261,280,15,105,210,35,140,197,296,381,171,257,263,420,193,99,379,8,31,366,228,221,415,151,68,36,378,87,342,90,58,51,380,6,408,143,367,201,344,293,310,299,267,79,85,18,242,5,289,136,298,1,272,7,72,259,317,292,164,29,110,215,100,186,246,399,217,147,384,309,220,188,38,207,9,357,363,82,318,423,37,43,394,30,254,135,359,338,387,65,22,116,406,409,42,16,358,3,61,364,313,339,405,224,25,211,316,77,252,102,410,73,216,165,184,139,13,32,114,276,382,107,75,94,369,97,144,368,103,189,74,80,182,328,67,153,377,258,159,108,57,194,95,181,155,60,142,340,47,91,397,78,183,248,17,203,154,295,190,],[95,-156,-59,95,95,95,7,-147,-217,-90,-238,-250,95,-47,95,-
 243,-107,-228,-232,-95,-28,-218,95,-145,-10,95,7,-248,95,-99,-246,-146,95,95,95,-15,95,-223,-252,-12,-43,-135,-121,-119,-16,95,-108,-154,-155,-233,-245,-178,-118,-98,95,95,-97,-32,-125,-92,-163,95,-7,-235,-221,95,-117,95,95,95,-91,95,-1,-249,-239,-214,95,95,95,-109,-227,-136,-2,-13,95,-128,95,95,190,95,7,95,95,-34,95,-16,-215,-123,-127,-25,95,7,-230,95,-179,-129,95,-148,95,-11,-222,-104,95,-122,95,-209,95,95,-216,95,-6,-60,95,95,190,-126,-219,-131,95,-212,-61,7,95,7,95,-225,-27,-21,7,7,-49,95,-22,95,-93,-229,-17,95,95,-8,-46,95,-164,95,-124,7,-57,-52,-24,-35,-132,7,95,-241,-94,-210,-251,-236,-253,-138,-3,-254,95,95,-112,7,-134,-111,-110,-48,-5,-220,-234,95,-120,-29,-26,-9,-96,-4,-33,-247,95,-244,-45,-208,-133,-242,7,95,95,-55,-18,-50,95,-58,-226,-23,-54,95,-20,95,-44,95,-137,-224,95,-237,-211,-53,7,95,-51,-14,-4,95,-56,-240,95,-19,-231,-56,95,-100,-130,95,-213,190,95,]),'SWITCH':([414,139,380,147,270,143,242,134,154,340,267,394,379,382,263,261,348,406,144,339,413,243,158,344,163,396
 ,378,268,415,259,258,397,60,51,338,135,408,399,269,159,58,346,405,260,136,140,153,240,],[-233,-208,152,152,-228,-209,-219,-223,-213,-240,152,152,-215,152,152,-227,-214,152,-226,-220,-235,-239,152,-216,-217,-232,152,-238,-230,-225,-237,-231,152,-104,-236,-210,152,-229,-221,-211,-222,152,-234,-218,-212,152,-224,152,]),'AND_ASSIGN':([217,292,318,181,179,110,368,102,316,309,109,105,99,184,74,142,104,90,314,185,78,388,363,182,180,423,155,100,420,310,84,213,220,91,77,364,75,211,410,366,313,317,],[-17,-21,-24,-14,-15,-49,-23,-4,-26,-8,-43,-13,-16,-45,-20,249,-10,-11,-7,-47,-56,-32,-57,-44,-16,-35,-4,-22,-34,-6,-12,-28,-46,-19,-9,-48,-18,-29,-33,-25,-5,-27,]),'IDENTIFIER':([9,141,280,344,293,21,246,384,242,82,194,257,346,55,30,23,0,259,243,164,139,16,215,24,134,65,58,33,5,144,408,38,127,67,79,209,108,107,1,138,397,103,216,409,42,17,332,143,342,212,159,45,360,394,37,43,254,268,252,387,207,51,53,382,190,3,186,192,94,231,147,191,47,196,406,248,195,188,287,61,73,54,165,118,10,253,367,358,214,38
 1,264,31,203,154,80,340,270,357,52,405,224,174,25,396,234,189,151,227,414,266,153,284,12,187,198,276,137,245,210,60,35,202,208,183,269,247,163,81,262,95,258,236,36,204,353,251,18,57,260,140,133,197,369,176,13,44,249,263,277,255,338,34,15,219,39,14,41,4,68,240,56,113,250,116,205,72,158,2,28,379,261,267,339,206,22,229,171,256,354,76,380,136,218,193,328,377,40,8,7,166,272,69,289,378,413,135,359,87,399,32,348,6,228,415,29,201,],[-124,102,-136,-216,102,-140,-93,102,-219,-52,102,102,155,102,-241,-117,-1,-225,-239,20,-208,20,102,52,-223,-138,-222,-139,-131,-226,155,-164,20,-137,102,102,-53,-55,20,239,-231,-54,102,102,-112,-130,-155,-209,102,316,-211,-176,-252,155,-132,-175,-94,-238,-96,-253,102,-104,121,155,102,-111,102,102,-50,20,155,102,102,-248,155,-100,-147,102,-250,-110,-247,124,-244,121,-119,-90,102,-134,317,102,102,-127,102,-213,102,-240,-228,20,-156,-234,102,102,-120,-232,20,102,102,-154,-233,102,-224,102,-118,-145,102,102,102,-95,102,155,-128,102,102,102,-221,-99,-217,-146,102,-51
 ,-237,335,-129,102,-135,-92,-126,20,-218,155,-245,102,102,102,-133,-178,-98,155,-243,-97,-236,-125,-2,102,-121,20,-108,-163,-179,155,-246,102,-91,-254,-249,102,155,-107,-109,-215,-227,155,-220,102,-3,121,20,102,102,102,155,-212,102,102,102,102,67,-123,-174,102,102,-177,102,155,-235,-210,-251,-148,-229,-242,-214,-122,102,-230,20,102,]),'ADD_ASSIGN':([420,317,104,109,313,78,155,213,91,179,181,185,182,423,90,314,100,220,180,316,364,363,77,105,366,309,142,310,410,75,368,217,211,74,102,388,292,184,318,84,99,110,],[-34,-27,-10,-43,-5,-56,-4,-28,-19,-15,-14,-47,-44,-35,-11,-7,-22,-46,-16,-26,-48,-57,-9,-13,-25,-8,254,-6,-33,-18,-23,-17,-29,-20,-4,-32,-21,-45,-24,-12,-16,-49,]),'>':([300,85,86,296,102,181,77,298,105,307,364,410,423,309,313,211,317,182,213,388,366,292,220,155,74,314,363,306,318,312,91,110,217,83,308,90,310,96,100,179,75,305,109,311,97,180,99,184,299,420,142,104,297,368,84,301,316,295,185,78,],[-66,-62,-68,-64,-4,-14,-9,-61,-13,-72,-48,-33,-35,-8,-5,-29,-27,-44,-28,-32,-25,-2
 1,-46,-4,-20,-7,-57,-69,-24,204,-19,-49,-17,-65,-70,-11,-6,204,-22,-15,-18,-71,-43,204,-58,-16,-16,-45,-60,-34,-56,-10,-59,-23,-12,-67,-26,-63,-47,-56,]),'PP_MACRO_PARAM':([263,354,103,82,207,245,414,144,203,58,139,174,84,289,215,108,186,76,254,192,74,290,216,143,369,47,250,202,381,276,266,141,377,258,189,158,247,113,137,218,261,219,90,206,328,270,382,188,269,51,260,135,153,183,204,367,264,346,257,190,268,107,217,406,134,396,240,154,256,293,197,380,413,253,259,99,94,210,163,272,246,198,201,267,348,176,339,262,249,394,405,384,224,151,340,415,255,193,344,111,181,378,338,105,194,147,408,209,80,60,243,180,191,379,251,284,166,399,409,136,140,79,252,70,55,208,242,95,228,397,248,159,342,179,72,],[99,99,-54,-52,99,-95,-233,-226,99,-222,-208,99,-12,99,99,-53,99,99,-94,99,180,362,99,-209,99,99,-91,99,99,99,99,99,99,-237,99,99,-99,99,99,99,-227,99,-11,309,99,-228,99,99,-221,-104,-218,-210,-224,99,99,99,99,99,99,99,-238,-55,-17,99,-223,-232,99,-213,99,99,99,99,-235,-90,-225,-16,-50,99,-217,99,-
 93,99,99,99,-214,99,-220,99,-98,99,-234,99,99,99,-240,-230,-97,99,-216,217,-14,99,-236,-13,99,99,99,314,99,99,-239,-16,99,-215,-92,99,99,-229,99,-212,99,99,-96,173,99,99,-219,-51,99,-231,-100,-211,99,-15,99,]),'GE_OP':([211,110,84,297,90,184,83,317,104,78,306,312,300,182,180,155,299,181,179,109,423,301,307,102,77,97,213,142,75,364,86,308,316,388,96,363,366,314,292,220,99,217,74,310,313,305,296,420,295,311,100,91,368,185,85,105,298,318,410,309,],[-29,-49,-12,-59,-11,-45,-65,-27,-10,-56,-69,203,-66,-44,-16,-4,-60,-14,-15,-43,-35,-67,-72,-4,-9,-58,-28,-56,-18,-48,-68,-70,-26,-32,203,-57,-25,-7,-21,-46,-16,-17,-20,-6,-5,-71,-64,-34,-63,203,-22,-19,-23,-47,-62,-13,-61,-24,-33,-8,]),'^':([366,179,315,298,296,91,97,100,155,99,312,420,363,110,104,388,299,185,182,96,90,317,311,220,410,75,85,297,306,301,184,423,314,308,313,180,291,307,310,102,78,142,292,295,74,316,302,106,211,368,109,213,300,181,305,89,364,309,101,318,77,217,86,84,105,83,],[-25,-15,-77,-61,-64,-19,-58,-22,-4,-16,-74,-34,-57,-
 49,-10,-32,-60,-47,-44,-73,-11,-27,-75,-46,-33,-18,-62,-59,-69,-67,-45,-35,-7,-70,-5,-16,197,-72,-6,-4,-56,-56,-21,-63,-20,-26,-79,-78,-29,-23,-43,-28,-66,-14,-71,197,-48,-8,-76,-24,-9,-17,-68,-12,-13,-65,]),'MOD_ASSIGN':([142,182,74,368,104,185,110,155,84,100,181,184,211,388,318,292,217,363,423,213,109,420,77,90,314,364,310,316,220,78,105,313,366,180,99,102,91,410,317,179,75,309,],[246,-44,-20,-23,-10,-47,-49,-4,-12,-22,-14,-45,-29,-32,-24,-21,-17,-57,-35,-28,-43,-34,-9,-11,-7,-48,-6,-26,-46,-56,-13,-5,-25,-16,-16,-4,-19,-33,-27,-15,-18,-8,]),':':([297,5,97,235,318,291,99,86,162,403,317,142,310,90,110,358,364,78,292,84,309,52,83,220,195,332,301,75,296,31,123,388,187,74,322,302,115,323,130,238,36,391,265,180,184,105,308,365,419,299,341,313,8,343,316,303,307,100,104,306,295,49,38,9,92,357,20,109,298,37,227,89,149,185,71,87,117,77,81,311,412,363,102,423,404,101,65,368,213,160,217,420,67,4,96,211,179,417,353,418,230,35,282,171,106,18,402,315,34,389,300,182,112,314,366,85,26,305,13,410,
 181,155,17,6,312,91,280,],[-59,-131,-58,-172,-24,-81,-16,-68,-88,-37,-27,-56,-6,-11,-49,-134,-48,-56,-21,-12,-8,-156,-65,-46,-147,-155,-67,-18,-64,-127,-173,-32,-145,-20,-85,-79,-103,369,-170,-169,-129,-87,346,-16,-45,-13,-70,389,-40,-60,-89,-5,-123,-102,-26,-83,-72,-22,-10,-69,-63,-165,-164,-124,-84,284,-167,-43,-61,-132,-154,-80,263,-47,-82,-148,-168,-9,-146,-75,-36,-57,-4,-35,412,-76,-138,-23,-28,-101,-17,-34,-137,-163,-73,-29,-15,-38,-135,421,-171,-128,354,284,-78,-126,-39,-77,-125,-36,-66,-44,-86,-7,-25,-62,-166,-71,-133,-33,-14,267,-130,-122,-74,-19,-136,]),'TYPE_NAME':([13,65,51,67,167,286,47,327,35,32,278,169,279,60,130,21,37,31,28,260,227,5,359,12,137,235,165,56,87,283,172,59,242,54,30,168,20,140,353,22,8,221,116,387,4,6,64,205,10,2,134,360,339,230,123,36,66,38,356,3,33,231,27,9,196,163,34,39,15,1,17,238,269,81,40,18,133,58,52,25,237,358,49,277,186,287,26,72,73,280,170,117,0,332,23,],[-133,-138,-104,-137,13,13,13,13,-128,-242,13,13,-142,13,-170,-140,-132,-127,13,-218,-154,-
 131,-251,-118,13,-172,-244,-246,13,-144,13,13,-219,13,-241,13,-167,13,-135,-3,-123,13,-254,-253,-163,-122,13,-249,-119,13,-223,-252,-220,-171,-173,-129,13,-164,-143,13,-139,13,13,-124,-248,-217,-125,-121,-2,13,-130,-169,-221,13,65,-126,-245,-222,-156,-120,13,-134,-165,-243,13,-250,-166,13,-247,-136,-141,-168,-1,-155,-117,]),'OR_ASSIGN':([211,179,420,110,91,99,102,310,78,142,213,423,185,184,368,388,317,75,182,90,364,410,314,100,180,155,309,217,109,84,74,105,220,104,316,363,366,318,181,77,313,292,],[-29,-15,-34,-49,-19,-16,-4,-6,-56,248,-28,-35,-47,-45,-23,-32,-27,-18,-44,-11,-48,-33,-7,-22,-16,-4,-8,-17,-43,-12,-20,-13,-46,-10,-26,-57,-25,-24,-14,-9,-5,-21,]),'BREAK':([263,258,269,242,158,378,260,399,397,58,270,346,382,379,261,134,154,139,408,51,135,153,344,348,259,396,338,243,268,415,380,406,163,340,267,414,159,405,240,394,339,144,147,136,60,140,143,413,],[156,-237,-221,-219,156,156,-218,-229,-231,-222,-228,156,156,-215,-227,-223,-213,-208,156,-104,-210,-224,-216,-214,-225,-232,-236
 ,-239,-238,-230,156,156,-217,-240,156,-233,-211,-234,156,156,-220,-226,156,-212,156,156,-209,-235,]),'VOLATILE':([237,205,170,66,353,130,360,47,327,260,8,26,4,235,59,339,356,38,387,140,23,17,117,242,358,279,93,1,0,54,18,5,169,287,35,168,221,6,186,37,52,123,283,25,133,269,81,7,31,277,116,56,87,9,231,13,165,12,227,20,60,27,65,137,359,72,230,58,278,3,286,172,43,51,22,2,332,68,73,39,15,64,280,32,238,196,163,167,34,67,134,28,44,36,10,49,30,],[38,-249,-141,38,-135,-170,-252,38,38,-218,-123,-166,-163,-172,38,-220,-143,-164,-253,38,-117,-130,-168,-219,-134,-142,199,38,-1,38,-126,-131,38,-250,-128,38,38,-122,38,-132,-156,-173,-144,-120,-245,-221,38,38,-127,-243,-254,-246,38,-124,38,-133,-244,-118,-154,-167,38,38,-138,38,-251,38,-171,-222,38,38,38,38,38,-104,-3,38,-155,-179,-247,-121,-2,38,-136,-242,-169,-248,-217,38,-125,-137,-223,38,-178,-129,-119,-165,-241,]),'error':([136,380,378,153,147,346,338,399,261,344,342,58,159,51,267,382,139,260,414,242,154,143,408,135,413,394,158,163,257,396,144,
 340,243,269,259,134,379,140,270,263,11,348,268,405,240,397,60,258,415,406,339,],[-212,241,241,-224,241,241,-236,-229,-227,-216,241,-222,-211,-104,241,241,-208,-218,-233,-219,-213,-209,241,-210,-235,241,241,-217,241,-232,-226,-240,-239,-221,-225,-223,-215,241,-228,241,48,-214,-238,-234,241,-231,157,-237,-230,241,-220,]),'~':([397,113,103,58,380,189,252,246,79,256,262,263,254,194,413,251,344,139,202,382,183,249,147,82,204,144,201,191,394,207,384,215,186,154,340,243,141,405,188,342,339,136,284,193,261,381,76,269,293,266,159,248,268,399,276,60,289,47,242,94,55,258,219,406,250,174,240,379,253,414,151,192,198,107,255,137,367,216,409,203,396,80,158,224,260,135,176,166,245,153,143,377,210,190,354,328,247,218,208,163,257,140,197,72,259,348,378,338,369,267,264,346,51,270,408,108,134,228,95,272,415,],[-231,103,-54,-222,103,103,-96,-93,103,103,103,103,-94,103,-235,-92,-216,-208,103,103,103,-98,103,-52,103,-226,103,103,103,103,103,103,103,-213,-240,-239,103,-234,103,103,-220,-212,103,103,-227,10
 3,103,-221,103,103,-211,-100,-238,-229,103,103,103,103,-219,-50,103,-237,103,103,-91,103,103,-215,-90,-233,103,103,103,-55,-97,103,103,103,103,103,-232,103,103,103,-218,-210,103,103,-95,-224,-209,103,103,103,103,103,-99,103,103,-217,103,103,103,103,-225,-214,103,-236,103,103,103,103,-104,-228,103,-53,-223,103,-51,103,-230,]),'DO':([243,346,339,153,163,338,136,158,396,415,380,51,258,405,242,382,397,159,263,267,240,259,408,270,134,140,340,348,143,144,413,135,378,379,154,399,147,414,260,139,60,269,394,268,406,344,261,58,],[-239,158,-220,-224,-217,-236,-212,158,-232,-230,158,-104,-237,-234,-219,158,-231,-211,158,158,158,-225,158,-228,-223,158,-240,-214,-209,-226,-235,-210,158,-215,-213,-229,158,-233,-218,-208,158,-221,158,-238,158,-216,-227,-222,]),'CONST':([359,205,81,31,9,49,2,32,196,37,72,20,59,10,242,18,358,231,15,117,60,235,123,26,360,6,34,260,230,356,54,353,25,27,3,8,167,67,269,133,332,227,140,237,283,56,4,38,43,186,64,12,51,39,44,68,221,278,5,7,134,47,52,280,87,163,327,339,168,28
 6,13,58,36,23,66,287,73,169,116,17,0,137,279,238,130,22,170,65,172,387,30,35,277,28,1,165,],[-251,-249,4,-127,-124,-165,4,-242,-248,-132,4,-167,4,-119,-219,-126,-134,4,-2,-168,4,-172,-173,-166,-252,-122,-125,-218,-171,-143,4,-135,-120,4,4,-123,4,-137,-221,-245,-155,-154,4,4,-144,-246,-163,-164,4,4,4,-118,-104,-121,-178,-179,4,4,-131,4,-223,4,-156,-136,4,-217,4,-220,4,4,-133,-222,-129,-117,4,-250,-247,4,-254,-130,-1,4,-142,-169,-170,-3,-141,-138,4,-253,-241,-128,-243,4,4,-244,]),'!':([107,246,204,242,147,269,189,262,208,58,176,243,254,263,183,108,379,270,51,338,342,380,405,159,79,293,80,215,139,396,339,193,381,256,197,249,47,369,260,95,399,354,144,250,408,247,163,201,348,397,216,272,266,413,186,194,328,382,257,198,82,289,261,367,76,414,253,255,409,224,153,202,267,406,218,113,136,140,143,60,207,377,240,174,141,134,340,190,228,384,219,344,251,94,137,276,284,394,191,210,378,135,258,55,158,252,245,203,154,264,192,268,415,188,103,248,259,166,72,151,346,],[-55,-93,107,-219,107,-221,107,107
 ,107,-222,107,-239,-94,107,107,-53,-215,-228,-104,-236,107,107,-234,-211,107,107,107,107,-208,-232,-220,107,107,107,107,-98,107,107,-218,-51,-229,107,-226,-91,107,-99,-217,107,-214,-231,107,107,107,-235,107,107,107,107,107,107,-52,107,-227,107,107,-233,-90,-97,107,107,-224,107,107,107,107,107,-212,107,-209,107,107,107,107,107,107,-223,-240,107,107,107,107,-216,-92,-50,107,107,107,107,107,107,107,-210,-237,107,107,-96,-95,107,-213,107,107,-238,-230,107,-54,-100,-225,107,107,107,107,]),'%':([364,295,314,90,388,179,217,292,75,110,77,180,420,309,299,296,84,423,109,220,368,363,142,74,78,99,102,100,310,297,182,184,318,316,366,298,185,97,317,313,155,104,91,85,211,181,213,410,105,],[-48,191,-7,-11,-32,-15,-17,-21,-18,-49,-9,-16,-34,-8,-60,191,-12,-35,-43,-46,-23,-57,-56,-20,-56,-16,-4,-22,-6,-59,-44,-45,-24,-26,-25,-61,-47,-58,-27,-5,-4,-10,-19,191,-29,-14,-28,-33,-13,]),')':([68,106,391,175,12,416,310,318,179,217,70,331,261,309,423,280,177,97,403,42,392,52,371,418,6,54,332,213,50,184,130,2
 23,299,231,13,311,294,195,127,325,335,373,92,388,238,312,20,75,398,123,419,215,44,74,84,337,316,185,38,86,162,233,31,364,296,389,350,142,5,104,114,358,99,227,173,307,144,319,28,124,420,322,69,292,187,305,330,100,17,65,211,336,78,128,303,341,180,9,345,366,376,422,365,234,102,182,300,77,317,297,101,295,343,49,225,393,368,160,96,71,85,8,3,320,178,7,126,306,347,23,61,67,109,395,37,220,110,41,370,270,363,89,404,232,181,291,18,410,129,313,25,90,2,10,34,39,87,377,324,230,43,81,314,390,372,91,301,221,112,417,402,105,412,302,235,117,315,36,298,308,35,83,125,362,421,45,327,326,374,353,222,26,4,],[-179,-78,-87,289,-118,419,-6,-24,-15,-17,174,-193,-227,-8,-35,-136,292,-58,-37,-112,-202,-156,-194,420,-122,123,-155,-28,117,-45,-170,-192,-60,324,-133,-75,364,-147,-186,370,-188,392,-84,-32,-169,-74,-167,-18,407,-173,-40,318,-178,-20,-12,-183,-26,-47,-164,-68,-88,-184,-127,-48,-64,-36,382,-56,-131,-10,-189,-134,-16,-154,-255,-72,-226,-30,-109,-187,-34,-85,-177,-21,-145,-71,-195,-22,-130,-138,-29,-18
 1,-56,235,-83,-89,-16,-124,378,-25,-196,423,388,-191,-4,-44,-66,-9,-27,-59,-76,-63,-102,-165,-191,-198,-23,-101,-73,-82,-62,-123,-111,366,293,-174,-182,-69,380,-117,-110,-137,-43,406,-132,-46,-49,-108,-200,-228,-57,-80,410,-185,-14,-81,-126,-33,-180,-5,-120,-11,-107,-119,-125,-121,-148,394,-199,-171,-175,-146,-7,-31,-201,-19,-67,324,-86,-38,-39,-13,-36,-79,-172,-168,-77,-129,-61,-70,-128,-65,230,-256,-36,-176,372,371,-197,-135,-190,-166,-163,]),'-':([378,240,364,83,409,202,252,197,247,261,97,219,248,110,72,414,250,310,245,309,354,318,99,183,94,313,154,176,180,262,379,413,296,184,181,203,207,381,190,55,297,104,76,377,420,408,301,316,51,201,251,328,263,75,79,74,155,246,249,292,188,396,182,174,108,243,314,135,254,298,348,340,186,399,185,95,338,85,107,159,255,367,192,384,368,346,394,253,220,289,256,344,105,77,267,369,210,228,216,264,423,363,242,218,217,189,415,103,91,143,82,134,60,136,342,47,397,339,166,109,299,163,194,405,268,272,58,366,78,100,388,224,258,276,193,269,257,295,211,266,27
 0,158,84,140,410,139,208,293,260,259,317,141,300,102,90,142,406,137,382,113,80,153,215,380,144,204,213,191,179,151,198,147,284,],[108,108,-48,189,108,108,-96,108,-99,-227,-58,108,-100,-49,108,-233,-91,-6,-95,-8,108,-24,-16,108,-50,-5,-213,108,-16,108,-215,-235,-64,-45,-14,108,108,108,108,108,-59,-10,108,108,-34,108,189,-26,-104,108,-92,108,108,-18,108,-20,-4,-93,-98,-21,108,-232,-44,108,-53,-239,-7,-210,-94,-61,-214,-240,108,-229,-47,-51,-236,-62,-55,-211,-97,108,108,108,-23,108,108,-90,-46,108,108,-216,-13,-9,108,108,108,108,108,108,-35,-57,-219,108,-17,108,-230,-54,-19,-209,-52,-223,108,-212,108,108,-231,-220,108,-43,-60,-217,108,-234,-238,108,-222,-25,-56,-22,-32,108,-237,108,108,-221,108,-63,-29,108,-228,108,-12,108,-33,-208,108,108,-218,-225,-27,108,189,-4,-11,-56,108,108,108,108,108,-224,108,108,-226,108,-28,108,-15,108,108,108,108,]),'CHARACTER_CONSTANT':([380,414,250,204,245,186,191,151,284,94,154,252,140,413,247,248,381,72,377,272,201,183,176,382,379,249,203,207,55,174,76,3
 44,408,51,254,396,415,251,338,263,79,158,293,289,346,394,240,253,188,369,210,262,108,243,144,348,340,242,218,399,189,107,159,367,192,82,134,342,378,256,397,219,166,267,228,216,264,194,405,58,135,255,193,269,257,103,143,266,270,60,136,47,339,163,141,268,354,406,137,328,224,276,113,153,139,208,260,190,259,258,384,147,198,409,202,80,215,197,261,95,246,],[104,-233,-91,104,-95,104,104,104,104,-50,-213,-96,104,-235,-99,-100,104,104,104,104,104,104,104,104,-215,-98,104,104,104,104,104,-216,104,-104,-94,-232,-230,-92,-236,104,104,104,104,104,104,104,104,-90,104,104,104,104,-53,-239,-226,-214,-240,-219,104,-229,104,-55,-211,104,104,-52,-223,104,104,104,-231,104,104,104,104,104,104,104,-234,-222,-210,-97,104,-221,104,-54,-209,104,-228,104,-212,104,-220,-217,104,-238,104,104,104,104,104,104,104,-224,-208,104,-218,104,-225,-237,104,104,104,104,104,104,104,104,-227,-51,-93,]),'PP_STRINGIFY':([139,242,176,82,58,268,381,103,94,99,367,259,84,163,147,272,204,354,382,344,328,174,266,183,394,269,255,3
 99,413,249,263,409,134,396,72,180,193,190,107,218,252,202,408,136,210,194,217,113,257,256,51,189,188,47,207,208,379,108,228,151,95,270,105,247,181,415,348,250,342,405,159,143,253,397,186,135,240,377,243,198,219,339,261,245,260,144,264,154,79,191,262,216,267,215,369,197,254,414,140,346,246,289,338,380,224,384,192,158,90,74,284,248,153,406,60,141,378,55,179,76,166,258,340,203,137,293,80,251,201,276,],[-208,-219,111,-52,-222,-238,111,-54,-50,-16,111,-225,-12,-217,111,111,111,111,111,-216,111,111,111,111,111,-221,-97,-229,-235,-98,111,111,-223,-232,111,-16,111,111,-55,111,-96,111,111,-212,111,111,-17,111,111,111,-104,111,111,111,111,111,-215,-53,111,111,-51,-228,-13,-99,-14,-230,-214,-91,111,-234,-211,-209,-90,-231,111,-210,111,111,-239,111,111,-220,-227,-95,-218,-226,111,-213,111,111,111,111,111,111,111,111,-94,-233,111,111,-93,111,-236,111,111,111,111,111,-11,111,111,-100,-224,111,111,111,111,111,-15,111,111,-237,-240,111,111,111,111,-92,111,111,]),'PTR_OP':([211,109,84,309,317,217,74
 ,181,77,91,213,90,104,102,292,313,100,368,99,179,314,180,310,366,316,318,105,75,155,],[-29,214,-12,-8,-27,-17,-20,-14,-9,-19,-28,-11,-10,-4,-21,-5,-22,-23,-16,-15,-7,-16,-6,-25,-26,-24,-13,-18,-4,]),'=':([117,26,132,104,99,182,185,90,142,78,220,109,313,49,155,213,91,179,316,121,423,366,314,100,363,235,180,238,64,130,230,102,388,105,123,211,364,84,410,317,110,368,20,310,420,309,75,74,292,184,217,181,77,318,],[-168,-166,166,-10,-16,-44,-47,-11,253,-56,-46,-43,-5,-165,-4,-28,-19,-15,-26,228,-35,-25,-7,-22,-57,-172,-16,-169,166,-170,-171,-4,-32,-13,-173,-29,-48,-12,-33,-27,-49,-23,-167,-6,-34,-8,-18,-20,-21,-45,-17,-14,-9,-24,]),'TYPEDEF':([58,52,242,359,358,3,123,35,287,34,28,227,196,38,231,26,130,165,64,327,269,15,2,37,6,205,25,51,230,133,54,73,235,280,10,5,27,31,30,117,18,332,134,221,20,8,260,67,9,13,1,387,56,60,49,23,32,237,36,116,59,140,238,339,163,17,167,277,353,12,22,65,0,4,39,360,],[-222,-156,-219,-251,-134,23,-173,-128,-250,-125,23,-154,-248,-164,23,-166,-170,-244,23,23,-221,-2
 ,23,-132,-122,-249,-120,-104,-171,-245,23,-247,-172,-136,-119,-131,23,-127,-241,-168,-126,-155,-223,23,-167,-123,-218,-137,-124,-133,23,-253,-246,23,-165,-117,-242,23,-129,-254,23,23,-169,-220,-217,-130,23,-243,-135,-118,-3,-138,-1,-163,-121,-252,]),'AUTO':([130,287,140,60,3,133,242,31,353,116,235,327,28,34,59,8,56,269,37,27,65,18,339,221,231,13,17,39,36,332,6,10,277,230,35,26,38,32,227,67,30,64,280,15,9,360,359,25,12,73,165,387,1,49,2,117,260,123,205,5,51,23,238,20,237,196,4,167,58,358,22,163,52,0,134,54,],[-170,-250,25,25,25,-245,-219,-127,-135,-254,-172,25,25,-125,25,-123,-246,-221,-132,25,-138,-126,-220,25,25,-133,-130,-121,-129,-155,-122,-119,-243,-171,-128,-166,-164,-242,-154,-137,-241,25,-136,-2,-124,-252,-251,-120,-118,-247,-244,-253,25,-165,25,-168,-218,-173,-249,-131,-104,-117,-169,-167,25,-248,-163,25,-222,-134,-3,-217,-156,-1,-223,25,]),'AND_OP':([142,101,301,97,86,308,423,77,213,364,366,109,75,295,420,311,220,211,363,84,217,296,90,110,100,300,96,106,99,302,92,83,185,89,
 314,104,322,299,74,105,310,410,71,307,91,368,155,313,180,292,312,303,298,309,182,306,184,318,179,317,102,291,388,297,181,315,305,85,316,78,],[-56,-76,-67,-58,-68,-70,-35,-9,-28,-48,-25,-43,-18,-63,-34,-75,-46,-29,-57,-12,-17,-64,-11,-49,-22,-66,-73,-78,-16,-79,198,-65,-47,-80,-7,-10,198,-60,-20,-13,-6,-33,-82,-72,-19,-23,-4,-5,-16,-21,-74,-83,-61,-8,-44,-69,-45,-24,-15,-27,-4,-81,-32,-59,-14,-77,-71,-62,-26,-56,]),']':([106,316,301,303,423,102,322,368,410,296,420,77,211,74,364,363,220,292,109,180,217,112,302,298,305,99,321,160,295,89,311,318,86,300,104,83,329,309,105,97,185,131,110,315,92,224,312,181,75,313,55,328,343,308,307,96,184,71,115,182,85,388,341,375,179,101,306,213,366,314,297,391,84,78,317,299,291,100,91,90,162,142,310,],[-78,-26,-67,-83,-35,-4,-85,-23,-33,-64,-34,-9,-29,-20,-48,-57,-46,-21,-43,-16,-17,-86,-79,-61,-71,-16,368,-101,-63,-80,-75,-24,-68,-66,-10,-65,376,-8,-13,-58,-47,238,-49,-77,-84,330,-74,-14,-18,-5,130,374,-102,-70,-72,-73,-45,-82,-103,-44,-62,-32,-89,393,
 -15,-76,-69,-28,-25,-7,-59,-87,-12,-56,-27,-60,-81,-22,-19,-11,-88,-56,-6,]),'IF':([260,399,382,269,413,344,406,147,380,144,134,346,58,408,405,394,51,379,259,415,268,396,340,378,60,154,240,140,261,159,242,135,263,153,243,258,139,414,267,348,338,397,158,163,143,136,339,270,],[-218,-229,161,-221,-235,-216,161,161,161,-226,-223,161,-222,161,-234,161,-104,-215,-225,-230,-238,-232,-240,161,161,-213,161,161,-227,-211,-219,-210,161,-224,-239,-237,-208,-233,161,-214,-236,-231,161,-217,-209,-212,-220,-228,]),'STRING_LITERAL':([414,134,252,412,255,193,90,105,228,216,257,249,409,179,394,260,243,210,103,76,369,55,219,245,269,354,380,192,413,208,348,84,248,218,263,289,163,201,60,136,204,242,108,268,251,151,186,51,250,240,190,207,276,94,180,256,99,377,72,189,224,258,259,166,344,95,397,264,399,284,338,405,153,415,421,408,194,346,113,367,139,342,254,340,406,411,159,147,389,215,174,253,135,379,158,262,188,378,107,141,267,246,143,80,197,47,74,396,144,304,261,82,328,191,217,381,247,181,339,154,198,384
 ,58,183,203,272,137,79,266,176,293,202,382,270,140,],[-233,-223,-96,90,-97,90,-11,-13,90,90,90,-98,90,-15,90,-218,-239,90,-54,90,90,90,90,-95,-221,90,90,90,-235,90,-214,-12,-100,90,90,90,-217,90,90,-212,90,-219,-53,-238,-92,90,90,-104,-91,90,90,90,90,-50,-16,90,-16,90,90,90,90,-237,-225,90,-216,-51,-231,90,-229,90,-236,-234,-224,-230,90,90,90,90,90,90,-208,90,-94,-240,90,90,-211,90,90,90,90,-90,-210,-215,90,90,90,90,-55,90,90,-93,-209,90,90,90,90,-232,-226,90,-227,-52,90,90,-17,90,-99,-14,-220,-213,90,90,-222,90,90,90,90,90,90,90,90,90,90,-228,90,]),'PP_IDENTIFIER_PASTE':([102,314,99,309,155,],[209,206,206,206,209,]),'PP_DEFINE_NAME':([11,],[47,]),'FLOAT':([64,13,186,231,165,56,1,35,39,10,277,9,360,36,49,32,237,238,227,332,168,52,278,133,287,60,116,134,283,66,23,12,356,196,260,54,6,72,73,28,58,130,4,17,0,205,359,20,81,235,123,221,167,3,51,353,358,18,387,286,172,34,170,137,65,269,22,37,26,31,27,327,163,47,25,30,59,242,140,2,67,8,169,5,279,87,339,280,117,15,230,38,],[31,-133,31,31,-24
 4,-246,31,-128,-121,-119,-243,-124,-252,-129,-165,-242,31,-169,-154,-155,31,-156,31,-245,-250,31,-254,-223,-144,31,-117,-118,-143,-248,-218,31,-122,31,-247,31,-222,-170,-163,-130,-1,-249,-251,-167,31,-172,-173,31,31,31,-104,-135,-134,-126,-253,31,31,-125,-141,31,-138,-221,-3,-132,-166,-127,31,31,-217,31,-120,-241,31,-219,31,31,-137,-123,31,-131,-142,31,-220,-136,-168,-2,-171,-164,]),'LEFT_ASSIGN':([314,184,180,317,313,316,366,109,364,99,318,102,410,368,100,78,179,423,104,309,142,74,420,110,84,292,211,388,181,220,185,90,213,182,217,310,363,105,91,155,77,75,],[-7,-45,-16,-27,-5,-26,-25,-43,-48,-16,-24,-4,-33,-23,-22,-56,-15,-35,-10,-8,252,-20,-34,-49,-12,-21,-29,-32,-14,-46,-47,-11,-28,-44,-17,-6,-57,-13,-19,-4,-9,-18,]),'}':([157,283,292,379,413,181,269,278,275,344,261,112,242,322,303,296,383,391,71,384,159,300,102,286,142,364,85,211,220,51,60,139,109,120,154,163,338,260,106,115,119,279,352,258,312,298,313,84,340,302,311,268,317,414,366,91,420,179,136,363,397,77,333,122,243,74,368,16
 2,135,240,217,226,401,396,169,356,351,299,182,308,270,309,339,348,306,334,291,388,104,147,89,90,99,315,105,144,400,97,399,140,185,101,297,110,423,213,301,310,78,295,307,316,75,410,259,405,121,341,96,58,184,305,314,180,100,170,134,143,318,86,415,83,153,92,229,],[269,-144,-21,-215,-235,-14,-221,353,-203,-216,-227,-86,-219,-85,-83,-64,-204,-87,-82,401,-211,-66,-4,358,-56,-48,-62,-29,-46,-104,163,-208,-43,227,-213,-217,-236,-218,-78,-103,-159,-142,383,-237,-74,-61,-5,-12,-240,-79,-75,-238,-27,-233,-25,-19,-34,-15,-212,-57,-231,-9,-162,-157,-239,-20,-23,-88,-210,339,-17,332,-205,-232,280,-143,-206,-60,-44,-70,-228,-8,-220,-214,-69,-160,-81,-32,-10,260,-80,-11,-16,-77,-13,-226,-207,-58,-229,242,-47,-76,-59,-49,-35,-28,-67,-6,-56,-63,-72,-26,-18,-33,-225,-234,-161,-89,-73,-222,-45,-71,-7,-16,-22,-141,-223,-209,-24,-68,-230,-65,-224,-84,-158,]),}
+_lr_action_items = {'VOID': ([387, 15, 238, 332, 22, 3, 37, 359, 137, 64, 170, 286, 58, 51, 230, 353, 12, 2, 39, 73, 20, 60, 47, 54, 25, 65, 168, 56, 242, 81, 0, 13, 27, 72, 116, 278, 4, 133, 277, 231, 221, 9, 280, 279, 34, 186, 130, 169, 358, 227, 18, 123, 327, 1, 360, 117, 17, 36, 165, 205, 30, 8, 52, 196, 35, 356, 339, 140, 269, 235, 23, 283, 31, 167, 134, 260, 287, 87, 5, 6, 10, 32, 38, 66, 28, 163, 59, 49, 237, 26, 67, 172, ], [-253, -2, -169, -155, -3, 6, -132, -251, 6, 6, -141, 6, -222, -104, -171, -135, -118, 6, -121, -247, -167, 6, 6, 6, -120, -138, 6, -246, -219, 6, -1, -133, 6, 6, -254, 6, -163, -245, -243, 6, 6, -124, -136, -142, -125, 6, -170, 6, -134, -154, -126, -173, 6, 6, -252, -168, -130, -129, -244, -249, -241, -123, -156, -248, -128, -143, -220, 6, -221, -172, -117, -144, -127, 6, -223, -218, -250, 6, -131, -122, -119, -242, -164, 6, 6, -217, 6, -165, 6, -166, -137, 6, ]), 'DIV_ASSIGN': ([309, 155, 363, 91, 179, 366, 182, 180, 316, 217, 313, 75, 317, 181, 211, 10
 0, 102, 184, 388, 423, 77, 314, 420, 410, 99, 142, 78, 310, 318, 185, 213, 74, 90, 104, 292, 220, 84, 105, 110, 364, 368, 109, ], [-8, -4, -57, -19, -15, -25, -44, -16, -26, -17, -5, -18, -27, -14, -29, -22, -4, -45, -32, -35, -9, -7, -34, -33, -16, 251, -56, -6, -24, -47, -28, -20, -11, -10, -21, -46, -12, -13, -49, -48, -23, -43, ]), 'PP_DEFINE': ([205, 30, 116, 56, 51, 277, 287, 359, 260, 387, 163, 196, 32, 339, 360, 15, 242, 0, 165, 73, 269, 22, 1, 133, ], [-249, -241, -254, -246, -104, -243, -250, -251, -218, -253, -217, -248, -242, -220, -252, -2, -219, -1, -244, -247, -221, -3, 11, -245, ]), 'LE_OP': ([78, 310, 100, 368, 301, 184, 96, 311, 211, 90, 297, 309, 220, 298, 364, 75, 155, 318, 102, 182, 423, 305, 104, 91, 110, 74, 213, 99, 109, 299, 86, 185, 97, 105, 77, 410, 296, 179, 181, 363, 84, 295, 217, 420, 180, 312, 292, 366, 388, 317, 306, 308, 313, 316, 142, 314, 85, 307, 83, 300, ], [-56, -6, -22, -23, -67, -45, 201, 201, -29, -11, -59, -8, -46, -61, -48, -18, -4, -24, -4
 , -44, -35, -71, -10, -19, -49, -20, -28, -16, -43, -60, -68, -47, -58, -13, -9, -33, -64, -15, -14, -57, -12, -63, -17, -34, -16, 201, -21, -25, -32, -27, -69, -70, -5, -26, -56, -7, -62, -72, -65, -66, ]), '(': ([9, 280, 3, 324, 133, 145, 67, 22, 130, 276, 108, 218, 55, 254, 75, 155, 199, 60, 409, 314, 151, 248, 28, 358, 93, 36, 113, 405, 339, 25, 263, 360, 189, 102, 268, 210, 377, 14, 79, 165, 99, 257, 158, 223, 235, 380, 376, 250, 366, 187, 52, 117, 166, 231, 72, 397, 196, 87, 208, 17, 143, 30, 163, 353, 105, 13, 284, 57, 6, 141, 181, 193, 201, 260, 272, 379, 242, 46, 123, 44, 277, 289, 154, 247, 190, 255, 270, 135, 179, 114, 134, 84, 29, 228, 240, 49, 152, 82, 217, 331, 399, 5, 243, 316, 2, 91, 38, 213, 225, 387, 349, 15, 292, 357, 234, 35, 384, 198, 354, 171, 76, 186, 317, 23, 330, 0, 65, 8, 109, 211, 144, 342, 287, 41, 252, 61, 414, 293, 26, 140, 205, 249, 37, 51, 328, 137, 90, 408, 95, 34, 107, 261, 204, 381, 238, 47, 103, 346, 374, 183, 269, 382, 203, 10, 68, 80, 313, 262, 
 371, 413, 159, 94, 20, 32, 259, 221, 164, 176, 367, 73, 344, 153, 267, 197, 58, 372, 194, 230, 340, 393, 161, 338, 127, 207, 219, 136, 7, 104, 378, 195, 150, 215, 56, 100, 258, 180, 266, 369, 192, 1, 359, 45, 147, 402, 191, 188, 253, 415, 246, 332, 18, 74, 309, 256, 264, 31, 43, 370, 392, 174, 251, 116, 202, 39, 310, 396, 216, 318, 139, 4, 69, 16, 81, 227, 224, 394, 406, 12, 77, 348, 368, 42, 245, 200, ], [-124, -136, -111, -199, -245, 257, -137, -3, -170, 137, -53, 72, 72, -94, -18, -4, -42, 137, 137, -7, 72, -100, -109, -134, -41, -129, 72, -234, -220, -120, 137, -252, 72, -4, -238, 72, 137, 16, 183, -244, -16, 137, 137, 327, -172, 137, -196, -91, -25, -145, -156, -168, 137, 231, 137, -231, -248, -148, 72, -130, -209, -241, -217, -135, -13, -133, 72, 16, -122, 137, -14, 72, 72, -218, 137, -215, -219, 70, -173, -178, -243, 72, -213, -99, 72, -97, -228, -210, -15, 221, -223, -12, 16, 72, 137, 54, 266, -52, -17, 327, -229, -131, -239, -26, -107, -19, -164, -28, 221, -253, 381, -2, -2
 1, 16, 231, -128, 137, 72, 72, 16, 183, 137, -27, -117, -195, -1, -138, -123, 215, -29, -226, 137, -250, -108, -96, -110, -233, 72, 54, 137, -249, -98, -132, -104, 72, 137, -11, 137, -51, -125, -55, -227, 72, 137, -169, 72, -54, 137, -197, 137, -221, 137, 72, -119, -179, 186, -5, 137, -194, -235, -211, -50, -167, -242, -225, 221, 16, 72, 137, -247, -216, -224, 137, 72, -222, -201, 72, -171, -240, -198, 272, -236, 231, 72, 137, -212, -174, -10, 137, -147, 264, 137, -246, -22, -237, -16, 137, 72, 72, 16, -251, -176, 137, 409, 72, 72, -90, -230, -93, -155, -126, -20, -8, 137, 137, -127, -175, -200, -202, 72, -92, -254, 72, -121, -6, -232, 137, -24, -208, -163, -177, 16, -146, -154, 72, 137, 137, -118, -9, -214, -23, -112, -95, 304, ]), 'STRUCT': ([15, 17, 140, 64, 221, 277, 238, 186, 39, 359, 12, 165, 283, 26, 360, 87, 170, 18, 227, 278, 37, 3, 27, 31, 123, 59, 54, 66, 32, 72, 237, 116, 231, 38, 242, 10, 51, 67, 117, 1, 235, 5, 353, 22, 260, 134, 205, 36, 269, 230, 133, 280, 356, 6, 28
 6, 73, 25, 327, 137, 279, 169, 56, 339, 65, 358, 0, 4, 35, 387, 196, 47, 60, 130, 9, 13, 172, 20, 49, 81, 30, 332, 23, 58, 163, 167, 52, 34, 168, 287, 2, 8, 28, ], [-2, -130, 33, 33, 33, -243, -169, 33, -121, -251, -118, -244, -144, -166, -252, 33, -141, -126, -154, 33, -132, 33, 33, -127, -173, 33, 33, 33, -242, 33, 33, -254, 33, -164, -219, -119, -104, -137, -168, 33, -172, -131, -135, -3, -218, -223, -249, -129, -221, -171, -245, -136, -143, -122, 33, -247, -120, 33, 33, -142, 33, -246, -220, -138, -134, -1, -163, -128, -253, -248, 33, 33, -170, -124, -133, 33, -167, -165, 33, -241, -155, -117, -222, -217, 33, -156, -125, 33, -250, 33, -123, 33, ]), ',': ([182, 244, 274, 90, 39, 100, 300, 372, 313, 395, 185, 318, 390, 345, 386, 370, 311, 38, 403, 347, 65, 75, 234, 4, 45, 106, 421, 323, 355, 220, 92, 315, 376, 238, 110, 402, 321, 13, 74, 301, 362, 132, 117, 173, 127, 235, 34, 96, 314, 423, 280, 213, 295, 142, 85, 331, 121, 177, 8, 49, 126, 179, 296, 25, 337, 3, 180, 5, 31, 322, 52
 , 112, 366, 422, 119, 398, 330, 388, 77, 383, 101, 41, 67, 316, 416, 162, 86, 374, 128, 123, 417, 364, 230, 102, 68, 305, 281, 307, 9, 35, 352, 20, 306, 332, 61, 122, 308, 26, 78, 6, 401, 275, 392, 43, 389, 297, 418, 28, 317, 343, 148, 184, 358, 368, 97, 400, 129, 155, 36, 42, 104, 419, 291, 124, 2, 64, 312, 410, 353, 282, 175, 292, 333, 10, 335, 391, 181, 62, 299, 89, 115, 232, 17, 285, 404, 12, 18, 44, 303, 385, 341, 334, 211, 83, 298, 37, 63, 351, 393, 223, 69, 363, 105, 412, 7, 130, 23, 84, 302, 109, 91, 420, 71, 309, 319, 217, 273, 350, 227, 99, 371, 233, 324, 320, 160, 310, ], [-44, 262, -116, -11, -121, -22, -66, -201, -5, 262, -47, -24, -31, 262, -150, -200, -75, -164, -37, 262, -138, -18, -191, -163, -176, -78, -36, 262, -152, -46, -84, -77, -196, -169, -49, -39, 262, -133, -20, -67, -256, -115, -168, -255, -186, -172, -125, -73, -7, -35, -136, -28, -63, -56, -62, -193, -161, 262, -123, -165, -182, -15, -64, -120, -183, -111, -16, -131, -127, -85, -156, -86, -25, 411, -159,
  262, -195, -32, -9, -204, -76, -108, -137, -26, 262, -88, -68, -197, 236, -173, -38, -48, -171, -4, -179, -71, -149, -72, -124, -128, 384, -167, -69, -155, -110, 229, -70, -166, -56, -122, -205, -203, -202, -175, -36, -59, 411, -109, -27, -102, 262, -45, -134, -23, -58, -207, 237, -4, -129, -112, -10, -40, -81, -187, -107, -115, -74, -33, -135, -151, 290, -21, -162, -119, -188, -87, -14, -113, -60, -80, -103, -185, -130, 357, 411, -118, -126, -178, -83, -153, -89, -160, -29, -65, -61, -132, 164, -206, -198, -192, -177, -57, -13, -36, -174, -170, -117, -12, -79, -43, -19, -34, -82, -8, -30, -17, -114, 262, -154, -16, -194, -184, -199, 367, -101, -6, ]), 'LONG': ([237, 286, 52, 51, 56, 31, 36, 353, 134, 205, 87, 9, 18, 287, 356, 67, 358, 17, 230, 130, 54, 123, 37, 27, 116, 35, 22, 10, 242, 137, 165, 231, 196, 278, 186, 277, 58, 3, 38, 283, 64, 23, 72, 238, 32, 47, 172, 59, 39, 4, 360, 117, 81, 140, 12, 260, 387, 168, 25, 5, 0, 167, 169, 66, 227, 327, 28, 280, 65, 8, 30, 339, 34, 73, 
 13, 279, 26, 6, 133, 359, 269, 49, 221, 170, 15, 20, 332, 235, 60, 2, 163, 1, ], [18, 18, -156, -104, -246, -127, -129, -135, -223, -249, 18, -124, -126, -250, -143, -137, -134, -130, -171, -170, 18, -173, -132, 18, -254, -128, -3, -119, -219, 18, -244, 18, -248, 18, 18, -243, -222, 18, -164, -144, 18, -117, 18, -169, -242, 18, 18, 18, -121, -163, -252, -168, 18, 18, -118, -218, -253, 18, -120, -131, -1, 18, 18, 18, -154, 18, 18, -136, -138, -123, -241, -220, -125, -247, -133, -142, -166, -122, -245, -251, -221, -165, 18, -141, -2, -167, -155, -172, 18, 18, -217, 18, ]), 'ELLIPSIS': ([237, ], [336, ]), '<': ([423, 217, 301, 364, 109, 366, 313, 420, 368, 295, 85, 77, 102, 305, 292, 388, 96, 90, 184, 314, 312, 181, 104, 363, 316, 297, 299, 317, 155, 99, 213, 142, 91, 105, 179, 309, 78, 75, 410, 310, 182, 296, 306, 97, 185, 86, 298, 211, 83, 311, 300, 100, 308, 307, 318, 74, 84, 220, 180, 110, ], [-35, -17, -67, -48, -43, -25, -5, -34, -23, -63, -62, -9, -4, -71, -21, -32, 202, -11, -4
 5, -7, 202, -14, -10, -57, -26, -59, -60, -27, -4, -16, -28, -56, -19, -13, -15, -8, -56, -18, -33, -6, -44, -64, -69, -58, -47, -68, -61, -29, -65, 202, -66, -22, -70, -72, -24, -20, -12, -46, -16, -49, ]), 'GOTO': ([136, 394, 263, 153, 415, 399, 338, 414, 163, 268, 269, 260, 261, 51, 243, 258, 135, 159, 405, 60, 344, 147, 270, 58, 413, 240, 140, 408, 406, 346, 267, 348, 396, 259, 134, 397, 154, 242, 340, 378, 144, 143, 380, 379, 382, 339, 158, 139, ], [-212, 138, 138, -224, -230, -229, -236, -233, -217, -238, -221, -218, -227, -104, -239, -237, -210, -211, -234, 138, -216, 138, -228, -222, -235, 138, 138, 138, 138, 138, 138, -214, -232, -225, -223, -231, -213, -219, -240, 138, -226, -209, 138, -215, 138, -220, 138, -208, ]), 'ENUM': ([59, 3, 8, 327, 130, 72, 10, 260, 172, 169, 332, 13, 231, 9, 73, 279, 167, 163, 356, 81, 230, 137, 116, 47, 238, 269, 227, 133, 117, 37, 12, 170, 221, 237, 34, 87, 2, 360, 280, 66, 58, 168, 242, 277, 65, 23, 39, 28, 20, 22, 196, 5, 18, 32, 15, 31, 278
 , 1, 17, 205, 283, 123, 52, 25, 51, 6, 67, 30, 358, 35, 287, 339, 235, 60, 36, 387, 38, 54, 0, 165, 26, 64, 56, 359, 140, 353, 4, 134, 186, 49, 27, 286, ], [24, 24, -123, 24, -170, 24, -119, -218, 24, 24, -155, -133, 24, -124, -247, -142, 24, -217, -143, 24, -171, 24, -254, 24, -169, -221, -154, -245, -168, -132, -118, -141, 24, 24, -125, 24, 24, -252, -136, 24, -222, 24, -219, -243, -138, -117, -121, 24, -167, -3, -248, -131, -126, -242, -2, -127, 24, 24, -130, -249, -144, -173, -156, -120, -104, -122, -137, -241, -134, -128, -250, -220, -172, 24, -129, -253, -164, 24, -1, -244, -166, 24, -246, -251, 24, -135, -163, -223, 24, -165, 24, 24, ]), 'PERIOD': ([104, 309, 84, 109, 105, 91, 90, 179, 99, 213, 313, 77, 211, 155, 75, 100, 366, 310, 292, 368, 180, 217, 318, 317, 314, 181, 316, 102, 74, ], [-10, -8, -12, 212, -13, -19, -11, -15, -16, -28, -5, -9, -29, -4, -18, -22, -25, -6, -21, -23, -16, -17, -24, -27, -7, -14, -26, -4, -20, ]), 'PP_END_DEFINE': ([310, 306, 311, 100, 36, 101, 
 112, 91, 361, 115, 74, 292, 88, 114, 371, 307, 84, 289, 280, 65, 83, 331, 17, 318, 5, 330, 391, 308, 305, 316, 6, 368, 364, 110, 358, 195, 388, 96, 97, 44, 312, 332, 303, 315, 86, 322, 180, 302, 222, 288, 353, 223, 43, 291, 67, 220, 179, 370, 317, 7, 366, 423, 182, 181, 31, 314, 4, 69, 106, 81, 71, 18, 372, 35, 309, 37, 217, 109, 313, 8, 75, 376, 187, 105, 393, 363, 52, 48, 211, 301, 298, 102, 184, 38, 185, 45, 77, 13, 68, 324, 227, 392, 420, 174, 104, 213, 225, 9, 90, 297, 410, 300, 47, 99, 374, 89, 85, 296, 92, 87, 34, 299, 78, 98, 295, ], [-6, -69, -75, -22, -129, -76, -86, -19, 387, -103, -20, -21, 196, -189, -194, -72, -12, 360, -136, -138, -65, -193, -130, -24, -131, -195, -87, -70, -71, -26, -122, -23, -48, -49, -134, -147, -32, -73, -58, -178, -74, -155, -83, -77, -68, -85, -16, -79, -190, 359, -135, -192, -175, -81, -137, -46, -15, -200, -27, -174, -25, -35, -44, -14, -127, -7, -163, -177, -78, -146, -82, -126, -201, -128, -8, -132, -17, -43, -5, -123, -18, -196, -145, -13,
  -198, -57, -156, 116, -29, -67, -61, -4, -45, -164, -47, -176, -9, -133, -179, -199, -154, -202, -34, 287, -10, -28, -191, -124, -11, -59, -33, -66, 73, -16, -197, -80, -62, -64, -84, -148, -125, -60, -56, 205, -63, ]), 'LEFT_OP': ([423, 142, 110, 299, 309, 308, 77, 292, 306, 75, 295, 305, 388, 86, 179, 217, 91, 364, 155, 220, 180, 105, 310, 213, 410, 104, 366, 90, 313, 211, 317, 97, 100, 316, 182, 84, 85, 298, 420, 296, 318, 314, 363, 185, 83, 184, 368, 74, 300, 307, 99, 181, 102, 109, 297, 301, 78, ], [-35, -56, -49, -60, -8, 193, -9, -21, 193, -18, -63, 193, -32, 193, -15, -17, -19, -48, -4, -46, -16, -13, -6, -28, -33, -10, -25, -11, -5, -29, -27, -58, -22, -26, -44, -12, -62, -61, -34, -64, -24, -7, -57, -47, -65, -45, -23, -20, -66, 193, -16, -14, -4, -43, -59, -67, -56, ]), 'DOUBLE': ([6, 278, 221, 4, 2, 27, 18, 286, 279, 186, 0, 358, 1, 10, 116, 327, 35, 140, 227, 37, 65, 167, 8, 9, 81, 353, 54, 73, 28, 280, 47, 133, 360, 66, 170, 20, 36, 58, 230, 64, 283, 231, 168, 169, 67
 , 56, 39, 72, 196, 130, 238, 12, 13, 31, 137, 242, 5, 277, 134, 387, 49, 172, 22, 3, 23, 332, 25, 38, 60, 356, 165, 15, 205, 237, 87, 30, 339, 34, 52, 59, 163, 269, 287, 26, 235, 32, 51, 260, 117, 17, 123, 359, ], [-122, 35, 35, -163, 35, 35, -126, 35, -142, 35, -1, -134, 35, -119, -254, 35, -128, 35, -154, -132, -138, 35, -123, -124, 35, -135, 35, -247, 35, -136, 35, -245, -252, 35, -141, -167, -129, -222, -171, 35, -144, 35, 35, 35, -137, -246, -121, 35, -248, -170, -169, -118, -133, -127, 35, -219, -131, -243, -223, -253, -165, 35, -3, 35, -117, -155, -120, -164, 35, -143, -244, -2, -249, 35, 35, -241, -220, -125, -156, 35, -217, -221, -250, -166, -172, -242, -104, -218, -168, -130, -173, -251, ]), 'INC_OP': ([210, 189, 255, 264, 159, 378, 188, 348, 366, 397, 245, 270, 408, 328, 102, 252, 317, 399, 316, 174, 224, 213, 242, 267, 191, 99, 380, 109, 140, 134, 415, 284, 163, 192, 257, 181, 256, 249, 77, 381, 346, 396, 262, 55, 84, 215, 94, 135, 394, 384, 247, 217, 208, 377, 379, 166,
  216, 74, 113, 259, 183, 91, 139, 251, 276, 155, 344, 180, 137, 413, 151, 266, 80, 190, 340, 405, 219, 248, 313, 47, 76, 141, 207, 153, 254, 79, 369, 338, 158, 318, 198, 197, 105, 204, 409, 269, 243, 60, 268, 176, 100, 202, 194, 143, 258, 51, 211, 90, 240, 144, 414, 228, 293, 107, 201, 367, 246, 179, 310, 58, 289, 339, 103, 218, 368, 382, 272, 261, 75, 104, 260, 253, 147, 309, 186, 72, 203, 82, 342, 136, 108, 250, 406, 154, 314, 193, 263, 292, 354, 95, ], [76, 76, -97, 76, -211, 76, 76, -214, -25, -231, -95, -228, 76, 76, -4, -96, -27, -229, -26, 76, 76, -28, -219, 76, 76, -16, 76, 213, 76, -223, -230, 76, -217, 76, 76, -14, 76, -98, -9, 76, 76, -232, 76, 76, -12, 76, -50, -210, 76, 76, -99, -17, 76, 76, -215, 76, 76, -20, 76, -225, 76, -19, -208, -92, 76, -4, -216, -16, 76, -235, 76, 76, 76, 76, -240, -234, 76, -100, -5, 76, 76, 76, 76, -224, -94, 76, 76, -236, 76, -24, 76, 76, -13, 76, 76, -221, -239, 76, -238, 76, -22, 76, 76, -209, -237, -104, -29, -11, 76, -226, -233, 76, 76, -
 55, 76, 76, -93, -15, -6, -222, 76, -220, -54, 76, -23, 76, 76, -227, -18, -10, -218, -90, 76, -8, 76, 76, 76, -52, 76, -212, -53, -91, 76, -213, -7, 76, 76, -21, 76, -51, ]), '|': ([316, 109, 105, 420, 104, 155, 314, 213, 301, 297, 317, 89, 296, 182, 85, 308, 309, 78, 305, 423, 211, 368, 300, 388, 100, 313, 96, 86, 97, 184, 185, 74, 315, 180, 311, 307, 292, 84, 366, 363, 77, 99, 181, 299, 142, 364, 303, 75, 310, 295, 306, 291, 91, 179, 102, 298, 83, 410, 318, 90, 220, 217, 110, 106, 312, 101, 302, 71, ], [-26, -43, -13, -34, -10, -4, -7, -28, -67, -59, -27, -80, -64, -44, -62, -70, -8, -56, -71, -35, -29, -23, -66, -32, -22, -5, -73, -68, -58, -45, -47, -20, -77, -16, -75, -72, -21, -12, -25, -57, -9, -16, -14, -60, -56, -48, 176, -18, -6, -63, -69, -81, -19, -15, -4, -61, -65, -33, -24, -11, -46, -17, -49, -78, -74, -76, -79, 176, ]), 'NE_OP': ([109, 364, 105, 213, 182, 297, 420, 104, 78, 317, 410, 313, 85, 155, 309, 74, 296, 86, 316, 101, 308, 97, 185, 423, 368, 300, 388, 100, 96
 , 184, 180, 211, 292, 305, 77, 84, 142, 311, 181, 307, 301, 310, 363, 99, 306, 298, 318, 90, 314, 75, 299, 110, 295, 91, 217, 179, 220, 83, 315, 102, 366, 312, ], [-43, -48, -13, -28, -44, -59, -34, -10, -56, -27, -33, -5, -62, -4, -8, -20, -64, -68, -26, 207, -70, -58, -47, -35, -23, -66, -32, -22, -73, -45, -16, -29, -21, -71, -9, -12, -56, -75, -14, -72, -67, -6, -57, -16, -69, -61, -24, -11, -7, -18, -60, -49, -63, -19, -17, -15, -46, -65, 207, -4, -25, -74, ]), 'SHORT': ([10, 81, 51, 36, 13, 339, 26, 27, 8, 30, 387, 196, 356, 230, 12, 231, 278, 260, 163, 54, 123, 67, 1, 170, 286, 73, 287, 242, 18, 15, 47, 0, 87, 6, 221, 34, 3, 37, 279, 137, 269, 238, 283, 327, 56, 58, 277, 31, 17, 59, 72, 205, 237, 9, 38, 20, 235, 169, 23, 167, 227, 186, 130, 168, 133, 165, 134, 49, 332, 22, 116, 35, 4, 353, 32, 64, 66, 140, 39, 25, 52, 280, 2, 28, 5, 172, 117, 358, 359, 65, 60, 360, ], [-119, 9, -104, -129, -133, -220, -166, 9, -123, -241, -253, -248, -143, -171, -118, 9, 9, -218, -217, 9, -17
 3, -137, 9, -141, 9, -247, -250, -219, -126, -2, 9, -1, 9, -122, 9, -125, 9, -132, -142, 9, -221, -169, -144, 9, -246, -222, -243, -127, -130, 9, 9, -249, 9, -124, -164, -167, -172, 9, -117, 9, -154, 9, -170, 9, -245, -244, -223, -165, -155, -3, -254, -128, -163, -135, -242, 9, 9, 9, -121, -120, -156, -136, 9, 9, -131, 9, -168, -134, -251, -138, 9, -252, ]), 'CONSTANT': ([55, 257, 163, 47, 144, 328, 263, 190, 197, 140, 399, 251, 176, 266, 354, 76, 203, 367, 409, 381, 137, 284, 378, 58, 192, 240, 174, 408, 380, 270, 51, 94, 154, 267, 369, 151, 253, 260, 259, 72, 250, 191, 258, 82, 242, 208, 248, 183, 202, 228, 60, 276, 194, 153, 166, 193, 136, 224, 159, 269, 158, 80, 396, 339, 204, 216, 377, 261, 107, 198, 346, 384, 188, 406, 338, 201, 141, 340, 147, 348, 186, 249, 215, 382, 219, 139, 207, 414, 394, 254, 262, 218, 247, 256, 344, 246, 415, 210, 143, 245, 413, 289, 135, 113, 79, 379, 252, 189, 272, 134, 293, 405, 255, 268, 264, 342, 103, 397, 243, 95, 108, ], [77, 77, -217, 77, -226, 7
 7, 77, 77, 77, 77, -229, -92, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, -222, 77, 77, 77, 77, 77, -228, -104, -50, -213, 77, 77, 77, -90, -218, -225, 77, -91, 77, -237, -52, -219, 77, -100, 77, 77, 77, 77, 77, 77, -224, 77, 77, -212, 77, -211, -221, 77, 77, -232, -220, 77, 77, 77, -227, -55, 77, 77, 77, 77, 77, -236, 77, 77, -240, 77, -214, 77, -98, 77, 77, 77, -208, 77, -233, 77, -94, 77, 77, -99, 77, -216, -93, -230, 77, -209, -95, -235, 77, -210, 77, 77, -215, -96, 77, 77, -223, 77, -234, -97, -238, 77, 77, -54, -231, -239, -51, -53, ]), 'DEC_OP': ([397, 192, 190, 252, 258, 245, 109, 268, 90, 219, 246, 228, 211, 75, 250, 95, 409, 240, 249, 113, 270, 405, 256, 94, 310, 55, 316, 313, 100, 47, 276, 198, 269, 254, 259, 99, 354, 263, 314, 140, 379, 134, 208, 257, 266, 74, 108, 144, 76, 155, 215, 255, 210, 166, 193, 158, 413, 253, 176, 309, 243, 340, 396, 204, 186, 135, 213, 292, 247, 203, 348, 179, 107, 378, 242, 163, 394, 139, 218, 217, 79, 328, 384, 201, 194, 105, 143, 154, 82, 28
 4, 382, 137, 414, 260, 181, 103, 147, 191, 174, 262, 102, 408, 51, 202, 58, 267, 369, 289, 91, 72, 261, 399, 344, 338, 159, 248, 272, 264, 104, 293, 342, 188, 197, 153, 180, 381, 380, 84, 346, 207, 317, 224, 251, 151, 339, 216, 80, 367, 318, 406, 415, 189, 368, 366, 377, 141, 136, 77, 183, 60, ], [-231, 79, 79, -96, -237, -95, 211, -238, -11, 79, -93, 79, -29, -18, -91, -51, 79, 79, -98, 79, -228, -234, 79, -50, -6, 79, -26, -5, -22, 79, 79, 79, -221, -94, -225, -16, 79, 79, -7, 79, -215, -223, 79, 79, 79, -20, -53, -226, 79, -4, 79, -97, 79, 79, 79, 79, -235, -90, 79, -8, -239, -240, -232, 79, 79, -210, -28, -21, -99, 79, -214, -15, -55, 79, -219, -217, 79, -208, 79, -17, 79, 79, 79, 79, 79, -13, -209, -213, -52, 79, 79, 79, -233, -218, -14, -54, 79, 79, 79, 79, -4, 79, -104, 79, -222, 79, 79, 79, -19, 79, -227, -229, -216, -236, -211, -100, 79, 79, -10, 79, 79, 79, 79, -224, -16, 79, 79, -12, 79, 79, -27, 79, -92, 79, -220, 79, 79, 79, -24, 79, -230, 79, -23, -25, 79, 79, -212, -9
 , 79, 79, ]), 'STATIC': ([358, 130, 123, 49, 360, 327, 117, 37, 28, 25, 140, 3, 235, 359, 30, 205, 0, 237, 230, 6, 58, 339, 9, 27, 31, 12, 4, 8, 22, 39, 35, 1, 134, 56, 242, 387, 18, 51, 238, 32, 13, 64, 38, 36, 163, 59, 10, 60, 5, 260, 2, 287, 167, 221, 20, 52, 332, 227, 73, 17, 15, 280, 54, 196, 26, 116, 23, 67, 269, 65, 277, 353, 34, 133, 165, 231, ], [-134, -170, -173, -165, -252, 10, -168, -132, 10, -120, 10, 10, -172, -251, -241, -249, -1, 10, -171, -122, -222, -220, -124, 10, -127, -118, -163, -123, -3, -121, -128, 10, -223, -246, -219, -253, -126, -104, -169, -242, -133, 10, -164, -129, -217, 10, -119, 10, -131, -218, 10, -250, 10, 10, -167, -156, -155, -154, -247, -130, -2, -136, 10, -248, -166, -254, -117, -137, -221, -138, -243, -135, -125, -245, -244, 10, ]), 'EQ_OP': ([100, 308, 311, 314, 101, 301, 185, 423, 99, 307, 90, 142, 297, 77, 410, 220, 96, 78, 110, 295, 97, 298, 84, 184, 74, 363, 104, 83, 312, 299, 318, 315, 213, 366, 182, 305, 292, 364, 309, 300, 86, 316, 155,
  180, 306, 109, 85, 388, 296, 313, 105, 91, 181, 179, 211, 310, 102, 217, 420, 317, 368, 75, ], [-22, -70, -75, -7, 208, -67, -47, -35, -16, -72, -11, -56, -59, -9, -33, -46, -73, -56, -49, -63, -58, -61, -12, -45, -20, -57, -10, -65, -74, -60, -24, 208, -28, -25, -44, -71, -21, -48, -8, -66, -68, -26, -4, -16, -69, -43, -62, -32, -64, -5, -13, -19, -14, -15, -29, -6, -4, -17, -34, -27, -23, -18, ]), 'SIZEOF': ([80, 203, 192, 268, 247, 107, 284, 191, 396, 219, 253, 249, 339, 95, 415, 406, 381, 60, 269, 346, 190, 264, 243, 82, 263, 259, 207, 151, 158, 405, 163, 147, 58, 197, 262, 141, 55, 218, 266, 76, 137, 51, 293, 204, 188, 270, 245, 79, 380, 193, 378, 72, 342, 134, 240, 413, 379, 255, 246, 369, 338, 367, 408, 143, 103, 144, 250, 414, 377, 153, 409, 272, 251, 113, 397, 139, 216, 94, 267, 210, 194, 215, 166, 384, 189, 140, 260, 183, 174, 108, 394, 276, 201, 136, 399, 261, 256, 252, 328, 135, 248, 242, 154, 254, 186, 159, 257, 208, 340, 47, 354, 198, 289, 228, 258, 224, 382, 348, 176
 , 344, 202, ], [80, 80, 80, -238, -99, -55, 80, 80, -232, 80, -90, -98, -220, -51, -230, 80, 80, 80, -221, 80, 80, 80, -239, -52, 80, -225, 80, 80, 80, -234, -217, 80, -222, 80, 80, 80, 80, 80, 80, 80, 80, -104, 80, 80, 80, -228, -95, 80, 80, 80, 80, 80, 80, -223, 80, -235, -215, -97, -93, 80, -236, 80, 80, -209, -54, -226, -91, -233, 80, -224, 80, 80, -92, 80, -231, -208, 80, -50, 80, 80, 80, 80, 80, 80, 80, 80, -218, 80, 80, -53, 80, 80, 80, -212, -229, -227, 80, -96, 80, -210, -100, -219, -213, -94, 80, -211, 80, 80, -240, 80, 80, 80, 80, 80, -237, 80, 80, -214, 80, -216, 80, ]), '+': ([208, 109, 289, 245, 191, 60, 110, 405, 147, 144, 293, 252, 183, 269, 409, 268, 217, 318, 354, 100, 94, 105, 192, 246, 314, 83, 295, 243, 317, 414, 310, 248, 420, 179, 107, 264, 363, 316, 298, 366, 377, 276, 134, 301, 79, 99, 136, 257, 256, 166, 55, 84, 140, 190, 253, 261, 260, 339, 186, 213, 210, 263, 266, 182, 193, 348, 378, 368, 242, 142, 408, 309, 51, 394, 215, 296, 197, 284, 249, 113, 153, 299
 , 155, 340, 396, 204, 344, 218, 254, 228, 194, 159, 211, 85, 75, 154, 82, 135, 313, 220, 247, 240, 181, 180, 97, 74, 369, 262, 47, 207, 384, 258, 381, 76, 103, 216, 90, 80, 143, 388, 415, 379, 410, 338, 342, 267, 141, 270, 78, 72, 201, 300, 108, 91, 176, 399, 382, 406, 292, 189, 297, 188, 95, 203, 77, 272, 413, 163, 380, 104, 174, 102, 397, 139, 346, 328, 202, 224, 251, 151, 259, 185, 184, 137, 58, 367, 423, 198, 364, 158, 255, 219, 250, ], [82, -43, 82, -95, 82, 82, -49, -234, 82, -226, 82, -96, 82, -221, 82, -238, -17, -24, 82, -22, -50, -13, 82, -93, -7, 188, -63, -239, -27, -233, -6, -100, -34, -15, -55, 82, -57, -26, -61, -25, 82, 82, -223, 188, 82, -16, -212, 82, 82, 82, 82, -12, 82, 82, -90, -227, -218, -220, 82, -28, 82, 82, 82, -44, 82, -214, 82, -23, -219, -56, 82, -8, -104, 82, 82, -64, 82, 82, -98, 82, -224, -60, -4, -240, -232, 82, -216, 82, -94, 82, 82, -211, -29, -62, -18, -213, -52, -210, -5, -46, -99, 82, -14, -16, -58, -20, 82, 82, 82, 82, 82, -237, 82, 82, -54, 82
 , -11, 82, -209, -32, -230, -215, -33, -236, 82, 82, 82, -228, -56, 82, 82, 188, -53, -19, 82, -229, 82, 82, -21, 82, -59, 82, -51, 82, -9, 82, -235, -217, 82, -10, 82, -4, -231, -208, 82, 82, 82, 82, -92, 82, -225, -47, -45, 82, -222, 82, -35, 82, -48, 82, -97, 82, -91, ]), 'UNSIGNED': ([36, 235, 52, 8, 133, 18, 66, 287, 35, 170, 20, 49, 221, 205, 358, 22, 2, 10, 353, 277, 242, 231, 73, 140, 64, 67, 59, 39, 87, 134, 54, 196, 356, 137, 186, 283, 47, 3, 359, 165, 5, 60, 38, 227, 230, 116, 360, 4, 278, 65, 37, 32, 28, 12, 172, 23, 81, 387, 167, 17, 327, 13, 130, 27, 58, 168, 51, 30, 31, 0, 169, 117, 56, 279, 1, 237, 339, 238, 280, 260, 26, 286, 6, 72, 34, 123, 25, 163, 269, 9, 332, 15, ], [-129, -172, -156, -123, -245, -126, 17, -250, -128, -141, -167, -165, 17, -249, -134, -3, 17, -119, -135, -243, -219, 17, -247, 17, 17, -137, 17, -121, 17, -223, 17, -248, -143, 17, 17, -144, 17, 17, -251, -244, -131, 17, -164, -154, -171, -254, -252, -163, 17, -138, -132, -242, 17, -118, 17, -117, 
 17, -253, 17, -130, 17, -133, -170, 17, -222, 17, -104, -241, -127, -1, 17, -168, -246, -142, 17, 17, -220, -169, -136, -218, -166, 17, -122, 17, -125, -173, -120, -217, -221, -124, -155, -2, ]), '/': ([84, 99, 155, 180, 77, 90, 368, 142, 388, 211, 75, 109, 217, 292, 313, 364, 91, 100, 423, 317, 78, 314, 295, 410, 213, 297, 102, 105, 110, 363, 184, 104, 309, 316, 318, 298, 97, 185, 420, 181, 310, 74, 179, 296, 299, 220, 182, 85, 366, ], [-12, -16, -4, -16, -9, -11, -23, -56, -32, -29, -18, -43, -17, -21, -5, -48, -19, -22, -35, -27, -56, -7, 192, -33, -28, -59, -4, -13, -49, -57, -45, -10, -8, -26, -24, -61, -58, -47, -34, -14, -6, -20, -15, 192, -60, -46, -44, 192, -25, ]), ';': ([42, 130, 90, 285, 316, 341, 38, 77, 63, 401, 67, 312, 342, 134, 301, 5, 182, 75, 4, 348, 52, 309, 397, 280, 83, 12, 17, 240, 303, 60, 317, 148, 74, 405, 162, 25, 263, 298, 2, 385, 311, 257, 158, 185, 306, 241, 99, 28, 184, 136, 10, 235, 410, 353, 36, 302, 299, 243, 117, 261, 84, 144, 260, 35, 220, 49, 380
 , 181, 64, 269, 339, 268, 26, 57, 242, 105, 6, 160, 34, 413, 135, 296, 414, 143, 87, 3, 244, 382, 19, 292, 155, 29, 115, 132, 217, 146, 163, 37, 106, 346, 8, 123, 408, 211, 140, 85, 310, 154, 171, 65, 343, 153, 338, 391, 91, 386, 179, 364, 314, 230, 399, 156, 363, 394, 187, 61, 238, 275, 109, 407, 180, 300, 41, 388, 270, 89, 18, 100, 379, 308, 396, 322, 97, 213, 273, 96, 23, 58, 71, 159, 81, 318, 281, 378, 142, 104, 258, 51, 102, 139, 62, 355, 112, 110, 147, 332, 20, 195, 420, 157, 297, 315, 13, 340, 274, 344, 291, 305, 78, 9, 358, 282, 313, 239, 86, 415, 31, 259, 295, 92, 307, 423, 39, 383, 267, 141, 406, 368, 227, 101, 366, ], [-112, -170, -11, 356, -26, -89, -164, -9, -106, -205, -137, -74, 144, -223, -67, -131, -44, -18, -163, -214, -156, -8, -231, -136, -65, -118, -130, 144, -83, 144, -27, 261, -20, -234, -88, -120, 144, -61, -107, -153, -75, 144, 144, -47, -69, 270, -16, -109, -45, -212, -119, -172, -33, -135, -129, -79, -60, -239, -168, -227, -12, -226, -218, -128, -46, -165,
  144, -14, -115, -221, -220, -238, -166, -105, -219, -13, -122, -101, -125, -235, -210, -64, -233, -209, -148, -111, 340, 144, 51, -21, -4, -105, -103, -115, -17, 258, -217, -132, -78, 144, -123, -173, 144, -29, 144, -62, -6, -213, 283, -138, -102, -224, -236, -87, -19, -150, -15, -48, -7, -171, -229, 268, -57, 144, -145, -110, -169, -203, -43, 414, -16, -66, -108, -32, -228, -80, -126, -22, -215, -70, -232, -85, -58, -28, -114, -73, -117, -222, -82, -211, -146, -24, -149, 144, -56, -10, -237, -104, -4, -208, -113, -152, -86, -49, 144, -155, -167, -147, -34, 270, -59, -77, -133, -240, -116, -216, -81, -71, -56, -124, -134, -151, -5, 338, -68, -230, -127, -225, -63, -84, -72, -35, -121, -204, 144, 243, 144, -23, -154, -76, -25, ]), '?': ([85, 155, 302, 77, 99, 91, 410, 90, 388, 100, 211, 96, 92, 217, 179, 101, 97, 420, 423, 89, 303, 317, 363, 110, 184, 313, 74, 180, 309, 291, 102, 305, 112, 185, 368, 301, 86, 297, 181, 142, 104, 78, 318, 314, 310, 306, 315, 84, 298, 312, 300, 220, 18
 2, 311, 307, 83, 366, 299, 75, 106, 295, 109, 316, 292, 105, 296, 364, 308, 322, 213, 71, ], [-62, -4, -79, -9, -16, -19, -33, -11, -32, -22, -29, -73, -84, -17, -15, -76, -58, -34, -35, -80, -83, -27, -57, -49, -45, -5, -20, -16, -8, -81, -4, -71, 219, -47, -23, -67, -68, -59, -14, -56, -10, -56, -24, -7, -6, -69, -77, -12, -61, -74, -66, -46, -44, -75, -72, -65, -25, -60, -18, -78, -63, -43, -26, -21, -13, -64, -48, -70, -85, -28, -82, ]), '$end': ([73, 339, 15, 165, 51, 359, 1, 0, 133, 387, 287, 116, 56, 32, 22, 277, 269, 242, 260, 196, 360, 30, 205, 163, ], [-247, -220, -2, -244, -104, -251, 0, -1, -245, -253, -250, -254, -246, -242, -3, -243, -221, -219, -218, -248, -252, -241, -249, -217, ]), 'FOR': ([340, 60, 135, 144, 268, 153, 143, 139, 338, 396, 378, 147, 346, 58, 397, 136, 260, 413, 394, 406, 339, 159, 134, 348, 154, 242, 51, 263, 259, 379, 158, 267, 344, 405, 408, 380, 163, 140, 240, 382, 261, 243, 415, 269, 399, 258, 270, 414, ], [-240, 145, -210, -226, -238, -224, -209
 , -208, -236, -232, 145, 145, 145, -222, -231, -212, -218, -235, 145, 145, -220, -211, -223, -214, -213, -219, -104, 145, -225, -215, 145, 145, -216, -234, 145, 145, -217, 145, 145, 145, -227, -239, -230, -221, -229, -237, -228, -233, ]), 'UNION': ([65, 242, 238, 37, 278, 287, 260, 13, 3, 23, 81, 137, 58, 387, 30, 34, 186, 56, 1, 140, 51, 66, 205, 38, 130, 116, 170, 269, 227, 64, 172, 72, 22, 17, 36, 286, 12, 280, 332, 39, 230, 353, 163, 0, 8, 60, 27, 35, 169, 5, 123, 231, 67, 10, 52, 20, 221, 47, 327, 32, 15, 358, 283, 73, 18, 26, 59, 167, 134, 235, 49, 168, 6, 9, 4, 359, 339, 237, 31, 277, 279, 360, 25, 133, 356, 165, 2, 87, 54, 28, 196, 117, ], [-138, -219, -169, -132, 21, -250, -218, -133, 21, -117, 21, 21, -222, -253, -241, -125, 21, -246, 21, 21, -104, 21, -249, -164, -170, -254, -141, -221, -154, 21, 21, 21, -3, -130, -129, 21, -118, -136, -155, -121, -171, -135, -217, -1, -123, 21, 21, -128, 21, -131, -173, 21, -137, -119, -156, -167, 21, 21, 21, -242, -2, -134, -144, -247, 
 -126, -166, 21, 21, -223, -172, -165, 21, -122, -124, -163, -251, -220, 21, -127, -243, -142, -252, -120, -245, -143, -244, 21, 21, 21, 21, -248, -168, ]), 'ELSE': ([340, 269, 339, 258, 399, 159, 413, 136, 139, 414, 261, 415, 243, 397, 396, 163, 135, 348, 154, 344, 268, 338, 242, 144, 270, 405, 260, 143, 379, ], [-240, -221, -220, -237, 408, -211, -235, -212, -208, -233, -227, -230, -239, -231, -232, -217, -210, -214, -213, -216, -238, -236, -219, -226, -228, -234, -218, -209, -215, ]), '[': ([316, 376, 102, 313, 7, 44, 105, 4, 332, 104, 324, 25, 37, 353, 8, 13, 155, 2, 317, 81, 41, 18, 45, 117, 65, 231, 238, 43, 84, 3, 331, 38, 221, 49, 393, 318, 100, 34, 127, 74, 368, 20, 99, 77, 195, 69, 36, 370, 12, 28, 314, 109, 39, 371, 31, 330, 366, 234, 10, 180, 213, 5, 35, 309, 280, 292, 358, 374, 225, 90, 75, 223, 67, 114, 217, 87, 392, 52, 6, 17, 187, 61, 310, 91, 181, 9, 179, 26, 123, 68, 211, 372, 235, 42, 23, 130, 230, 227, ], [-26, -196, -4, -5, -174, -178, -13, -163, -155, -10, -199,
  -120, -132, -135, -123, -133, -4, -107, -27, -146, -108, -126, -176, -168, -138, 224, -169, -175, -12, -111, 328, -164, 224, 55, -198, -24, -22, -125, 224, -20, -23, -167, -16, -9, -147, -177, -129, -200, -118, -109, -7, 216, -121, -194, -127, -195, -25, 224, -119, -16, -28, -131, -128, -8, -136, -21, -134, -197, 224, -11, -18, 328, -137, 224, -17, -148, -202, -156, -122, -130, -145, -110, -6, -19, -14, -124, -15, 55, -173, -179, -29, -201, -172, -112, -117, -170, -171, -154, ]), 'OR_OP': ([96, 77, 86, 312, 142, 363, 97, 155, 316, 410, 305, 110, 184, 368, 314, 84, 104, 309, 211, 318, 307, 83, 185, 423, 292, 310, 179, 366, 78, 91, 71, 100, 89, 303, 297, 101, 180, 220, 420, 92, 85, 105, 74, 90, 302, 298, 102, 388, 308, 301, 313, 75, 109, 217, 181, 364, 295, 291, 300, 112, 317, 322, 296, 213, 315, 99, 306, 299, 106, 311, 182, ], [-73, -9, -68, -74, -56, -57, -58, -4, -26, -33, -71, -49, -45, -23, -7, -12, -10, -8, -29, -24, -72, -65, -47, -35, -21, -6, -15, -25, -56, -19, -82, -22, -8
 0, -83, -59, -76, -16, -46, -34, -84, -62, -13, -20, -11, -79, -61, -4, -32, -70, -67, -5, -18, -43, -17, -14, -48, -63, -81, -66, 218, -27, -85, -64, -28, -77, -16, -69, -60, -78, -75, -44, ]), 'SUB_ASSIGN': ([363, 105, 77, 318, 292, 366, 78, 213, 423, 109, 317, 368, 313, 211, 388, 185, 91, 314, 104, 142, 102, 310, 410, 420, 184, 99, 182, 316, 309, 179, 364, 75, 110, 74, 220, 180, 181, 90, 84, 155, 100, 217, ], [-57, -13, -9, -24, -21, -25, -56, -28, -35, -43, -27, -23, -5, -29, -32, -47, -19, -7, -10, 245, -4, -6, -33, -34, -45, -16, -44, -26, -8, -15, -48, -18, -49, -20, -46, -16, -14, -11, -12, -4, -22, -17, ]), 'XOR_ASSIGN': ([366, 102, 182, 91, 78, 388, 100, 309, 179, 185, 213, 420, 142, 313, 105, 292, 181, 74, 310, 104, 99, 423, 220, 410, 110, 84, 217, 77, 184, 316, 75, 180, 155, 109, 317, 368, 364, 90, 363, 314, 318, 211, ], [-25, -4, -44, -19, -56, -32, -22, -8, -15, -47, -28, -34, 247, -5, -13, -21, -14, -20, -6, -10, -16, -35, -46, -33, -49, -12, -17, -9, -45, -26, -18, -
 16, -4, -43, -27, -23, -48, -11, -57, -7, -24, -29, ]), 'INT': ([2, 137, 47, 32, 358, 27, 59, 140, 5, 117, 65, 260, 227, 72, 221, 3, 9, 81, 283, 360, 332, 359, 18, 1, 28, 230, 279, 66, 163, 8, 30, 116, 170, 64, 280, 231, 238, 37, 13, 20, 133, 0, 58, 34, 73, 52, 54, 186, 56, 167, 169, 196, 205, 38, 49, 67, 287, 277, 36, 15, 327, 12, 387, 356, 339, 26, 39, 22, 51, 134, 235, 353, 165, 60, 130, 87, 168, 31, 172, 6, 17, 35, 269, 286, 123, 242, 4, 237, 10, 278, 23, 25, ], [34, 34, 34, -242, -134, 34, 34, 34, -131, -168, -138, -218, -154, 34, 34, 34, -124, 34, -144, -252, -155, -251, -126, 34, 34, -171, -142, 34, -217, -123, -241, -254, -141, 34, -136, 34, -169, -132, -133, -167, -245, -1, -222, -125, -247, -156, 34, 34, -246, 34, 34, -248, -249, -164, -165, -137, -250, -243, -129, -2, 34, -118, -253, -143, -220, -166, -121, -3, -104, -223, -172, -135, -244, 34, -170, 34, 34, -127, 34, -122, -130, -128, -221, 34, -173, -219, -163, 34, -119, 34, -117, -120, ]), 'SIGNED': ([31, 356, 6, 168, 
 137, 28, 25, 287, 0, 36, 167, 358, 196, 327, 235, 8, 123, 170, 35, 27, 277, 2, 38, 237, 360, 10, 227, 32, 56, 134, 87, 359, 116, 260, 59, 30, 242, 34, 283, 67, 230, 186, 13, 81, 20, 3, 163, 23, 387, 269, 22, 5, 66, 165, 73, 205, 140, 17, 278, 286, 47, 130, 54, 279, 51, 37, 26, 65, 12, 9, 172, 49, 39, 15, 280, 169, 332, 58, 1, 231, 60, 238, 353, 133, 18, 339, 221, 64, 4, 117, 52, 72, ], [-127, -143, -122, 36, 36, 36, -120, -250, -1, -129, 36, -134, -248, 36, -172, -123, -173, -141, -128, 36, -243, 36, -164, 36, -252, -119, -154, -242, -246, -223, 36, -251, -254, -218, 36, -241, -219, -125, -144, -137, -171, 36, -133, 36, -167, 36, -217, -117, -253, -221, -3, -131, 36, -244, -247, -249, 36, -130, 36, 36, 36, -170, 36, -142, -104, -132, -166, -138, -118, -124, 36, -165, -121, -2, -136, 36, -155, -222, 36, 36, 36, -169, -135, -245, -126, -220, 36, 36, -163, -168, -156, 36, ]), 'CONTINUE': ([58, 340, 243, 408, 154, 269, 144, 143, 258, 338, 394, 136, 159, 263, 413, 339, 382, 259, 153, 344
 , 399, 268, 242, 406, 158, 415, 135, 240, 405, 147, 414, 134, 163, 267, 60, 140, 260, 396, 346, 261, 270, 380, 379, 397, 139, 378, 51, 348, ], [-222, -240, -239, 146, -213, -221, -226, -209, -237, -236, 146, -212, -211, 146, -235, -220, 146, -225, -224, -216, -229, -238, -219, 146, 146, -230, -210, 146, -234, 146, -233, -223, -217, 146, 146, 146, -218, -232, 146, -227, -228, 146, -215, -231, -208, 146, -104, -214, ]), 'MUL_ASSIGN': ([318, 105, 420, 100, 317, 314, 78, 91, 292, 366, 181, 182, 104, 179, 185, 99, 142, 155, 220, 309, 84, 74, 310, 410, 213, 75, 184, 368, 316, 180, 313, 363, 423, 217, 364, 77, 110, 102, 388, 211, 90, 109, ], [-24, -13, -34, -22, -27, -7, -56, -19, -21, -25, -14, -44, -10, -15, -47, -16, 250, -4, -46, -8, -12, -20, -6, -33, -28, -18, -45, -23, -26, -16, -5, -57, -35, -17, -48, -9, -49, -4, -32, -29, -11, -43, ]), '{': ([267, 24, 346, 238, 408, 52, 379, 58, 159, 136, 258, 243, 405, 158, 339, 344, 276, 51, 139, 384, 380, 261, 144, 415, 64, 269, 26, 340, 406, 
 135, 163, 414, 140, 338, 67, 230, 134, 394, 270, 348, 154, 27, 60, 396, 33, 235, 397, 167, 240, 117, 260, 21, 263, 20, 40, 268, 378, 166, 413, 59, 147, 399, 49, 242, 153, 123, 382, 130, 143, 259, 65, ], [60, 53, 60, -169, 60, 118, -215, -222, -211, -212, -237, -239, -234, 60, -220, -216, 276, -104, -208, 276, 60, -227, -226, -230, 60, -221, -166, -240, 60, -210, -217, -233, 60, -236, 172, -171, -223, 60, -228, -214, -213, 60, 60, -232, -139, -172, -231, 60, 60, -168, -218, -140, 60, -167, 66, -238, 60, 276, -235, 60, 60, -229, -165, -219, -224, -173, 60, -170, -209, -225, 168, ]), 'RIGHT_OP': ([155, 363, 86, 74, 77, 307, 78, 313, 211, 317, 305, 308, 309, 296, 297, 104, 388, 300, 301, 213, 105, 109, 185, 97, 85, 179, 91, 182, 420, 83, 75, 410, 217, 220, 314, 366, 318, 306, 310, 364, 299, 110, 292, 99, 295, 102, 142, 90, 184, 298, 100, 180, 84, 316, 368, 423, 181, ], [-4, -57, 194, -20, -9, 194, -56, -5, -29, -27, 194, 194, -8, -64, -59, -10, -32, -66, -67, -28, -13, -43, -47, -58, -6
 2, -15, -19, -44, -34, -65, -18, -33, -17, -46, -7, -25, -24, 194, -6, -48, -60, -49, -21, -16, -63, -4, -56, -11, -45, -61, -22, -16, -12, -26, -23, -35, -14, ]), 'REGISTER': ([2, 260, 13, 17, 54, 39, 130, 360, 4, 387, 237, 205, 64, 280, 52, 167, 231, 238, 196, 49, 287, 0, 73, 133, 165, 123, 36, 65, 358, 58, 31, 6, 9, 20, 59, 227, 1, 277, 8, 27, 5, 163, 38, 67, 28, 140, 339, 22, 51, 230, 37, 235, 359, 25, 353, 23, 3, 26, 221, 10, 60, 117, 332, 134, 242, 116, 32, 30, 12, 34, 15, 35, 18, 327, 269, 56, ], [39, -218, -133, -130, 39, -121, -170, -252, -163, -253, 39, -249, 39, -136, -156, 39, 39, -169, -248, -165, -250, -1, -247, -245, -244, -173, -129, -138, -134, -222, -127, -122, -124, -167, 39, -154, 39, -243, -123, 39, -131, -217, -164, -137, 39, 39, -220, -3, -104, -171, -132, -172, -251, -120, -135, -117, 39, -166, 39, -119, 39, -168, -155, -223, -219, -254, -242, -241, -118, -125, -2, -128, -126, 39, -221, -246, ]), 'RIGHT_ASSIGN': ([142, 410, 77, 420, 423, 99, 185, 155, 104, 21
 1, 213, 182, 220, 366, 364, 316, 363, 78, 313, 91, 388, 318, 310, 292, 105, 110, 75, 74, 181, 100, 309, 102, 84, 90, 217, 317, 179, 184, 109, 368, 180, 314, ], [255, -33, -9, -34, -35, -16, -47, -4, -10, -29, -28, -44, -46, -25, -48, -26, -57, -56, -5, -19, -32, -24, -6, -21, -13, -49, -18, -20, -14, -22, -8, -4, -12, -11, -17, -27, -15, -45, -43, -23, -16, -7, ]), 'DEFAULT': ([159, 140, 258, 260, 153, 154, 379, 380, 269, 339, 136, 270, 344, 405, 267, 378, 382, 58, 134, 348, 414, 242, 147, 243, 397, 346, 263, 408, 158, 394, 51, 406, 143, 261, 139, 338, 259, 60, 268, 340, 413, 135, 163, 415, 399, 144, 396, 240, ], [-211, 149, -237, -218, -224, -213, -215, 149, -221, -220, -212, -228, -216, -234, 149, 149, 149, -222, -223, -214, -233, -219, 149, -239, -231, 149, 149, 149, 149, 149, -104, 149, -209, -227, -208, -236, -225, 149, -238, -240, -235, -210, -217, -230, -229, -226, -232, 149, ]), 'CHAR': ([15, 18, 133, 137, 58, 4, 13, 31, 280, 231, 26, 60, 37, 387, 278, 49, 332, 66, 12, 1, 39
 , 165, 169, 5, 279, 9, 17, 269, 186, 23, 34, 140, 54, 130, 65, 20, 116, 47, 51, 230, 73, 81, 87, 172, 22, 67, 205, 163, 3, 170, 286, 38, 28, 134, 32, 8, 260, 59, 2, 356, 242, 360, 35, 287, 30, 25, 227, 52, 56, 235, 6, 10, 358, 0, 359, 27, 283, 72, 123, 238, 168, 237, 196, 36, 277, 117, 353, 221, 339, 327, 64, 167, ], [-2, -126, -245, 8, -222, -163, -133, -127, -136, 8, -166, 8, -132, -253, 8, -165, -155, 8, -118, 8, -121, -244, 8, -131, -142, -124, -130, -221, 8, -117, -125, 8, 8, -170, -138, -167, -254, 8, -104, -171, -247, 8, 8, 8, -3, -137, -249, -217, 8, -141, 8, -164, 8, -223, -242, -123, -218, 8, 8, -143, -219, -252, -128, -250, -241, -120, -154, -156, -246, -172, -122, -119, -134, -1, -251, 8, -144, 8, -173, -169, 8, 8, -248, -129, -243, -168, -135, 8, -220, 8, 8, 8, ]), 'WHILE': ([382, 147, 338, 413, 153, 259, 258, 344, 139, 405, 136, 134, 415, 397, 267, 339, 394, 379, 380, 396, 240, 159, 261, 399, 243, 348, 260, 140, 408, 154, 406, 51, 143, 270, 242, 378, 163, 58, 269, 268,
  340, 414, 135, 60, 158, 271, 263, 346, 144, ], [150, 150, -236, -235, -224, -225, -237, -216, -208, -234, -212, -223, -230, -231, 150, -220, 150, -215, 150, -232, 150, -211, -227, -229, -239, -214, -218, 150, 150, -213, 150, -104, -209, -228, -219, 150, -217, -222, -221, -238, -240, -233, -210, 150, 150, 349, 150, 150, -226, ]), 'EXTERN': ([163, 4, 31, 23, 117, 34, 67, 242, 56, 13, 10, 32, 133, 54, 59, 227, 269, 130, 65, 359, 1, 280, 36, 358, 15, 123, 235, 26, 167, 6, 230, 51, 238, 12, 339, 49, 134, 60, 73, 58, 5, 353, 38, 2, 387, 231, 332, 237, 3, 0, 30, 27, 116, 28, 360, 327, 9, 39, 37, 64, 8, 196, 35, 18, 277, 140, 221, 260, 17, 165, 22, 287, 205, 20, 25, 52, ], [-217, -163, -127, -117, -168, -125, -137, -219, -246, -133, -119, -242, -245, 12, 12, -154, -221, -170, -138, -251, 12, -136, -129, -134, -2, -173, -172, -166, 12, -122, -171, -104, -169, -118, -220, -165, -223, 12, -247, -222, -131, -135, -164, 12, -253, 12, -155, 12, 12, -1, -241, 12, -254, 12, -252, 12, -124, -121, -
 132, 12, -123, -248, -128, -126, -243, 12, 12, -218, -130, -244, -3, -250, -249, -167, -120, -156, ]), 'RETURN': ([158, 396, 406, 348, 260, 143, 147, 339, 340, 159, 269, 399, 394, 135, 163, 414, 139, 405, 379, 415, 134, 243, 344, 136, 259, 397, 242, 382, 240, 140, 60, 258, 408, 144, 51, 378, 263, 338, 154, 153, 267, 413, 346, 380, 270, 58, 268, 261, ], [141, -232, 141, -214, -218, -209, 141, -220, -240, -211, -221, -229, 141, -210, -217, -233, -208, -234, -215, -230, -223, -239, -216, -212, -225, -231, -219, 141, 141, 141, 141, -237, 141, -226, -104, 141, 141, -236, -213, -224, 141, -235, 141, 141, -228, -222, -238, -227, ]), '__ASM__': ([198, 381, 408, 174, 240, 135, 269, 258, 144, 202, 284, 382, 260, 79, 252, 47, 137, 257, 369, 218, 276, 80, 147, 228, 189, 191, 380, 151, 338, 396, 378, 176, 249, 399, 203, 261, 246, 263, 108, 243, 340, 190, 253, 192, 342, 55, 377, 51, 219, 136, 141, 94, 270, 339, 262, 354, 183, 264, 414, 328, 367, 215, 379, 154, 384, 82, 293, 140, 254, 267, 158, 14
 3, 58, 406, 242, 409, 113, 210, 268, 103, 289, 250, 139, 216, 413, 405, 245, 107, 60, 415, 272, 256, 247, 348, 204, 207, 255, 193, 166, 346, 153, 201, 134, 259, 76, 194, 251, 394, 248, 224, 397, 95, 197, 344, 186, 72, 208, 163, 266, 188, 159, ], [93, 93, 93, 93, 93, -210, -221, -237, -226, 93, 93, 93, -218, 93, -96, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, -236, -232, 93, 93, -98, -229, 93, -227, -93, 93, -53, -239, -240, 93, -90, 93, 93, 93, 93, -104, 93, -212, 93, -50, -228, -220, 93, 93, 93, 93, -233, 93, 93, 93, -215, -213, 93, -52, 93, 93, -94, 93, 93, -209, -222, 93, -219, 93, 93, 93, -238, -54, 93, -91, -208, 93, -235, -234, -95, -55, 93, -230, 93, 93, -99, -214, 93, 93, -97, 93, 93, 93, -224, 93, -223, -225, 93, 93, -92, 93, -100, 93, -231, -51, 93, -216, 93, 93, 93, -217, 93, 93, -211, ]), 'CASE': ([378, 153, 259, 163, 258, 139, 134, 242, 396, 339, 147, 51, 380, 58, 159, 399, 136, 269, 379, 154, 408, 243, 270, 267, 397, 405, 413, 382, 135, 143, 394, 340, 260, 144
 , 158, 140, 414, 344, 240, 268, 263, 406, 338, 346, 60, 415, 348, 261, ], [151, -224, -225, -217, -237, -208, -223, -219, -232, -220, 151, -104, 151, -222, -211, -229, -212, -221, -215, -213, 151, -239, -228, 151, -231, -234, -235, 151, -210, -209, 151, -240, -218, -226, 151, 151, -233, -216, 151, -238, 151, 151, -236, 151, 151, -230, -214, -227, ]), 'PP_DEFINE_MACRO_NAME': ([11, ], [46, ]), '&': ([106, 74, 256, 224, 83, 91, 308, 276, 397, 202, 210, 95, 94, 240, 85, 381, 318, 211, 219, 113, 306, 191, 198, 260, 153, 315, 184, 192, 140, 384, 388, 257, 142, 338, 215, 84, 369, 254, 154, 340, 242, 312, 216, 409, 220, 188, 413, 382, 134, 251, 313, 163, 261, 423, 99, 316, 292, 185, 78, 379, 245, 270, 213, 420, 76, 104, 289, 174, 255, 317, 218, 262, 248, 189, 197, 90, 135, 58, 252, 166, 314, 77, 300, 247, 399, 108, 293, 301, 194, 79, 364, 363, 368, 302, 310, 179, 298, 183, 190, 406, 414, 307, 250, 249, 253, 207, 299, 246, 267, 139, 180, 366, 342, 243, 264, 272, 60, 378, 144, 103, 284, 339, 
 102, 295, 258, 143, 408, 367, 96, 193, 296, 311, 354, 107, 75, 268, 137, 309, 141, 101, 109, 377, 82, 203, 396, 72, 80, 405, 158, 100, 186, 176, 348, 217, 410, 228, 204, 97, 105, 182, 51, 328, 269, 47, 55, 201, 344, 394, 86, 136, 181, 208, 147, 155, 266, 151, 159, 415, 305, 346, 259, 297, 263, 380, 110, ], [210, -20, 94, 94, -65, -19, -70, 94, -231, 94, 94, -51, -50, 94, -62, 94, -24, -29, 94, 94, -69, 94, 94, -218, -224, -77, -45, 94, 94, 94, -32, 94, -56, -236, 94, -12, 94, -94, -213, -240, -219, -74, 94, 94, -46, 94, -235, 94, -223, -92, -5, -217, -227, -35, -16, -26, -21, -47, -56, -215, -95, -228, -28, -34, 94, -10, 94, 94, -97, -27, 94, 94, -100, 94, 94, -11, -210, -222, -96, 94, -7, -9, -66, -99, -229, -53, 94, -67, 94, 94, -48, -57, -23, 210, -6, -15, -61, 94, 94, 94, -233, -72, -91, -98, -90, 94, -60, -93, 94, -208, -16, -25, 94, -239, 94, 94, 94, 94, -226, -54, 94, -220, -4, -63, -237, -209, 94, 94, -73, 94, -64, -75, 94, -55, -18, -238, 94, -8, 94, -76, -43, 94, -52, 94, 
 -232, 94, 94, -234, 94, -22, 94, 94, -214, -17, -33, 94, 94, -58, -13, -44, -104, 94, -221, 94, 94, 94, -216, 94, -68, -212, -14, 94, 94, -4, 94, 94, -211, -230, -71, 94, -225, -59, 94, 94, -49, ]), '*': ([266, 52, 297, 202, 208, 176, 127, 195, 163, 253, 268, 287, 204, 185, 191, 277, 2, 270, 396, 245, 213, 260, 219, 187, 104, 174, 231, 196, 256, 247, 56, 81, 218, 192, 141, 179, 284, 134, 360, 84, 109, 353, 39, 10, 180, 240, 41, 227, 332, 414, 133, 44, 12, 249, 264, 354, 255, 388, 34, 251, 4, 346, 314, 413, 269, 55, 23, 113, 262, 76, 250, 158, 0, 205, 243, 348, 198, 166, 137, 28, 261, 280, 15, 105, 210, 35, 140, 197, 296, 381, 171, 257, 263, 420, 193, 99, 379, 8, 31, 366, 228, 221, 415, 151, 68, 36, 378, 87, 342, 90, 58, 51, 380, 6, 408, 143, 367, 201, 344, 293, 310, 299, 267, 79, 85, 18, 242, 5, 289, 136, 298, 1, 272, 7, 72, 259, 317, 292, 164, 29, 110, 215, 100, 186, 246, 399, 217, 147, 384, 309, 220, 188, 38, 207, 9, 357, 363, 82, 318, 423, 37, 43, 394, 30, 254, 135, 359, 338, 387
 , 65, 22, 116, 406, 409, 42, 16, 358, 3, 61, 364, 313, 339, 405, 224, 25, 211, 316, 77, 252, 102, 410, 73, 216, 165, 184, 139, 13, 32, 114, 276, 382, 107, 75, 94, 369, 97, 144, 368, 103, 189, 74, 80, 182, 328, 67, 153, 377, 258, 159, 108, 57, 194, 95, 181, 155, 60, 142, 340, 47, 91, 397, 78, 183, 248, 17, 203, 154, 295, 190, ], [95, -156, -59, 95, 95, 95, 7, -147, -217, -90, -238, -250, 95, -47, 95, -243, -107, -228, -232, -95, -28, -218, 95, -145, -10, 95, 7, -248, 95, -99, -246, -146, 95, 95, 95, -15, 95, -223, -252, -12, -43, -135, -121, -119, -16, 95, -108, -154, -155, -233, -245, -178, -118, -98, 95, 95, -97, -32, -125, -92, -163, 95, -7, -235, -221, 95, -117, 95, 95, 95, -91, 95, -1, -249, -239, -214, 95, 95, 95, -109, -227, -136, -2, -13, 95, -128, 95, 95, 190, 95, 7, 95, 95, -34, 95, -16, -215, -123, -127, -25, 95, 7, -230, 95, -179, -129, 95, -148, 95, -11, -222, -104, 95, -122, 95, -209, 95, 95, -216, 95, -6, -60, 95, 95, 190, -126, -219, -131, 95, -212, -61, 7, 95, 7, 95,
  -225, -27, -21, 7, 7, -49, 95, -22, 95, -93, -229, -17, 95, 95, -8, -46, 95, -164, 95, -124, 7, -57, -52, -24, -35, -132, 7, 95, -241, -94, -210, -251, -236, -253, -138, -3, -254, 95, 95, -112, 7, -134, -111, -110, -48, -5, -220, -234, 95, -120, -29, -26, -9, -96, -4, -33, -247, 95, -244, -45, -208, -133, -242, 7, 95, 95, -55, -18, -50, 95, -58, -226, -23, -54, 95, -20, 95, -44, 95, -137, -224, 95, -237, -211, -53, 7, 95, -51, -14, -4, 95, -56, -240, 95, -19, -231, -56, 95, -100, -130, 95, -213, 190, 95, ]), 'SWITCH': ([414, 139, 380, 147, 270, 143, 242, 134, 154, 340, 267, 394, 379, 382, 263, 261, 348, 406, 144, 339, 413, 243, 158, 344, 163, 396, 378, 268, 415, 259, 258, 397, 60, 51, 338, 135, 408, 399, 269, 159, 58, 346, 405, 260, 136, 140, 153, 240, ], [-233, -208, 152, 152, -228, -209, -219, -223, -213, -240, 152, 152, -215, 152, 152, -227, -214, 152, -226, -220, -235, -239, 152, -216, -217, -232, 152, -238, -230, -225, -237, -231, 152, -104, -236, -210, 152, -229, -221, -211, 
 -222, 152, -234, -218, -212, 152, -224, 152, ]), 'AND_ASSIGN': ([217, 292, 318, 181, 179, 110, 368, 102, 316, 309, 109, 105, 99, 184, 74, 142, 104, 90, 314, 185, 78, 388, 363, 182, 180, 423, 155, 100, 420, 310, 84, 213, 220, 91, 77, 364, 75, 211, 410, 366, 313, 317, ], [-17, -21, -24, -14, -15, -49, -23, -4, -26, -8, -43, -13, -16, -45, -20, 249, -10, -11, -7, -47, -56, -32, -57, -44, -16, -35, -4, -22, -34, -6, -12, -28, -46, -19, -9, -48, -18, -29, -33, -25, -5, -27, ]), 'IDENTIFIER': ([9, 141, 280, 344, 293, 21, 246, 384, 242, 82, 194, 257, 346, 55, 30, 23, 0, 259, 243, 164, 139, 16, 215, 24, 134, 65, 58, 33, 5, 144, 408, 38, 127, 67, 79, 209, 108, 107, 1, 138, 397, 103, 216, 409, 42, 17, 332, 143, 342, 212, 159, 45, 360, 394, 37, 43, 254, 268, 252, 387, 207, 51, 53, 382, 190, 3, 186, 192, 94, 231, 147, 191, 47, 196, 406, 248, 195, 188, 287, 61, 73, 54, 165, 118, 10, 253, 367, 358, 214, 381, 264, 31, 203, 154, 80, 340, 270, 357, 52, 405, 224, 174, 25, 396, 234, 189, 151, 227, 414
 , 266, 153, 284, 12, 187, 198, 276, 137, 245, 210, 60, 35, 202, 208, 183, 269, 247, 163, 81, 262, 95, 258, 236, 36, 204, 353, 251, 18, 57, 260, 140, 133, 197, 369, 176, 13, 44, 249, 263, 277, 255, 338, 34, 15, 219, 39, 14, 41, 4, 68, 240, 56, 113, 250, 116, 205, 72, 158, 2, 28, 379, 261, 267, 339, 206, 22, 229, 171, 256, 354, 76, 380, 136, 218, 193, 328, 377, 40, 8, 7, 166, 272, 69, 289, 378, 413, 135, 359, 87, 399, 32, 348, 6, 228, 415, 29, 201, ], [-124, 102, -136, -216, 102, -140, -93, 102, -219, -52, 102, 102, 155, 102, -241, -117, -1, -225, -239, 20, -208, 20, 102, 52, -223, -138, -222, -139, -131, -226, 155, -164, 20, -137, 102, 102, -53, -55, 20, 239, -231, -54, 102, 102, -112, -130, -155, -209, 102, 316, -211, -176, -252, 155, -132, -175, -94, -238, -96, -253, 102, -104, 121, 155, 102, -111, 102, 102, -50, 20, 155, 102, 102, -248, 155, -100, -147, 102, -250, -110, -247, 124, -244, 121, -119, -90, 102, -134, 317, 102, 102, -127, 102, -213, 102, -240, -228, 20, -156, -234, 102
 , 102, -120, -232, 20, 102, 102, -154, -233, 102, -224, 102, -118, -145, 102, 102, 102, -95, 102, 155, -128, 102, 102, 102, -221, -99, -217, -146, 102, -51, -237, 335, -129, 102, -135, -92, -126, 20, -218, 155, -245, 102, 102, 102, -133, -178, -98, 155, -243, -97, -236, -125, -2, 102, -121, 20, -108, -163, -179, 155, -246, 102, -91, -254, -249, 102, 155, -107, -109, -215, -227, 155, -220, 102, -3, 121, 20, 102, 102, 102, 155, -212, 102, 102, 102, 102, 67, -123, -174, 102, 102, -177, 102, 155, -235, -210, -251, -148, -229, -242, -214, -122, 102, -230, 20, 102, ]), 'ADD_ASSIGN': ([420, 317, 104, 109, 313, 78, 155, 213, 91, 179, 181, 185, 182, 423, 90, 314, 100, 220, 180, 316, 364, 363, 77, 105, 366, 309, 142, 310, 410, 75, 368, 217, 211, 74, 102, 388, 292, 184, 318, 84, 99, 110, ], [-34, -27, -10, -43, -5, -56, -4, -28, -19, -15, -14, -47, -44, -35, -11, -7, -22, -46, -16, -26, -48, -57, -9, -13, -25, -8, 254, -6, -33, -18, -23, -17, -29, -20, -4, -32, -21, -45, -24, -12, -16, -49, ])
 , '>': ([300, 85, 86, 296, 102, 181, 77, 298, 105, 307, 364, 410, 423, 309, 313, 211, 317, 182, 213, 388, 366, 292, 220, 155, 74, 314, 363, 306, 318, 312, 91, 110, 217, 83, 308, 90, 310, 96, 100, 179, 75, 305, 109, 311, 97, 180, 99, 184, 299, 420, 142, 104, 297, 368, 84, 301, 316, 295, 185, 78, ], [-66, -62, -68, -64, -4, -14, -9, -61, -13, -72, -48, -33, -35, -8, -5, -29, -27, -44, -28, -32, -25, -21, -46, -4, -20, -7, -57, -69, -24, 204, -19, -49, -17, -65, -70, -11, -6, 204, -22, -15, -18, -71, -43, 204, -58, -16, -16, -45, -60, -34, -56, -10, -59, -23, -12, -67, -26, -63, -47, -56, ]), 'PP_MACRO_PARAM': ([263, 354, 103, 82, 207, 245, 414, 144, 203, 58, 139, 174, 84, 289, 215, 108, 186, 76, 254, 192, 74, 290, 216, 143, 369, 47, 250, 202, 381, 276, 266, 141, 377, 258, 189, 158, 247, 113, 137, 218, 261, 219, 90, 206, 328, 270, 382, 188, 269, 51, 260, 135, 153, 183, 204, 367, 264, 346, 257, 190, 268, 107, 217, 406, 134, 396, 240, 154, 256, 293, 197, 380, 413, 253, 259, 99, 94, 210, 
 163, 272, 246, 198, 201, 267, 348, 176, 339, 262, 249, 394, 405, 384, 224, 151, 340, 415, 255, 193, 344, 111, 181, 378, 338, 105, 194, 147, 408, 209, 80, 60, 243, 180, 191, 379, 251, 284, 166, 399, 409, 136, 140, 79, 252, 70, 55, 208, 242, 95, 228, 397, 248, 159, 342, 179, 72, ], [99, 99, -54, -52, 99, -95, -233, -226, 99, -222, -208, 99, -12, 99, 99, -53, 99, 99, -94, 99, 180, 362, 99, -209, 99, 99, -91, 99, 99, 99, 99, 99, 99, -237, 99, 99, -99, 99, 99, 99, -227, 99, -11, 309, 99, -228, 99, 99, -221, -104, -218, -210, -224, 99, 99, 99, 99, 99, 99, 99, -238, -55, -17, 99, -223, -232, 99, -213, 99, 99, 99, 99, -235, -90, -225, -16, -50, 99, -217, 99, -93, 99, 99, 99, -214, 99, -220, 99, -98, 99, -234, 99, 99, 99, -240, -230, -97, 99, -216, 217, -14, 99, -236, -13, 99, 99, 99, 314, 99, 99, -239, -16, 99, -215, -92, 99, 99, -229, 99, -212, 99, 99, -96, 173, 99, 99, -219, -51, 99, -231, -100, -211, 99, -15, 99, ]), 'GE_OP': ([211, 110, 84, 297, 90, 184, 83, 317, 104, 78, 306, 312, 300,
  182, 180, 155, 299, 181, 179, 109, 423, 301, 307, 102, 77, 97, 213, 142, 75, 364, 86, 308, 316, 388, 96, 363, 366, 314, 292, 220, 99, 217, 74, 310, 313, 305, 296, 420, 295, 311, 100, 91, 368, 185, 85, 105, 298, 318, 410, 309, ], [-29, -49, -12, -59, -11, -45, -65, -27, -10, -56, -69, 203, -66, -44, -16, -4, -60, -14, -15, -43, -35, -67, -72, -4, -9, -58, -28, -56, -18, -48, -68, -70, -26, -32, 203, -57, -25, -7, -21, -46, -16, -17, -20, -6, -5, -71, -64, -34, -63, 203, -22, -19, -23, -47, -62, -13, -61, -24, -33, -8, ]), '^': ([366, 179, 315, 298, 296, 91, 97, 100, 155, 99, 312, 420, 363, 110, 104, 388, 299, 185, 182, 96, 90, 317, 311, 220, 410, 75, 85, 297, 306, 301, 184, 423, 314, 308, 313, 180, 291, 307, 310, 102, 78, 142, 292, 295, 74, 316, 302, 106, 211, 368, 109, 213, 300, 181, 305, 89, 364, 309, 101, 318, 77, 217, 86, 84, 105, 83, ], [-25, -15, -77, -61, -64, -19, -58, -22, -4, -16, -74, -34, -57, -49, -10, -32, -60, -47, -44, -73, -11, -27, -75, -46, -33, -18, -62, -59, -69
 , -67, -45, -35, -7, -70, -5, -16, 197, -72, -6, -4, -56, -56, -21, -63, -20, -26, -79, -78, -29, -23, -43, -28, -66, -14, -71, 197, -48, -8, -76, -24, -9, -17, -68, -12, -13, -65, ]), 'MOD_ASSIGN': ([142, 182, 74, 368, 104, 185, 110, 155, 84, 100, 181, 184, 211, 388, 318, 292, 217, 363, 423, 213, 109, 420, 77, 90, 314, 364, 310, 316, 220, 78, 105, 313, 366, 180, 99, 102, 91, 410, 317, 179, 75, 309, ], [246, -44, -20, -23, -10, -47, -49, -4, -12, -22, -14, -45, -29, -32, -24, -21, -17, -57, -35, -28, -43, -34, -9, -11, -7, -48, -6, -26, -46, -56, -13, -5, -25, -16, -16, -4, -19, -33, -27, -15, -18, -8, ]), ':': ([297, 5, 97, 235, 318, 291, 99, 86, 162, 403, 317, 142, 310, 90, 110, 358, 364, 78, 292, 84, 309, 52, 83, 220, 195, 332, 301, 75, 296, 31, 123, 388, 187, 74, 322, 302, 115, 323, 130, 238, 36, 391, 265, 180, 184, 105, 308, 365, 419, 299, 341, 313, 8, 343, 316, 303, 307, 100, 104, 306, 295, 49, 38, 9, 92, 357, 20, 109, 298, 37, 227, 89, 149, 185, 71, 87, 117, 77, 81, 311, 412,
  363, 102, 423, 404, 101, 65, 368, 213, 160, 217, 420, 67, 4, 96, 211, 179, 417, 353, 418, 230, 35, 282, 171, 106, 18, 402, 315, 34, 389, 300, 182, 112, 314, 366, 85, 26, 305, 13, 410, 181, 155, 17, 6, 312, 91, 280, ], [-59, -131, -58, -172, -24, -81, -16, -68, -88, -37, -27, -56, -6, -11, -49, -134, -48, -56, -21, -12, -8, -156, -65, -46, -147, -155, -67, -18, -64, -127, -173, -32, -145, -20, -85, -79, -103, 369, -170, -169, -129, -87, 346, -16, -45, -13, -70, 389, -40, -60, -89, -5, -123, -102, -26, -83, -72, -22, -10, -69, -63, -165, -164, -124, -84, 284, -167, -43, -61, -132, -154, -80, 263, -47, -82, -148, -168, -9, -146, -75, -36, -57, -4, -35, 412, -76, -138, -23, -28, -101, -17, -34, -137, -163, -73, -29, -15, -38, -135, 421, -171, -128, 354, 284, -78, -126, -39, -77, -125, -36, -66, -44, -86, -7, -25, -62, -166, -71, -133, -33, -14, 267, -130, -122, -74, -19, -136, ]), 'TYPE_NAME': ([13, 65, 51, 67, 167, 286, 47, 327, 35, 32, 278, 169, 279, 60, 130, 21, 37, 31, 28, 260, 227
 , 5, 359, 12, 137, 235, 165, 56, 87, 283, 172, 59, 242, 54, 30, 168, 20, 140, 353, 22, 8, 221, 116, 387, 4, 6, 64, 205, 10, 2, 134, 360, 339, 230, 123, 36, 66, 38, 356, 3, 33, 231, 27, 9, 196, 163, 34, 39, 15, 1, 17, 238, 269, 81, 40, 18, 133, 58, 52, 25, 237, 358, 49, 277, 186, 287, 26, 72, 73, 280, 170, 117, 0, 332, 23, ], [-133, -138, -104, -137, 13, 13, 13, 13, -128, -242, 13, 13, -142, 13, -170, -140, -132, -127, 13, -218, -154, -131, -251, -118, 13, -172, -244, -246, 13, -144, 13, 13, -219, 13, -241, 13, -167, 13, -135, -3, -123, 13, -254, -253, -163, -122, 13, -249, -119, 13, -223, -252, -220, -171, -173, -129, 13, -164, -143, 13, -139, 13, 13, -124, -248, -217, -125, -121, -2, 13, -130, -169, -221, 13, 65, -126, -245, -222, -156, -120, 13, -134, -165, -243, 13, -250, -166, 13, -247, -136, -141, -168, -1, -155, -117, ]), 'OR_ASSIGN': ([211, 179, 420, 110, 91, 99, 102, 310, 78, 142, 213, 423, 185, 184, 368, 388, 317, 75, 182, 90, 364, 410, 314, 100, 180, 155, 309, 217, 109, 84
 , 74, 105, 220, 104, 316, 363, 366, 318, 181, 77, 313, 292, ], [-29, -15, -34, -49, -19, -16, -4, -6, -56, 248, -28, -35, -47, -45, -23, -32, -27, -18, -44, -11, -48, -33, -7, -22, -16, -4, -8, -17, -43, -12, -20, -13, -46, -10, -26, -57, -25, -24, -14, -9, -5, -21, ]), 'BREAK': ([263, 258, 269, 242, 158, 378, 260, 399, 397, 58, 270, 346, 382, 379, 261, 134, 154, 139, 408, 51, 135, 153, 344, 348, 259, 396, 338, 243, 268, 415, 380, 406, 163, 340, 267, 414, 159, 405, 240, 394, 339, 144, 147, 136, 60, 140, 143, 413, ], [156, -237, -221, -219, 156, 156, -218, -229, -231, -222, -228, 156, 156, -215, -227, -223, -213, -208, 156, -104, -210, -224, -216, -214, -225, -232, -236, -239, -238, -230, 156, 156, -217, -240, 156, -233, -211, -234, 156, 156, -220, -226, 156, -212, 156, 156, -209, -235, ]), 'VOLATILE': ([237, 205, 170, 66, 353, 130, 360, 47, 327, 260, 8, 26, 4, 235, 59, 339, 356, 38, 387, 140, 23, 17, 117, 242, 358, 279, 93, 1, 0, 54, 18, 5, 169, 287, 35, 168, 221, 6, 186, 37, 52, 12
 3, 283, 25, 133, 269, 81, 7, 31, 277, 116, 56, 87, 9, 231, 13, 165, 12, 227, 20, 60, 27, 65, 137, 359, 72, 230, 58, 278, 3, 286, 172, 43, 51, 22, 2, 332, 68, 73, 39, 15, 64, 280, 32, 238, 196, 163, 167, 34, 67, 134, 28, 44, 36, 10, 49, 30, ], [38, -249, -141, 38, -135, -170, -252, 38, 38, -218, -123, -166, -163, -172, 38, -220, -143, -164, -253, 38, -117, -130, -168, -219, -134, -142, 199, 38, -1, 38, -126, -131, 38, -250, -128, 38, 38, -122, 38, -132, -156, -173, -144, -120, -245, -221, 38, 38, -127, -243, -254, -246, 38, -124, 38, -133, -244, -118, -154, -167, 38, 38, -138, 38, -251, 38, -171, -222, 38, 38, 38, 38, 38, -104, -3, 38, -155, -179, -247, -121, -2, 38, -136, -242, -169, -248, -217, 38, -125, -137, -223, 38, -178, -129, -119, -165, -241, ]), 'error': ([136, 380, 378, 153, 147, 346, 338, 399, 261, 344, 342, 58, 159, 51, 267, 382, 139, 260, 414, 242, 154, 143, 408, 135, 413, 394, 158, 163, 257, 396, 144, 340, 243, 269, 259, 134, 379, 140, 270, 263, 11, 348, 268, 405, 240,
  397, 60, 258, 415, 406, 339, ], [-212, 241, 241, -224, 241, 241, -236, -229, -227, -216, 241, -222, -211, -104, 241, 241, -208, -218, -233, -219, -213, -209, 241, -210, -235, 241, 241, -217, 241, -232, -226, -240, -239, -221, -225, -223, -215, 241, -228, 241, 48, -214, -238, -234, 241, -231, 157, -237, -230, 241, -220, ]), '~': ([397, 113, 103, 58, 380, 189, 252, 246, 79, 256, 262, 263, 254, 194, 413, 251, 344, 139, 202, 382, 183, 249, 147, 82, 204, 144, 201, 191, 394, 207, 384, 215, 186, 154, 340, 243, 141, 405, 188, 342, 339, 136, 284, 193, 261, 381, 76, 269, 293, 266, 159, 248, 268, 399, 276, 60, 289, 47, 242, 94, 55, 258, 219, 406, 250, 174, 240, 379, 253, 414, 151, 192, 198, 107, 255, 137, 367, 216, 409, 203, 396, 80, 158, 224, 260, 135, 176, 166, 245, 153, 143, 377, 210, 190, 354, 328, 247, 218, 208, 163, 257, 140, 197, 72, 259, 348, 378, 338, 369, 267, 264, 346, 51, 270, 408, 108, 134, 228, 95, 272, 415, ], [-231, 103, -54, -222, 103, 103, -96, -93, 103, 103, 103, 103, -94, 
 103, -235, -92, -216, -208, 103, 103, 103, -98, 103, -52, 103, -226, 103, 103, 103, 103, 103, 103, 103, -213, -240, -239, 103, -234, 103, 103, -220, -212, 103, 103, -227, 103, 103, -221, 103, 103, -211, -100, -238, -229, 103, 103, 103, 103, -219, -50, 103, -237, 103, 103, -91, 103, 103, -215, -90, -233, 103, 103, 103, -55, -97, 103, 103, 103, 103, 103, -232, 103, 103, 103, -218, -210, 103, 103, -95, -224, -209, 103, 103, 103, 103, 103, -99, 103, 103, -217, 103, 103, 103, 103, -225, -214, 103, -236, 103, 103, 103, 103, -104, -228, 103, -53, -223, 103, -51, 103, -230, ]), 'DO': ([243, 346, 339, 153, 163, 338, 136, 158, 396, 415, 380, 51, 258, 405, 242, 382, 397, 159, 263, 267, 240, 259, 408, 270, 134, 140, 340, 348, 143, 144, 413, 135, 378, 379, 154, 399, 147, 414, 260, 139, 60, 269, 394, 268, 406, 344, 261, 58, ], [-239, 158, -220, -224, -217, -236, -212, 158, -232, -230, 158, -104, -237, -234, -219, 158, -231, -211, 158, 158, 158, -225, 158, -228, -223, 158, -240, -214, -209, -226, 
 -235, -210, 158, -215, -213, -229, 158, -233, -218, -208, 158, -221, 158, -238, 158, -216, -227, -222, ]), 'CONST': ([359, 205, 81, 31, 9, 49, 2, 32, 196, 37, 72, 20, 59, 10, 242, 18, 358, 231, 15, 117, 60, 235, 123, 26, 360, 6, 34, 260, 230, 356, 54, 353, 25, 27, 3, 8, 167, 67, 269, 133, 332, 227, 140, 237, 283, 56, 4, 38, 43, 186, 64, 12, 51, 39, 44, 68, 221, 278, 5, 7, 134, 47, 52, 280, 87, 163, 327, 339, 168, 286, 13, 58, 36, 23, 66, 287, 73, 169, 116, 17, 0, 137, 279, 238, 130, 22, 170, 65, 172, 387, 30, 35, 277, 28, 1, 165, ], [-251, -249, 4, -127, -124, -165, 4, -242, -248, -132, 4, -167, 4, -119, -219, -126, -134, 4, -2, -168, 4, -172, -173, -166, -252, -122, -125, -218, -171, -143, 4, -135, -120, 4, 4, -123, 4, -137, -221, -245, -155, -154, 4, 4, -144, -246, -163, -164, 4, 4, 4, -118, -104, -121, -178, -179, 4, 4, -131, 4, -223, 4, -156, -136, 4, -217, 4, -220, 4, 4, -133, -222, -129, -117, 4, -250, -247, 4, -254, -130, -1, 4, -142, -169, -170, -3, -141, -138, 4, -253, -241
 , -128, -243, 4, 4, -244, ]), '!': ([107, 246, 204, 242, 147, 269, 189, 262, 208, 58, 176, 243, 254, 263, 183, 108, 379, 270, 51, 338, 342, 380, 405, 159, 79, 293, 80, 215, 139, 396, 339, 193, 381, 256, 197, 249, 47, 369, 260, 95, 399, 354, 144, 250, 408, 247, 163, 201, 348, 397, 216, 272, 266, 413, 186, 194, 328, 382, 257, 198, 82, 289, 261, 367, 76, 414, 253, 255, 409, 224, 153, 202, 267, 406, 218, 113, 136, 140, 143, 60, 207, 377, 240, 174, 141, 134, 340, 190, 228, 384, 219, 344, 251, 94, 137, 276, 284, 394, 191, 210, 378, 135, 258, 55, 158, 252, 245, 203, 154, 264, 192, 268, 415, 188, 103, 248, 259, 166, 72, 151, 346, ], [-55, -93, 107, -219, 107, -221, 107, 107, 107, -222, 107, -239, -94, 107, 107, -53, -215, -228, -104, -236, 107, 107, -234, -211, 107, 107, 107, 107, -208, -232, -220, 107, 107, 107, 107, -98, 107, 107, -218, -51, -229, 107, -226, -91, 107, -99, -217, 107, -214, -231, 107, 107, 107, -235, 107, 107, 107, 107, 107, 107, -52, 107, -227, 107, 107, -233, -90, -97, 1
 07, 107, -224, 107, 107, 107, 107, 107, -212, 107, -209, 107, 107, 107, 107, 107, 107, -223, -240, 107, 107, 107, 107, -216, -92, -50, 107, 107, 107, 107, 107, 107, 107, -210, -237, 107, 107, -96, -95, 107, -213, 107, 107, -238, -230, 107, -54, -100, -225, 107, 107, 107, 107, ]), '%': ([364, 295, 314, 90, 388, 179, 217, 292, 75, 110, 77, 180, 420, 309, 299, 296, 84, 423, 109, 220, 368, 363, 142, 74, 78, 99, 102, 100, 310, 297, 182, 184, 318, 316, 366, 298, 185, 97, 317, 313, 155, 104, 91, 85, 211, 181, 213, 410, 105, ], [-48, 191, -7, -11, -32, -15, -17, -21, -18, -49, -9, -16, -34, -8, -60, 191, -12, -35, -43, -46, -23, -57, -56, -20, -56, -16, -4, -22, -6, -59, -44, -45, -24, -26, -25, -61, -47, -58, -27, -5, -4, -10, -19, 191, -29, -14, -28, -33, -13, ]), ')': ([68, 106, 391, 175, 12, 416, 310, 318, 179, 217, 70, 331, 261, 309, 423, 280, 177, 97, 403, 42, 392, 52, 371, 418, 6, 54, 332, 213, 50, 184, 130, 223, 299, 231, 13, 311, 294, 195, 127, 325, 335, 373, 92, 388, 238, 312, 20,
  75, 398, 123, 419, 215, 44, 74, 84, 337, 316, 185, 38, 86, 162, 233, 31, 364, 296, 389, 350, 142, 5, 104, 114, 358, 99, 227, 173, 307, 144, 319, 28, 124, 420, 322, 69, 292, 187, 305, 330, 100, 17, 65, 211, 336, 78, 128, 303, 341, 180, 9, 345, 366, 376, 422, 365, 234, 102, 182, 300, 77, 317, 297, 101, 295, 343, 49, 225, 393, 368, 160, 96, 71, 85, 8, 3, 320, 178, 7, 126, 306, 347, 23, 61, 67, 109, 395, 37, 220, 110, 41, 370, 270, 363, 89, 404, 232, 181, 291, 18, 410, 129, 313, 25, 90, 2, 10, 34, 39, 87, 377, 324, 230, 43, 81, 314, 390, 372, 91, 301, 221, 112, 417, 402, 105, 412, 302, 235, 117, 315, 36, 298, 308, 35, 83, 125, 362, 421, 45, 327, 326, 374, 353, 222, 26, 4, ], [-179, -78, -87, 289, -118, 419, -6, -24, -15, -17, 174, -193, -227, -8, -35, -136, 292, -58, -37, -112, -202, -156, -194, 420, -122, 123, -155, -28, 117, -45, -170, -192, -60, 324, -133, -75, 364, -147, -186, 370, -188, 392, -84, -32, -169, -74, -167, -18, 407, -173, -40, 318, -178, -20, -12, -183, -26, -47, -164,
  -68, -88, -184, -127, -48, -64, -36, 382, -56, -131, -10, -189, -134, -16, -154, -255, -72, -226, -30, -109, -187, -34, -85, -177, -21, -145, -71, -195, -22, -130, -138, -29, -181, -56, 235, -83, -89, -16, -124, 378, -25, -196, 423, 388, -191, -4, -44, -66, -9, -27, -59, -76, -63, -102, -165, -191, -198, -23, -101, -73, -82, -62, -123, -111, 366, 293, -174, -182, -69, 380, -117, -110, -137, -43, 406, -132, -46, -49, -108, -200, -228, -57, -80, 410, -185, -14, -81, -126, -33, -180, -5, -120, -11, -107, -119, -125, -121, -148, 394, -199, -171, -175, -146, -7, -31, -201, -19, -67, 324, -86, -38, -39, -13, -36, -79, -172, -168, -77, -129, -61, -70, -128, -65, 230, -256, -36, -176, 372, 371, -197, -135, -190, -166, -163, ]), '-': ([378, 240, 364, 83, 409, 202, 252, 197, 247, 261, 97, 219, 248, 110, 72, 414, 250, 310, 245, 309, 354, 318, 99, 183, 94, 313, 154, 176, 180, 262, 379, 413, 296, 184, 181, 203, 207, 381, 190, 55, 297, 104, 76, 377, 420, 408, 301, 316, 51, 201, 251, 328, 263, 75
 , 79, 74, 155, 246, 249, 292, 188, 396, 182, 174, 108, 243, 314, 135, 254, 298, 348, 340, 186, 399, 185, 95, 338, 85, 107, 159, 255, 367, 192, 384, 368, 346, 394, 253, 220, 289, 256, 344, 105, 77, 267, 369, 210, 228, 216, 264, 423, 363, 242, 218, 217, 189, 415, 103, 91, 143, 82, 134, 60, 136, 342, 47, 397, 339, 166, 109, 299, 163, 194, 405, 268, 272, 58, 366, 78, 100, 388, 224, 258, 276, 193, 269, 257, 295, 211, 266, 270, 158, 84, 140, 410, 139, 208, 293, 260, 259, 317, 141, 300, 102, 90, 142, 406, 137, 382, 113, 80, 153, 215, 380, 144, 204, 213, 191, 179, 151, 198, 147, 284, ], [108, 108, -48, 189, 108, 108, -96, 108, -99, -227, -58, 108, -100, -49, 108, -233, -91, -6, -95, -8, 108, -24, -16, 108, -50, -5, -213, 108, -16, 108, -215, -235, -64, -45, -14, 108, 108, 108, 108, 108, -59, -10, 108, 108, -34, 108, 189, -26, -104, 108, -92, 108, 108, -18, 108, -20, -4, -93, -98, -21, 108, -232, -44, 108, -53, -239, -7, -210, -94, -61, -214, -240, 108, -229, -47, -51, -236, -62, -55, -211, 
 -97, 108, 108, 108, -23, 108, 108, -90, -46, 108, 108, -216, -13, -9, 108, 108, 108, 108, 108, 108, -35, -57, -219, 108, -17, 108, -230, -54, -19, -209, -52, -223, 108, -212, 108, 108, -231, -220, 108, -43, -60, -217, 108, -234, -238, 108, -222, -25, -56, -22, -32, 108, -237, 108, 108, -221, 108, -63, -29, 108, -228, 108, -12, 108, -33, -208, 108, 108, -218, -225, -27, 108, 189, -4, -11, -56, 108, 108, 108, 108, 108, -224, 108, 108, -226, 108, -28, 108, -15, 108, 108, 108, 108, ]), 'CHARACTER_CONSTANT': ([380, 414, 250, 204, 245, 186, 191, 151, 284, 94, 154, 252, 140, 413, 247, 248, 381, 72, 377, 272, 201, 183, 176, 382, 379, 249, 203, 207, 55, 174, 76, 344, 408, 51, 254, 396, 415, 251, 338, 263, 79, 158, 293, 289, 346, 394, 240, 253, 188, 369, 210, 262, 108, 243, 144, 348, 340, 242, 218, 399, 189, 107, 159, 367, 192, 82, 134, 342, 378, 256, 397, 219, 166, 267, 228, 216, 264, 194, 405, 58, 135, 255, 193, 269, 257, 103, 143, 266, 270, 60, 136, 47, 339, 163, 141, 268, 354, 406, 137, 3
 28, 224, 276, 113, 153, 139, 208, 260, 190, 259, 258, 384, 147, 198, 409, 202, 80, 215, 197, 261, 95, 246, ], [104, -233, -91, 104, -95, 104, 104, 104, 104, -50, -213, -96, 104, -235, -99, -100, 104, 104, 104, 104, 104, 104, 104, 104, -215, -98, 104, 104, 104, 104, 104, -216, 104, -104, -94, -232, -230, -92, -236, 104, 104, 104, 104, 104, 104, 104, 104, -90, 104, 104, 104, 104, -53, -239, -226, -214, -240, -219, 104, -229, 104, -55, -211, 104, 104, -52, -223, 104, 104, 104, -231, 104, 104, 104, 104, 104, 104, 104, -234, -222, -210, -97, 104, -221, 104, -54, -209, 104, -228, 104, -212, 104, -220, -217, 104, -238, 104, 104, 104, 104, 104, 104, 104, -224, -208, 104, -218, 104, -225, -237, 104, 104, 104, 104, 104, 104, 104, 104, -227, -51, -93, ]), 'PP_STRINGIFY': ([139, 242, 176, 82, 58, 268, 381, 103, 94, 99, 367, 259, 84, 163, 147, 272, 204, 354, 382, 344, 328, 174, 266, 183, 394, 269, 255, 399, 413, 249, 263, 409, 134, 396, 72, 180, 193, 190, 107, 218, 252, 202, 408, 136, 210, 194, 
 217, 113, 257, 256, 51, 189, 188, 47, 207, 208, 379, 108, 228, 151, 95, 270, 105, 247, 181, 415, 348, 250, 342, 405, 159, 143, 253, 397, 186, 135, 240, 377, 243, 198, 219, 339, 261, 245, 260, 144, 264, 154, 79, 191, 262, 216, 267, 215, 369, 197, 254, 414, 140, 346, 246, 289, 338, 380, 224, 384, 192, 158, 90, 74, 284, 248, 153, 406, 60, 141, 378, 55, 179, 76, 166, 258, 340, 203, 137, 293, 80, 251, 201, 276, ], [-208, -219, 111, -52, -222, -238, 111, -54, -50, -16, 111, -225, -12, -217, 111, 111, 111, 111, 111, -216, 111, 111, 111, 111, 111, -221, -97, -229, -235, -98, 111, 111, -223, -232, 111, -16, 111, 111, -55, 111, -96, 111, 111, -212, 111, 111, -17, 111, 111, 111, -104, 111, 111, 111, 111, 111, -215, -53, 111, 111, -51, -228, -13, -99, -14, -230, -214, -91, 111, -234, -211, -209, -90, -231, 111, -210, 111, 111, -239, 111, 111, -220, -227, -95, -218, -226, 111, -213, 111, 111, 111, 111, 111, 111, 111, 111, -94, -233, 111, 111, -93, 111, -236, 111, 111, 111, 111, 111, -11, 111, 11
 1, -100, -224, 111, 111, 111, 111, 111, -15, 111, 111, -237, -240, 111, 111, 111, 111, -92, 111, 111, ]), 'PTR_OP': ([211, 109, 84, 309, 317, 217, 74, 181, 77, 91, 213, 90, 104, 102, 292, 313, 100, 368, 99, 179, 314, 180, 310, 366, 316, 318, 105, 75, 155, ], [-29, 214, -12, -8, -27, -17, -20, -14, -9, -19, -28, -11, -10, -4, -21, -5, -22, -23, -16, -15, -7, -16, -6, -25, -26, -24, -13, -18, -4, ]), '=': ([117, 26, 132, 104, 99, 182, 185, 90, 142, 78, 220, 109, 313, 49, 155, 213, 91, 179, 316, 121, 423, 366, 314, 100, 363, 235, 180, 238, 64, 130, 230, 102, 388, 105, 123, 211, 364, 84, 410, 317, 110, 368, 20, 310, 420, 309, 75, 74, 292, 184, 217, 181, 77, 318, ], [-168, -166, 166, -10, -16, -44, -47, -11, 253, -56, -46, -43, -5, -165, -4, -28, -19, -15, -26, 228, -35, -25, -7, -22, -57, -172, -16, -169, 166, -170, -171, -4, -32, -13, -173, -29, -48, -12, -33, -27, -49, -23, -167, -6, -34, -8, -18, -20, -21, -45, -17, -14, -9, -24, ]), 'TYPEDEF': ([58, 52, 242, 359, 358, 3, 123, 35, 28
 7, 34, 28, 227, 196, 38, 231, 26, 130, 165, 64, 327, 269, 15, 2, 37, 6, 205, 25, 51, 230, 133, 54, 73, 235, 280, 10, 5, 27, 31, 30, 117, 18, 332, 134, 221, 20, 8, 260, 67, 9, 13, 1, 387, 56, 60, 49, 23, 32, 237, 36, 116, 59, 140, 238, 339, 163, 17, 167, 277, 353, 12, 22, 65, 0, 4, 39, 360, ], [-222, -156, -219, -251, -134, 23, -173, -128, -250, -125, 23, -154, -248, -164, 23, -166, -170, -244, 23, 23, -221, -2, 23, -132, -122, -249, -120, -104, -171, -245, 23, -247, -172, -136, -119, -131, 23, -127, -241, -168, -126, -155, -223, 23, -167, -123, -218, -137, -124, -133, 23, -253, -246, 23, -165, -117, -242, 23, -129, -254, 23, 23, -169, -220, -217, -130, 23, -243, -135, -118, -3, -138, -1, -163, -121, -252, ]), 'AUTO': ([130, 287, 140, 60, 3, 133, 242, 31, 353, 116, 235, 327, 28, 34, 59, 8, 56, 269, 37, 27, 65, 18, 339, 221, 231, 13, 17, 39, 36, 332, 6, 10, 277, 230, 35, 26, 38, 32, 227, 67, 30, 64, 280, 15, 9, 360, 359, 25, 12, 73, 165, 387, 1, 49, 2, 117, 260, 123, 205, 5, 51, 23, 2
 38, 20, 237, 196, 4, 167, 58, 358, 22, 163, 52, 0, 134, 54, ], [-170, -250, 25, 25, 25, -245, -219, -127, -135, -254, -172, 25, 25, -125, 25, -123, -246, -221, -132, 25, -138, -126, -220, 25, 25, -133, -130, -121, -129, -155, -122, -119, -243, -171, -128, -166, -164, -242, -154, -137, -241, 25, -136, -2, -124, -252, -251, -120, -118, -247, -244, -253, 25, -165, 25, -168, -218, -173, -249, -131, -104, -117, -169, -167, 25, -248, -163, 25, -222, -134, -3, -217, -156, -1, -223, 25, ]), 'AND_OP': ([142, 101, 301, 97, 86, 308, 423, 77, 213, 364, 366, 109, 75, 295, 420, 311, 220, 211, 363, 84, 217, 296, 90, 110, 100, 300, 96, 106, 99, 302, 92, 83, 185, 89, 314, 104, 322, 299, 74, 105, 310, 410, 71, 307, 91, 368, 155, 313, 180, 292, 312, 303, 298, 309, 182, 306, 184, 318, 179, 317, 102, 291, 388, 297, 181, 315, 305, 85, 316, 78, ], [-56, -76, -67, -58, -68, -70, -35, -9, -28, -48, -25, -43, -18, -63, -34, -75, -46, -29, -57, -12, -17, -64, -11, -49, -22, -66, -73, -78, -16, -79, 198, -65, 
 -47, -80, -7, -10, 198, -60, -20, -13, -6, -33, -82, -72, -19, -23, -4, -5, -16, -21, -74, -83, -61, -8, -44, -69, -45, -24, -15, -27, -4, -81, -32, -59, -14, -77, -71, -62, -26, -56, ]), ']': ([106, 316, 301, 303, 423, 102, 322, 368, 410, 296, 420, 77, 211, 74, 364, 363, 220, 292, 109, 180, 217, 112, 302, 298, 305, 99, 321, 160, 295, 89, 311, 318, 86, 300, 104, 83, 329, 309, 105, 97, 185, 131, 110, 315, 92, 224, 312, 181, 75, 313, 55, 328, 343, 308, 307, 96, 184, 71, 115, 182, 85, 388, 341, 375, 179, 101, 306, 213, 366, 314, 297, 391, 84, 78, 317, 299, 291, 100, 91, 90, 162, 142, 310, ], [-78, -26, -67, -83, -35, -4, -85, -23, -33, -64, -34, -9, -29, -20, -48, -57, -46, -21, -43, -16, -17, -86, -79, -61, -71, -16, 368, -101, -63, -80, -75, -24, -68, -66, -10, -65, 376, -8, -13, -58, -47, 238, -49, -77, -84, 330, -74, -14, -18, -5, 130, 374, -102, -70, -72, -73, -45, -82, -103, -44, -62, -32, -89, 393, -15, -76, -69, -28, -25, -7, -59, -87, -12, -56, -27, -60, -81, -22, -19, -11, -8
 8, -56, -6, ]), 'IF': ([260, 399, 382, 269, 413, 344, 406, 147, 380, 144, 134, 346, 58, 408, 405, 394, 51, 379, 259, 415, 268, 396, 340, 378, 60, 154, 240, 140, 261, 159, 242, 135, 263, 153, 243, 258, 139, 414, 267, 348, 338, 397, 158, 163, 143, 136, 339, 270, ], [-218, -229, 161, -221, -235, -216, 161, 161, 161, -226, -223, 161, -222, 161, -234, 161, -104, -215, -225, -230, -238, -232, -240, 161, 161, -213, 161, 161, -227, -211, -219, -210, 161, -224, -239, -237, -208, -233, 161, -214, -236, -231, 161, -217, -209, -212, -220, -228, ]), 'STRING_LITERAL': ([414, 134, 252, 412, 255, 193, 90, 105, 228, 216, 257, 249, 409, 179, 394, 260, 243, 210, 103, 76, 369, 55, 219, 245, 269, 354, 380, 192, 413, 208, 348, 84, 248, 218, 263, 289, 163, 201, 60, 136, 204, 242, 108, 268, 251, 151, 186, 51, 250, 240, 190, 207, 276, 94, 180, 256, 99, 377, 72, 189, 224, 258, 259, 166, 344, 95, 397, 264, 399, 284, 338, 405, 153, 415, 421, 408, 194, 346, 113, 367, 139, 342, 254, 340, 406, 411, 159, 147, 389,
  215, 174, 253, 135, 379, 158, 262, 188, 378, 107, 141, 267, 246, 143, 80, 197, 47, 74, 396, 144, 304, 261, 82, 328, 191, 217, 381, 247, 181, 339, 154, 198, 384, 58, 183, 203, 272, 137, 79, 266, 176, 293, 202, 382, 270, 140, ], [-233, -223, -96, 90, -97, 90, -11, -13, 90, 90, 90, -98, 90, -15, 90, -218, -239, 90, -54, 90, 90, 90, 90, -95, -221, 90, 90, 90, -235, 90, -214, -12, -100, 90, 90, 90, -217, 90, 90, -212, 90, -219, -53, -238, -92, 90, 90, -104, -91, 90, 90, 90, 90, -50, -16, 90, -16, 90, 90, 90, 90, -237, -225, 90, -216, -51, -231, 90, -229, 90, -236, -234, -224, -230, 90, 90, 90, 90, 90, 90, -208, 90, -94, -240, 90, 90, -211, 90, 90, 90, 90, -90, -210, -215, 90, 90, 90, 90, -55, 90, 90, -93, -209, 90, 90, 90, 90, -232, -226, 90, -227, -52, 90, 90, -17, 90, -99, -14, -220, -213, 90, 90, -222, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, -228, 90, ]), 'PP_IDENTIFIER_PASTE': ([102, 314, 99, 309, 155, ], [209, 206, 206, 206, 209, ]), 'PP_DEFINE_NAME': ([11, ], [47, ]), 'FLOAT': ([6
 4, 13, 186, 231, 165, 56, 1, 35, 39, 10, 277, 9, 360, 36, 49, 32, 237, 238, 227, 332, 168, 52, 278, 133, 287, 60, 116, 134, 283, 66, 23, 12, 356, 196, 260, 54, 6, 72, 73, 28, 58, 130, 4, 17, 0, 205, 359, 20, 81, 235, 123, 221, 167, 3, 51, 353, 358, 18, 387, 286, 172, 34, 170, 137, 65, 269, 22, 37, 26, 31, 27, 327, 163, 47, 25, 30, 59, 242, 140, 2, 67, 8, 169, 5, 279, 87, 339, 280, 117, 15, 230, 38, ], [31, -133, 31, 31, -244, -246, 31, -128, -121, -119, -243, -124, -252, -129, -165, -242, 31, -169, -154, -155, 31, -156, 31, -245, -250, 31, -254, -223, -144, 31, -117, -118, -143, -248, -218, 31, -122, 31, -247, 31, -222, -170, -163, -130, -1, -249, -251, -167, 31, -172, -173, 31, 31, 31, -104, -135, -134, -126, -253, 31, 31, -125, -141, 31, -138, -221, -3, -132, -166, -127, 31, 31, -217, 31, -120, -241, 31, -219, 31, 31, -137, -123, 31, -131, -142, 31, -220, -136, -168, -2, -171, -164, ]), 'LEFT_ASSIGN': ([314, 184, 180, 317, 313, 316, 366, 109, 364, 99, 318, 102, 410, 368, 100, 78, 
 179, 423, 104, 309, 142, 74, 420, 110, 84, 292, 211, 388, 181, 220, 185, 90, 213, 182, 217, 310, 363, 105, 91, 155, 77, 75, ], [-7, -45, -16, -27, -5, -26, -25, -43, -48, -16, -24, -4, -33, -23, -22, -56, -15, -35, -10, -8, 252, -20, -34, -49, -12, -21, -29, -32, -14, -46, -47, -11, -28, -44, -17, -6, -57, -13, -19, -4, -9, -18, ]), '}': ([157, 283, 292, 379, 413, 181, 269, 278, 275, 344, 261, 112, 242, 322, 303, 296, 383, 391, 71, 384, 159, 300, 102, 286, 142, 364, 85, 211, 220, 51, 60, 139, 109, 120, 154, 163, 338, 260, 106, 115, 119, 279, 352, 258, 312, 298, 313, 84, 340, 302, 311, 268, 317, 414, 366, 91, 420, 179, 136, 363, 397, 77, 333, 122, 243, 74, 368, 162, 135, 240, 217, 226, 401, 396, 169, 356, 351, 299, 182, 308, 270, 309, 339, 348, 306, 334, 291, 388, 104, 147, 89, 90, 99, 315, 105, 144, 400, 97, 399, 140, 185, 101, 297, 110, 423, 213, 301, 310, 78, 295, 307, 316, 75, 410, 259, 405, 121, 341, 96, 58, 184, 305, 314, 180, 100, 170, 134, 143, 318, 86, 415, 83, 153, 92, 229,
  ], [269, -144, -21, -215, -235, -14, -221, 353, -203, -216, -227, -86, -219, -85, -83, -64, -204, -87, -82, 401, -211, -66, -4, 358, -56, -48, -62, -29, -46, -104, 163, -208, -43, 227, -213, -217, -236, -218, -78, -103, -159, -142, 383, -237, -74, -61, -5, -12, -240, -79, -75, -238, -27, -233, -25, -19, -34, -15, -212, -57, -231, -9, -162, -157, -239, -20, -23, -88, -210, 339, -17, 332, -205, -232, 280, -143, -206, -60, -44, -70, -228, -8, -220, -214, -69, -160, -81, -32, -10, 260, -80, -11, -16, -77, -13, -226, -207, -58, -229, 242, -47, -76, -59, -49, -35, -28, -67, -6, -56, -63, -72, -26, -18, -33, -225, -234, -161, -89, -73, -222, -45, -71, -7, -16, -22, -141, -223, -209, -24, -68, -230, -65, -224, -84, -158, ]), }
 
-_lr_action = { }
+_lr_action = {}
 for _k, _v in _lr_action_items.items():
-   for _x,_y in zip(_v[0],_v[1]):
-       _lr_action[(_x,_k)] = _y
+    for _x, _y in zip(_v[0], _v[1]):
+        _lr_action[(_x, _k)] = _y
 del _lr_action_items
 
-_lr_goto_items = {'expression_statement':([240,257,382,267,140,406,380,342,263,60,408,147,378,346,158,394,],[135,342,135,135,135,135,135,377,135,135,135,135,135,135,135,135,]),'storage_class_specifier':([140,27,28,327,167,221,60,54,59,64,2,3,1,237,231,],[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,]),'declaration_list':([64,60,27,],[167,140,59,]),'type_qualifier':([60,72,87,28,169,47,27,327,221,59,54,278,7,81,43,2,237,140,168,64,231,286,172,167,3,66,186,1,137,],[3,87,87,3,87,87,3,3,3,3,3,87,44,87,68,3,3,3,87,3,3,87,87,3,3,87,87,3,87,]),'constant':([262,380,186,176,191,408,377,266,207,409,60,183,367,80,203,202,328,276,394,166,293,272,151,76,194,378,289,158,201,147,72,190,369,228,346,79,264,197,204,381,55,224,193,257,198,382,284,174,256,47,216,141,267,384,192,189,240,140,263,137,188,354,218,208,406,219,342,113,210,215,],[91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,
 91,91,91,91,91,91,91,91,91,91,]),'volatile_opt':([93,],[200,]),'unary_expression':([256,208,47,166,346,192,197,202,141,189,194,263,215,289,198,158,201,219,409,381,207,60,369,367,193,257,176,191,137,328,174,151,276,394,384,382,408,380,342,183,76,80,203,262,147,218,354,204,377,272,224,113,210,186,284,72,228,190,79,264,216,55,267,266,293,406,240,140,188,378,],[142,78,78,142,142,78,78,78,142,78,78,142,142,78,78,142,78,142,142,142,78,142,78,142,78,142,78,78,142,78,78,78,142,142,142,142,142,142,142,142,182,185,78,142,142,78,78,78,142,142,78,78,78,142,78,142,78,78,184,142,142,78,142,142,78,142,142,142,78,142,]),'struct_or_union_specifier':([221,2,59,278,168,27,64,169,87,137,231,72,1,66,54,186,47,81,167,28,172,237,3,140,60,286,327,],[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,]),'exclusive_or_expression':([262,272,264,408,328,384,219,224,228,72,216,141,342,367,284,377,166,289,218,267,276,257,266,198,186,140,55,60,382,256,147,176,240,47,158,381,215,137,394,369,378,354,380,263,183,
 174,406,346,151,409,],[89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,291,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,]),'identifier_list':([54,],[128,]),'define':([1,],[22,]),'initializer':([384,276,166,],[400,351,274,]),'macro_param':([240,147,186,151,208,198,191,384,193,257,60,203,140,380,408,79,381,262,55,176,276,210,194,201,378,47,224,293,202,80,189,328,346,190,174,219,256,166,266,264,216,367,192,272,197,284,409,377,158,267,72,369,406,215,137,76,342,188,141,354,218,382,207,228,183,394,204,263,113,289,74,],[105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,105,179,]),'struct_declaration_list':([172,168,66,],[286,278,169,]),'macro_parameter_list':([70,],[175,]),'struct_declaration':([66,168,172,278,169,
 286,],[170,170,170,279,279,279,]),'abstract_declarator':([221,114,231,127,],[326,222,326,232,]),'iteration_statement':([406,382,240,378,60,263,158,380,140,267,147,394,408,346,],[136,136,136,136,136,136,136,136,136,136,136,136,136,136,]),'and_expression':([262,377,151,342,408,394,198,137,328,60,219,381,228,367,47,257,158,224,369,276,197,141,240,183,263,264,346,266,384,289,174,176,186,354,409,215,216,55,218,166,378,267,72,256,140,380,284,382,272,147,406,],[106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,302,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,]),'assignment_expression':([276,394,272,216,147,367,256,380,158,262,266,264,342,408,263,183,381,406,166,377,72,140,60,378,409,215,240,346,267,186,384,137,257,141,382,219,],[275,160,160,160,160,390,341,160,160,343,160,160,160,160,160,160,160,160,275,160,160,160,160,160,160,319,160,160,160,160,275,160,160,160,160,160,]),'external_dec
 laration':([1,],[15,]),'type_specifier':([237,140,28,172,167,81,221,59,47,286,3,60,87,137,27,64,231,327,66,54,72,278,168,169,1,186,2,],[28,28,28,81,28,81,28,28,81,81,28,28,81,81,28,28,28,28,81,28,81,81,81,81,28,81,28,]),'compound_statement':([140,60,378,394,147,408,406,346,59,263,382,158,267,167,240,27,64,380,],[143,143,143,143,143,143,143,143,133,143,143,143,143,277,143,56,165,143,]),'inclusive_or_expression':([60,382,47,218,409,183,272,228,377,408,328,224,166,380,284,55,186,289,151,256,346,369,367,147,240,216,266,262,158,267,276,378,219,198,140,72,406,381,354,263,257,394,342,384,264,215,141,137,174,],[71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,303,71,71,71,71,71,71,71,71,71,71,71,71,71,71,71,]),'enumerator_list_iso':([118,53,],[122,122,]),'selection_statement':([408,346,394,378,263,267,147,240,158,406,140,60,380,382,],[159,159,159,159,159,159,159,159,159,159,159,159,159,159,]),'postfix_expression':([197,394,192,137,328,194,26
 3,378,141,151,60,189,369,380,219,207,262,240,193,228,406,257,377,342,266,381,183,202,147,190,346,47,367,204,176,408,224,293,384,79,276,208,272,201,210,409,166,203,267,186,72,216,140,198,188,55,289,264,218,382,354,174,76,113,284,256,158,80,215,191,],[109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,]),'asm_expression':([151,215,409,210,276,377,183,141,378,224,80,198,192,166,262,194,72,113,406,257,189,384,394,219,354,263,240,346,284,60,207,201,203,408,382,174,264,272,176,204,266,197,216,193,328,267,190,369,228,186,381,256,147,342,380,188,158,47,55,293,208,218,289,76,79,137,191,140,202,367,],[110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,1
 10,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,]),'declaration_impl':([167,27,64,59,1,60,140,],[19,19,19,19,19,19,19,]),'type_name':([186,137,72,47,],[294,178,178,88,]),'relational_expression':([276,408,378,289,216,264,382,183,263,380,224,240,377,219,262,409,158,197,210,346,394,166,55,384,381,257,207,147,267,369,215,367,198,186,174,354,72,272,328,47,60,137,141,140,406,218,284,208,176,256,266,342,151,228,],[96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,311,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,96,312,96,96,96,96,96,96,]),'statement':([158,60,394,140,267,380,263,147,408,240,382,406,346,378,],[271,153,405,153,348,397,344,259,415,259,399,413,379,396,]),'parameter_declaration':([54,327,231,237,221,],[126,126,126,337,126,]),'cast_expression':([186,293,266,406,174,224,384,202,257,189,240,113,218,193,262,55,377,198,166,216,264,194,137,382,203,276,378,215,210,219,267,197,147,381
 ,354,409,158,208,176,256,342,188,141,207,192,272,72,204,284,228,191,346,289,394,151,408,369,60,140,47,183,263,380,328,201,190,367,],[97,363,97,97,97,97,97,97,97,97,97,220,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,299,97,97,97,97,97,298,97,97,97,97,97,97,97,97,97,97,97,97,97,97,297,97,]),'init_declarator':([29,164,57,],[62,273,62,]),'struct_declarator_list':([171,],[285,]),'multiplicative_expression':([384,367,60,55,47,166,201,406,346,204,197,72,228,203,409,262,198,381,219,194,263,207,377,257,378,137,276,210,202,189,267,158,342,256,208,218,140,141,394,188,380,183,382,328,224,272,264,174,216,289,186,354,408,215,151,369,193,147,266,240,176,284,],[85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,296,85,85,85,85,85,85,85,85,85,295,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,]),'unary_operator':([284,141,176,224,369,384,293,276,409,240,201,210,194,354,203,186,72,60,189,380,188
 ,198,55,219,218,202,207,382,190,406,76,204,113,257,256,147,158,377,151,215,208,272,137,408,183,166,262,378,267,47,140,79,191,192,193,228,264,342,80,266,197,394,216,328,381,289,263,346,174,367,],[113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,]),'assignment_operator':([142,],[256,]),'struct_or_union':([59,140,286,3,27,327,167,72,137,237,172,81,231,60,2,221,169,66,47,186,54,168,1,28,87,64,278,],[40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,40,]),'type_qualifier_list':([7,],[43,]),'enumerator':([118,229,53,],[119,334,119,]),'string_literal':([203,276,210,381,389,216,256,151,176,367,202,421,382,80,377,219,412,408,380,266,354,201,394,207,406,272,192,411,262,218,369,189,224,346,263,183,198,158,215,47,240,72,190,140,228,60,384,3
 04,188,264,378,208,191,267,409,166,289,76,204,193,113,79,257,141,137,147,55,194,74,293,342,328,174,186,284,197,],[84,84,84,84,402,84,84,84,84,84,84,402,84,84,84,84,402,84,84,84,84,84,84,84,84,84,84,402,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,365,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,84,181,84,84,84,84,84,84,84,]),'parameter_type_list':([221,327,54,231,],[325,373,125,325,]),'pointer':([29,164,231,171,127,16,57,43,221,7,357,1,114,],[14,14,234,14,234,14,14,69,225,45,14,14,225,]),'direct_declarator':([29,1,14,16,357,231,57,164,127,171,234,],[26,26,49,26,26,26,26,26,26,26,49,]),'declarator':([127,164,1,231,16,357,57,171,29,],[233,132,27,50,50,282,132,282,64,]),'argument_expression_list':([215,],[320,]),'str_opt_expr_pair_list':([412,421,389,],[418,422,404,]),'direct_abstract_declarator':([114,225,234,231,127,221,],[223,331,331,223,223,223,]),'additive_expression':([377,289,262,207,272,47,257,346,264,328,394,218,208,256,147,408,381,224,367,266,216,382,1
 83,369,276,342,186,201,60,174,193,141,176,240,409,197,203,204,210,72,263,384,219,202,284,378,354,137,380,194,140,166,267,151,215,406,158,198,55,228,],[83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,300,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,83,301,83,83,83,83,83,83,83,83,83,83,]),'constant_expression':([354,289,151,174,284,47,224,55,228,328,],[385,361,265,288,355,98,329,131,333,375,]),'primary_expression':([166,176,293,266,408,240,147,228,158,276,267,191,218,204,367,55,289,208,256,257,72,284,224,79,328,194,219,377,197,198,192,216,141,342,76,394,151,272,380,202,381,378,264,262,113,409,369,80,137,382,215,210,346,186,384,174,203,354,207,201,190,193,47,188,189,60,140,183,263,406,],[100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100
 ,100,100,100,100,100,100,]),'declaration_specifiers':([59,237,28,327,60,140,54,1,167,3,231,64,27,2,221,],[57,127,61,127,57,57,127,29,57,42,127,57,57,41,127,]),'declaration':([59,27,60,167,1,140,64,],[134,58,58,134,30,134,58,]),'logical_and_expression':([328,406,60,262,140,141,256,284,354,218,183,263,384,174,224,369,267,381,147,378,166,394,276,72,342,55,47,346,382,137,272,264,377,409,380,216,228,289,219,186,266,240,367,408,215,257,151,158,],[92,92,92,92,92,92,92,92,92,322,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,92,]),'init_declarator_list':([29,57,],[63,63,]),'shift_expression':([176,208,186,384,224,228,382,276,151,72,377,216,342,201,367,380,140,141,409,406,47,346,263,60,202,257,369,240,266,354,207,219,284,215,408,264,256,55,378,394,197,147,210,289,381,267,137,166,198,218,204,328,272,203,158,262,183,174,],[86,86,86,86,86,86,86,86,86,86,86,86,86,305,86,86,86,86,86,86,86,86,86,86,306,86,86,86,86,86,86,86,86,86,86,86
 ,86,86,86,86,86,86,86,86,86,86,86,86,86,86,308,86,86,307,86,86,86,86,]),'equality_expression':([381,284,224,378,137,380,266,216,166,267,276,151,346,158,198,55,60,272,289,257,186,328,406,176,409,147,197,408,210,384,367,183,354,218,342,140,215,369,174,228,377,382,262,141,240,47,264,72,263,394,256,219,],[101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,315,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,]),'jump_statement':([378,267,60,147,394,382,408,240,158,406,263,380,346,140,],[154,154,154,154,154,154,154,154,154,154,154,154,154,154,]),'struct_declarator':([171,357,],[281,386,]),'function_definition':([1,],[32,]),'parameter_list':([54,327,221,231,],[129,129,129,129,]),'enum_specifier':([87,231,64,27,327,66,47,59,140,168,54,172,1,137,167,3,169,60,72,278,28,186,237,286,81,2,221,],[37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,]),'str_opt_expr_p
 air':([411,421,412,389,],[417,403,403,403,]),'enumerator_list':([118,53,],[226,120,]),'labeled_statement':([408,380,240,60,267,394,406,346,382,378,158,147,140,263,],[139,139,139,139,139,139,139,139,139,139,139,139,139,139,]),'logical_or_expression':([328,55,408,406,174,224,384,257,276,377,240,166,262,378,264,215,137,381,151,216,382,141,267,369,158,284,219,256,342,147,394,409,272,346,289,72,60,183,140,263,380,47,367,354,228,186,266,],[112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,]),'specifier_qualifier_list':([168,169,172,72,186,137,286,66,278,81,47,87,],[171,171,171,114,114,114,171,171,171,187,114,195,]),'multi_string_literal':([140,72,186,267,203,346,166,183,201,409,276,293,224,176,204,193,367,47,190,202,207,381,219,408,266,342,151,264,263,194,406,228,240,354,147,192,197,80,380,369,189,60,257,256,141,284,378,218,55,328,137,158,198,394,216,21
 5,262,210,113,76,174,272,208,382,191,289,79,188,384,377,],[74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,]),'translation_unit':([0,],[1,]),'initializer_list':([276,],[352,]),'conditional_expression':([266,257,240,141,215,272,183,147,328,394,216,354,406,72,140,378,369,47,276,267,384,367,263,174,151,137,289,186,408,342,158,228,219,262,380,382,264,166,409,224,377,381,346,256,55,284,60,],[162,162,162,162,162,162,162,162,115,162,162,115,162,162,162,162,391,115,162,162,162,162,162,115,115,162,115,162,162,162,162,115,162,162,162,162,162,162,162,115,162,162,162,162,115,115,162,]),'statement_list':([140,60,],[240,147,]),'identifier':([408,293,342,208,203,218,188,183,263,380,60,140,207,266,267,141,176,256,240,284,210,113,193,369,224,219,55,381,204,197,406,346,354,206,147,137,377,158,378,189,192,272,216,47,384,209,166,394,276,174,40
 9,367,190,382,328,202,198,257,80,264,79,228,72,201,289,191,186,262,215,194,76,151,],[75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,310,75,75,75,75,75,75,75,75,75,75,75,313,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,75,]),'expression':([257,266,378,394,158,140,381,409,342,216,72,380,219,406,408,264,186,377,267,272,147,183,346,141,60,382,137,240,263,],[148,347,148,148,148,148,398,416,148,321,177,148,323,148,148,345,177,395,148,350,148,177,148,244,148,148,177,148,148,]),}
+_lr_goto_items = {'expression_statement': ([240, 257, 382, 267, 140, 406, 380, 342, 263, 60, 408, 147, 378, 346, 158, 394, ], [135, 342, 135, 135, 135, 135, 135, 377, 135, 135, 135, 135, 135, 135, 135, 135, ]), 'storage_class_specifier': ([140, 27, 28, 327, 167, 221, 60, 54, 59, 64, 2, 3, 1, 237, 231, ], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ]), 'declaration_list': ([64, 60, 27, ], [167, 140, 59, ]), 'type_qualifier': ([60, 72, 87, 28, 169, 47, 27, 327, 221, 59, 54, 278, 7, 81, 43, 2, 237, 140, 168, 64, 231, 286, 172, 167, 3, 66, 186, 1, 137, ], [3, 87, 87, 3, 87, 87, 3, 3, 3, 3, 3, 87, 44, 87, 68, 3, 3, 3, 87, 3, 3, 87, 87, 3, 3, 87, 87, 3, 87, ]), 'constant': ([262, 380, 186, 176, 191, 408, 377, 266, 207, 409, 60, 183, 367, 80, 203, 202, 328, 276, 394, 166, 293, 272, 151, 76, 194, 378, 289, 158, 201, 147, 72, 190, 369, 228, 346, 79, 264, 197, 204, 381, 55, 224, 193, 257, 198, 382, 284, 174, 256, 47, 216, 141, 267, 384, 192, 189, 240, 140, 263, 137, 188, 354, 218, 208, 406,
  219, 342, 113, 210, 215, ], [91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, ]), 'volatile_opt': ([93, ], [200, ]), 'unary_expression': ([256, 208, 47, 166, 346, 192, 197, 202, 141, 189, 194, 263, 215, 289, 198, 158, 201, 219, 409, 381, 207, 60, 369, 367, 193, 257, 176, 191, 137, 328, 174, 151, 276, 394, 384, 382, 408, 380, 342, 183, 76, 80, 203, 262, 147, 218, 354, 204, 377, 272, 224, 113, 210, 186, 284, 72, 228, 190, 79, 264, 216, 55, 267, 266, 293, 406, 240, 140, 188, 378, ], [142, 78, 78, 142, 142, 78, 78, 78, 142, 78, 78, 142, 142, 78, 78, 142, 78, 142, 142, 142, 78, 142, 78, 142, 78, 142, 78, 78, 142, 78, 78, 78, 142, 142, 142, 142, 142, 142, 142, 142, 182, 185, 78, 142, 142, 78, 78, 78, 142, 142, 78, 78, 78, 142, 78, 142, 78, 78, 184, 142, 142, 78
 , 142, 142, 78, 142, 142, 142, 78, 142, ]), 'struct_or_union_specifier': ([221, 2, 59, 278, 168, 27, 64, 169, 87, 137, 231, 72, 1, 66, 54, 186, 47, 81, 167, 28, 172, 237, 3, 140, 60, 286, 327, ], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, ]), 'exclusive_or_expression': ([262, 272, 264, 408, 328, 384, 219, 224, 228, 72, 216, 141, 342, 367, 284, 377, 166, 289, 218, 267, 276, 257, 266, 198, 186, 140, 55, 60, 382, 256, 147, 176, 240, 47, 158, 381, 215, 137, 394, 369, 378, 354, 380, 263, 183, 174, 406, 346, 151, 409, ], [89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 291, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, ]), 'identifier_list': ([54, ], [128, ]), 'define': ([1, ], [22, ]), 'initializer': ([384, 276, 166, ], [400, 351, 274, ]), 'macro_param': ([240, 147, 186, 151, 208, 198, 191, 384, 193, 257, 60, 203, 140, 380, 408, 79, 381, 262, 55, 17
 6, 276, 210, 194, 201, 378, 47, 224, 293, 202, 80, 189, 328, 346, 190, 174, 219, 256, 166, 266, 264, 216, 367, 192, 272, 197, 284, 409, 377, 158, 267, 72, 369, 406, 215, 137, 76, 342, 188, 141, 354, 218, 382, 207, 228, 183, 394, 204, 263, 113, 289, 74, ], [105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 179, ]), 'struct_declaration_list': ([172, 168, 66, ], [286, 278, 169, ]), 'macro_parameter_list': ([70, ], [175, ]), 'struct_declaration': ([66, 168, 172, 278, 169, 286, ], [170, 170, 170, 279, 279, 279, ]), 'abstract_declarator': ([221, 114, 231, 127, ], [326, 222, 326, 232, ]), 'iteration_statement': ([406, 382, 240, 378, 60, 263, 158, 380, 140, 267, 147, 394, 408, 346, ], [136, 136, 
 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, ]), 'and_expression': ([262, 377, 151, 342, 408, 394, 198, 137, 328, 60, 219, 381, 228, 367, 47, 257, 158, 224, 369, 276, 197, 141, 240, 183, 263, 264, 346, 266, 384, 289, 174, 176, 186, 354, 409, 215, 216, 55, 218, 166, 378, 267, 72, 256, 140, 380, 284, 382, 272, 147, 406, ], [106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 302, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, ]), 'assignment_expression': ([276, 394, 272, 216, 147, 367, 256, 380, 158, 262, 266, 264, 342, 408, 263, 183, 381, 406, 166, 377, 72, 140, 60, 378, 409, 215, 240, 346, 267, 186, 384, 137, 257, 141, 382, 219, ], [275, 160, 160, 160, 160, 390, 341, 160, 160, 343, 160, 160, 160, 160, 160, 160, 160, 160, 275, 160, 160, 160, 160, 160, 160, 319, 160, 160, 160, 160, 275, 160, 160, 160, 160, 160, ]), 'exter
 nal_declaration': ([1, ], [15, ]), 'type_specifier': ([237, 140, 28, 172, 167, 81, 221, 59, 47, 286, 3, 60, 87, 137, 27, 64, 231, 327, 66, 54, 72, 278, 168, 169, 1, 186, 2, ], [28, 28, 28, 81, 28, 81, 28, 28, 81, 81, 28, 28, 81, 81, 28, 28, 28, 28, 81, 28, 81, 81, 81, 81, 28, 81, 28, ]), 'compound_statement': ([140, 60, 378, 394, 147, 408, 406, 346, 59, 263, 382, 158, 267, 167, 240, 27, 64, 380, ], [143, 143, 143, 143, 143, 143, 143, 143, 133, 143, 143, 143, 143, 277, 143, 56, 165, 143, ]), 'inclusive_or_expression': ([60, 382, 47, 218, 409, 183, 272, 228, 377, 408, 328, 224, 166, 380, 284, 55, 186, 289, 151, 256, 346, 369, 367, 147, 240, 216, 266, 262, 158, 267, 276, 378, 219, 198, 140, 72, 406, 381, 354, 263, 257, 394, 342, 384, 264, 215, 141, 137, 174, ], [71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 303, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, ]), 'enumerator_list_iso': ([1
 18, 53, ], [122, 122, ]), 'selection_statement': ([408, 346, 394, 378, 263, 267, 147, 240, 158, 406, 140, 60, 380, 382, ], [159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, ]), 'postfix_expression': ([197, 394, 192, 137, 328, 194, 263, 378, 141, 151, 60, 189, 369, 380, 219, 207, 262, 240, 193, 228, 406, 257, 377, 342, 266, 381, 183, 202, 147, 190, 346, 47, 367, 204, 176, 408, 224, 293, 384, 79, 276, 208, 272, 201, 210, 409, 166, 203, 267, 186, 72, 216, 140, 198, 188, 55, 289, 264, 218, 382, 354, 174, 76, 113, 284, 256, 158, 80, 215, 191, ], [109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, 109, ]), 'asm_expression': ([151, 215, 409, 210, 276, 377, 183, 141, 378, 224, 80, 
 198, 192, 166, 262, 194, 72, 113, 406, 257, 189, 384, 394, 219, 354, 263, 240, 346, 284, 60, 207, 201, 203, 408, 382, 174, 264, 272, 176, 204, 266, 197, 216, 193, 328, 267, 190, 369, 228, 186, 381, 256, 147, 342, 380, 188, 158, 47, 55, 293, 208, 218, 289, 76, 79, 137, 191, 140, 202, 367, ], [110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, ]), 'declaration_impl': ([167, 27, 64, 59, 1, 60, 140, ], [19, 19, 19, 19, 19, 19, 19, ]), 'type_name': ([186, 137, 72, 47, ], [294, 178, 178, 88, ]), 'relational_expression': ([276, 408, 378, 289, 216, 264, 382, 183, 263, 380, 224, 240, 377, 219, 262, 409, 158, 197, 210, 346, 394, 166, 55, 384, 381, 257, 207, 147, 267, 369, 215, 367, 198, 186, 174, 35
 4, 72, 272, 328, 47, 60, 137, 141, 140, 406, 218, 284, 208, 176, 256, 266, 342, 151, 228, ], [96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 311, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 312, 96, 96, 96, 96, 96, 96, ]), 'statement': ([158, 60, 394, 140, 267, 380, 263, 147, 408, 240, 382, 406, 346, 378, ], [271, 153, 405, 153, 348, 397, 344, 259, 415, 259, 399, 413, 379, 396, ]), 'parameter_declaration': ([54, 327, 231, 237, 221, ], [126, 126, 126, 337, 126, ]), 'cast_expression': ([186, 293, 266, 406, 174, 224, 384, 202, 257, 189, 240, 113, 218, 193, 262, 55, 377, 198, 166, 216, 264, 194, 137, 382, 203, 276, 378, 215, 210, 219, 267, 197, 147, 381, 354, 409, 158, 208, 176, 256, 342, 188, 141, 207, 192, 272, 72, 204, 284, 228, 191, 346, 289, 394, 151, 408, 369, 60, 140, 47, 183, 263, 380, 328, 201, 190, 367, ], [97, 363, 97, 97, 97, 97, 97, 97, 97, 97, 97, 220, 97, 97, 97, 97, 97, 97, 97, 9
 7, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 299, 97, 97, 97, 97, 97, 298, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 297, 97, ]), 'init_declarator': ([29, 164, 57, ], [62, 273, 62, ]), 'struct_declarator_list': ([171, ], [285, ]), 'multiplicative_expression': ([384, 367, 60, 55, 47, 166, 201, 406, 346, 204, 197, 72, 228, 203, 409, 262, 198, 381, 219, 194, 263, 207, 377, 257, 378, 137, 276, 210, 202, 189, 267, 158, 342, 256, 208, 218, 140, 141, 394, 188, 380, 183, 382, 328, 224, 272, 264, 174, 216, 289, 186, 354, 408, 215, 151, 369, 193, 147, 266, 240, 176, 284, ], [85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 296, 85, 85, 85, 85, 85, 85, 85, 85, 85, 295, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, ]), 'unary_operator': ([284, 141, 176, 224, 369, 384, 293, 276, 409, 240, 201, 210, 194, 354, 203, 186, 72,
  60, 189, 380, 188, 198, 55, 219, 218, 202, 207, 382, 190, 406, 76, 204, 113, 257, 256, 147, 158, 377, 151, 215, 208, 272, 137, 408, 183, 166, 262, 378, 267, 47, 140, 79, 191, 192, 193, 228, 264, 342, 80, 266, 197, 394, 216, 328, 381, 289, 263, 346, 174, 367, ], [113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, ]), 'assignment_operator': ([142, ], [256, ]), 'struct_or_union': ([59, 140, 286, 3, 27, 327, 167, 72, 137, 237, 172, 81, 231, 60, 2, 221, 169, 66, 47, 186, 54, 168, 1, 28, 87, 64, 278, ], [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, ]), 'type_qualifier_list': ([7, ], [43, ]), 'enumerator': ([118, 229, 53, ], [119, 33
 4, 119, ]), 'string_literal': ([203, 276, 210, 381, 389, 216, 256, 151, 176, 367, 202, 421, 382, 80, 377, 219, 412, 408, 380, 266, 354, 201, 394, 207, 406, 272, 192, 411, 262, 218, 369, 189, 224, 346, 263, 183, 198, 158, 215, 47, 240, 72, 190, 140, 228, 60, 384, 304, 188, 264, 378, 208, 191, 267, 409, 166, 289, 76, 204, 193, 113, 79, 257, 141, 137, 147, 55, 194, 74, 293, 342, 328, 174, 186, 284, 197, ], [84, 84, 84, 84, 402, 84, 84, 84, 84, 84, 84, 402, 84, 84, 84, 84, 402, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 402, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 365, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 181, 84, 84, 84, 84, 84, 84, 84, ]), 'parameter_type_list': ([221, 327, 54, 231, ], [325, 373, 125, 325, ]), 'pointer': ([29, 164, 231, 171, 127, 16, 57, 43, 221, 7, 357, 1, 114, ], [14, 14, 234, 14, 234, 14, 14, 69, 225, 45, 14, 14, 225, ]), 'direct_declarator': ([29, 1, 14, 16, 357, 231, 57, 164, 127, 171, 23
 4, ], [26, 26, 49, 26, 26, 26, 26, 26, 26, 26, 49, ]), 'declarator': ([127, 164, 1, 231, 16, 357, 57, 171, 29, ], [233, 132, 27, 50, 50, 282, 132, 282, 64, ]), 'argument_expression_list': ([215, ], [320, ]), 'str_opt_expr_pair_list': ([412, 421, 389, ], [418, 422, 404, ]), 'direct_abstract_declarator': ([114, 225, 234, 231, 127, 221, ], [223, 331, 331, 223, 223, 223, ]), 'additive_expression': ([377, 289, 262, 207, 272, 47, 257, 346, 264, 328, 394, 218, 208, 256, 147, 408, 381, 224, 367, 266, 216, 382, 183, 369, 276, 342, 186, 201, 60, 174, 193, 141, 176, 240, 409, 197, 203, 204, 210, 72, 263, 384, 219, 202, 284, 378, 354, 137, 380, 194, 140, 166, 267, 151, 215, 406, 158, 198, 55, 228, ], [83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 300, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 301, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, ]), 'constant_expression': ([354, 289, 151, 174, 284, 47
 , 224, 55, 228, 328, ], [385, 361, 265, 288, 355, 98, 329, 131, 333, 375, ]), 'primary_expression': ([166, 176, 293, 266, 408, 240, 147, 228, 158, 276, 267, 191, 218, 204, 367, 55, 289, 208, 256, 257, 72, 284, 224, 79, 328, 194, 219, 377, 197, 198, 192, 216, 141, 342, 76, 394, 151, 272, 380, 202, 381, 378, 264, 262, 113, 409, 369, 80, 137, 382, 215, 210, 346, 186, 384, 174, 203, 354, 207, 201, 190, 193, 47, 188, 189, 60, 140, 183, 263, 406, ], [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, ]), 'declaration_specifiers': ([59, 237, 28, 327, 60, 140, 54, 1, 167, 3, 231, 64, 27, 2, 221, ], [57, 127, 61, 127, 57, 57, 127, 29, 57, 42, 127, 57, 57, 41, 127, ]), 'declaration': ([59, 27, 60, 1
 67, 1, 140, 64, ], [134, 58, 58, 134, 30, 134, 58, ]), 'logical_and_expression': ([328, 406, 60, 262, 140, 141, 256, 284, 354, 218, 183, 263, 384, 174, 224, 369, 267, 381, 147, 378, 166, 394, 276, 72, 342, 55, 47, 346, 382, 137, 272, 264, 377, 409, 380, 216, 228, 289, 219, 186, 266, 240, 367, 408, 215, 257, 151, 158, ], [92, 92, 92, 92, 92, 92, 92, 92, 92, 322, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, ]), 'init_declarator_list': ([29, 57, ], [63, 63, ]), 'shift_expression': ([176, 208, 186, 384, 224, 228, 382, 276, 151, 72, 377, 216, 342, 201, 367, 380, 140, 141, 409, 406, 47, 346, 263, 60, 202, 257, 369, 240, 266, 354, 207, 219, 284, 215, 408, 264, 256, 55, 378, 394, 197, 147, 210, 289, 381, 267, 137, 166, 198, 218, 204, 328, 272, 203, 158, 262, 183, 174, ], [86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 305, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 306, 86, 86, 86, 8
 6, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 308, 86, 86, 307, 86, 86, 86, 86, ]), 'equality_expression': ([381, 284, 224, 378, 137, 380, 266, 216, 166, 267, 276, 151, 346, 158, 198, 55, 60, 272, 289, 257, 186, 328, 406, 176, 409, 147, 197, 408, 210, 384, 367, 183, 354, 218, 342, 140, 215, 369, 174, 228, 377, 382, 262, 141, 240, 47, 264, 72, 263, 394, 256, 219, ], [101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 315, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, ]), 'jump_statement': ([378, 267, 60, 147, 394, 382, 408, 240, 158, 406, 263, 380, 346, 140, ], [154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, 154, ]), 'struct_declarator': ([171, 357, ], [281, 386, ]), 'function_definition': ([1, ], [32, ]), 'parameter_list': ([54, 327, 221, 231, ], [129, 129, 129, 129, ])
 , 'enum_specifier': ([87, 231, 64, 27, 327, 66, 47, 59, 140, 168, 54, 172, 1, 137, 167, 3, 169, 60, 72, 278, 28, 186, 237, 286, 81, 2, 221, ], [37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, ]), 'str_opt_expr_pair': ([411, 421, 412, 389, ], [417, 403, 403, 403, ]), 'enumerator_list': ([118, 53, ], [226, 120, ]), 'labeled_statement': ([408, 380, 240, 60, 267, 394, 406, 346, 382, 378, 158, 147, 140, 263, ], [139, 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, 139, ]), 'logical_or_expression': ([328, 55, 408, 406, 174, 224, 384, 257, 276, 377, 240, 166, 262, 378, 264, 215, 137, 381, 151, 216, 382, 141, 267, 369, 158, 284, 219, 256, 342, 147, 394, 409, 272, 346, 289, 72, 60, 183, 140, 263, 380, 47, 367, 354, 228, 186, 266, ], [112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 
 112, 112, 112, 112, 112, 112, 112, 112, 112, ]), 'specifier_qualifier_list': ([168, 169, 172, 72, 186, 137, 286, 66, 278, 81, 47, 87, ], [171, 171, 171, 114, 114, 114, 171, 171, 171, 187, 114, 195, ]), 'multi_string_literal': ([140, 72, 186, 267, 203, 346, 166, 183, 201, 409, 276, 293, 224, 176, 204, 193, 367, 47, 190, 202, 207, 381, 219, 408, 266, 342, 151, 264, 263, 194, 406, 228, 240, 354, 147, 192, 197, 80, 380, 369, 189, 60, 257, 256, 141, 284, 378, 218, 55, 328, 137, 158, 198, 394, 216, 215, 262, 210, 113, 76, 174, 272, 208, 382, 191, 289, 79, 188, 384, 377, ], [74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, ]), 'translation_unit': ([0, ], [1, ]), 'initializer_list': ([276, ], [352, ]), 'conditional_expression': ([266, 257, 240, 141, 215, 272, 183,
  147, 328, 394, 216, 354, 406, 72, 140, 378, 369, 47, 276, 267, 384, 367, 263, 174, 151, 137, 289, 186, 408, 342, 158, 228, 219, 262, 380, 382, 264, 166, 409, 224, 377, 381, 346, 256, 55, 284, 60, ], [162, 162, 162, 162, 162, 162, 162, 162, 115, 162, 162, 115, 162, 162, 162, 162, 391, 115, 162, 162, 162, 162, 162, 115, 115, 162, 115, 162, 162, 162, 162, 115, 162, 162, 162, 162, 162, 162, 162, 115, 162, 162, 162, 162, 115, 115, 162, ]), 'statement_list': ([140, 60, ], [240, 147, ]), 'identifier': ([408, 293, 342, 208, 203, 218, 188, 183, 263, 380, 60, 140, 207, 266, 267, 141, 176, 256, 240, 284, 210, 113, 193, 369, 224, 219, 55, 381, 204, 197, 406, 346, 354, 206, 147, 137, 377, 158, 378, 189, 192, 272, 216, 47, 384, 209, 166, 394, 276, 174, 409, 367, 190, 382, 328, 202, 198, 257, 80, 264, 79, 228, 72, 201, 289, 191, 186, 262, 215, 194, 76, 151, ], [75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 310, 
 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 313, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, ]), 'expression': ([257, 266, 378, 394, 158, 140, 381, 409, 342, 216, 72, 380, 219, 406, 408, 264, 186, 377, 267, 272, 147, 183, 346, 141, 60, 382, 137, 240, 263, ], [148, 347, 148, 148, 148, 148, 398, 416, 148, 321, 177, 148, 323, 148, 148, 345, 177, 395, 148, 350, 148, 177, 148, 244, 148, 148, 177, 148, 148, ]), }
 
-_lr_goto = { }
+_lr_goto = {}
 for _k, _v in _lr_goto_items.items():
-   for _x,_y in zip(_v[0],_v[1]):
-       _lr_goto[(_x,_k)] = _y
+    for _x, _y in zip(_v[0], _v[1]):
+        _lr_goto[(_x, _k)] = _y
 del _lr_goto_items
 _lr_productions = [
-  ("S'",1,None,None,None),
-  ('translation_unit',0,'p_translation_unit','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',57),
-  ('translation_unit',2,'p_translation_unit','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',58),
-  ('translation_unit',2,'p_translation_unit','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',59),
-  ('identifier',1,'p_identifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',67),
-  ('identifier',3,'p_identifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',68),
-  ('identifier',3,'p_identifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',69),
-  ('identifier',3,'p_identifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',70),
-  ('identifier',3,'p_identifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',71),
-  ('constant',1,'p_constant','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',87),
-  ('constant',1,'p_constant','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',88),
-  ('string_literal',1,'p_string_literal','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',111),
-  ('multi_string_literal',1,'p_multi_string_literal','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',115),
-  ('multi_string_literal',1,'p_multi_string_literal','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',116),
-  ('multi_string_literal',2,'p_multi_string_literal','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',117),
-  ('multi_string_literal',2,'p_multi_string_literal','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',118),
-  ('macro_param',1,'p_macro_param','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',127),
-  ('macro_param',2,'p_macro_param','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',128),
-  ('primary_expression',1,'p_primary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',136),
-  ('primary_expression',1,'p_primary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',137),
-  ('primary_expression',1,'p_primary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',138),
-  ('primary_expression',3,'p_primary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',139),
-  ('postfix_expression',1,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',147),
-  ('postfix_expression',4,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',148),
-  ('postfix_expression',3,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',149),
-  ('postfix_expression',4,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',150),
-  ('postfix_expression',3,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',151),
-  ('postfix_expression',3,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',152),
-  ('postfix_expression',2,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',153),
-  ('postfix_expression',2,'p_postfix_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',154),
-  ('argument_expression_list',1,'p_argument_expression_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',187),
-  ('argument_expression_list',3,'p_argument_expression_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',188),
-  ('asm_expression',5,'p_asm_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',197),
-  ('asm_expression',7,'p_asm_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',198),
-  ('asm_expression',9,'p_asm_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',199),
-  ('asm_expression',11,'p_asm_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',200),
-  ('str_opt_expr_pair_list',0,'p_str_opt_expr_pair_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',212),
-  ('str_opt_expr_pair_list',1,'p_str_opt_expr_pair_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',213),
-  ('str_opt_expr_pair_list',3,'p_str_opt_expr_pair_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',214),
-  ('str_opt_expr_pair',1,'p_str_opt_expr_pair','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',218),
-  ('str_opt_expr_pair',4,'p_str_opt_expr_pair','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',219),
-  ('volatile_opt',0,'p_volatile_opt','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',223),
-  ('volatile_opt',1,'p_volatile_opt','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',224),
-  ('unary_expression',1,'p_unary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',239),
-  ('unary_expression',2,'p_unary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',240),
-  ('unary_expression',2,'p_unary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',241),
-  ('unary_expression',2,'p_unary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',242),
-  ('unary_expression',2,'p_unary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',243),
-  ('unary_expression',4,'p_unary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',244),
-  ('unary_expression',1,'p_unary_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',245),
-  ('unary_operator',1,'p_unary_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',262),
-  ('unary_operator',1,'p_unary_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',263),
-  ('unary_operator',1,'p_unary_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',264),
-  ('unary_operator',1,'p_unary_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',265),
-  ('unary_operator',1,'p_unary_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',266),
-  ('unary_operator',1,'p_unary_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',267),
-  ('cast_expression',1,'p_cast_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',272),
-  ('cast_expression',4,'p_cast_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',273),
-  ('multiplicative_expression',1,'p_multiplicative_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',287),
-  ('multiplicative_expression',3,'p_multiplicative_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',288),
-  ('multiplicative_expression',3,'p_multiplicative_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',289),
-  ('multiplicative_expression',3,'p_multiplicative_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',290),
-  ('additive_expression',1,'p_additive_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',305),
-  ('additive_expression',3,'p_additive_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',306),
-  ('additive_expression',3,'p_additive_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',307),
-  ('shift_expression',1,'p_shift_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',322),
-  ('shift_expression',3,'p_shift_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',323),
-  ('shift_expression',3,'p_shift_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',324),
-  ('relational_expression',1,'p_relational_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',341),
-  ('relational_expression',3,'p_relational_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',342),
-  ('relational_expression',3,'p_relational_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',343),
-  ('relational_expression',3,'p_relational_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',344),
-  ('relational_expression',3,'p_relational_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',345),
-  ('equality_expression',1,'p_equality_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',360),
-  ('equality_expression',3,'p_equality_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',361),
-  ('equality_expression',3,'p_equality_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',362),
-  ('and_expression',1,'p_and_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',372),
-  ('and_expression',3,'p_and_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',373),
-  ('exclusive_or_expression',1,'p_exclusive_or_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',382),
-  ('exclusive_or_expression',3,'p_exclusive_or_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',383),
-  ('inclusive_or_expression',1,'p_inclusive_or_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',392),
-  ('inclusive_or_expression',3,'p_inclusive_or_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',393),
-  ('logical_and_expression',1,'p_logical_and_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',402),
-  ('logical_and_expression',3,'p_logical_and_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',403),
-  ('logical_or_expression',1,'p_logical_or_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',412),
-  ('logical_or_expression',3,'p_logical_or_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',413),
-  ('conditional_expression',1,'p_conditional_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',422),
-  ('conditional_expression',5,'p_conditional_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',423),
-  ('assignment_expression',1,'p_assignment_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',444),
-  ('assignment_expression',3,'p_assignment_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',445),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',460),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',461),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',462),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',463),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',464),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',465),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',466),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',467),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',468),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',469),
-  ('assignment_operator',1,'p_assignment_operator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',470),
-  ('expression',1,'p_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',475),
-  ('expression',3,'p_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',476),
-  ('constant_expression',1,'p_constant_expression','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',482),
-  ('declaration',2,'p_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',487),
-  ('declaration_impl',1,'p_declaration_impl','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',494),
-  ('declaration_impl',2,'p_declaration_impl','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',495),
-  ('declaration_specifiers',1,'p_declaration_specifiers','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',519),
-  ('declaration_specifiers',2,'p_declaration_specifiers','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',520),
-  ('declaration_specifiers',1,'p_declaration_specifiers','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',521),
-  ('declaration_specifiers',2,'p_declaration_specifiers','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',522),
-  ('declaration_specifiers',1,'p_declaration_specifiers','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',523),
-  ('declaration_specifiers',2,'p_declaration_specifiers','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',524),
-  ('init_declarator_list',1,'p_init_declarator_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',532),
-  ('init_declarator_list',3,'p_init_declarator_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',533),
-  ('init_declarator',1,'p_init_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',541),
-  ('init_declarator',3,'p_init_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',542),
-  ('storage_class_specifier',1,'p_storage_class_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',549),
-  ('storage_class_specifier',1,'p_storage_class_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',550),
-  ('storage_class_specifier',1,'p_storage_class_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',551),
-  ('storage_class_specifier',1,'p_storage_class_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',552),
-  ('storage_class_specifier',1,'p_storage_class_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',553),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',558),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',559),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',560),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',561),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',562),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',563),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',564),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',565),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',566),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',567),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',568),
-  ('type_specifier',1,'p_type_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',569),
-  ('struct_or_union_specifier',5,'p_struct_or_union_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',578),
-  ('struct_or_union_specifier',5,'p_struct_or_union_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',579),
-  ('struct_or_union_specifier',4,'p_struct_or_union_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',580),
-  ('struct_or_union_specifier',2,'p_struct_or_union_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',581),
-  ('struct_or_union_specifier',2,'p_struct_or_union_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',582),
-  ('struct_or_union',1,'p_struct_or_union','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',598),
-  ('struct_or_union',1,'p_struct_or_union','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',599),
-  ('struct_declaration_list',1,'p_struct_declaration_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',604),
-  ('struct_declaration_list',2,'p_struct_declaration_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',605),
-  ('struct_declaration',3,'p_struct_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',613),
-  ('struct_declaration',2,'p_struct_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',614),
-  ('specifier_qualifier_list',2,'p_specifier_qualifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',628),
-  ('specifier_qualifier_list',1,'p_specifier_qualifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',629),
-  ('specifier_qualifier_list',2,'p_specifier_qualifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',630),
-  ('specifier_qualifier_list',1,'p_specifier_qualifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',631),
-  ('struct_declarator_list',1,'p_struct_declarator_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',640),
-  ('struct_declarator_list',3,'p_struct_declarator_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',641),
-  ('struct_declarator',1,'p_struct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',649),
-  ('struct_declarator',2,'p_struct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',650),
-  ('struct_declarator',3,'p_struct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',651),
-  ('enum_specifier',4,'p_enum_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',662),
-  ('enum_specifier',5,'p_enum_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',663),
-  ('enum_specifier',2,'p_enum_specifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',664),
-  ('enumerator_list',1,'p_enumerator_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',677),
-  ('enumerator_list',2,'p_enumerator_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',678),
-  ('enumerator_list_iso',1,'p_enumerator_list_iso','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',685),
-  ('enumerator_list_iso',3,'p_enumerator_list_iso','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',686),
-  ('enumerator',1,'p_enumerator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',694),
-  ('enumerator',3,'p_enumerator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',695),
-  ('type_qualifier',1,'p_type_qualifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',703),
-  ('type_qualifier',1,'p_type_qualifier','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',704),
-  ('declarator',2,'p_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',709),
-  ('declarator',1,'p_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',710),
-  ('direct_declarator',1,'p_direct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',722),
-  ('direct_declarator',3,'p_direct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',723),
-  ('direct_declarator',4,'p_direct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',724),
-  ('direct_declarator',3,'p_direct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',725),
-  ('direct_declarator',4,'p_direct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',726),
-  ('direct_declarator',4,'p_direct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',727),
-  ('direct_declarator',3,'p_direct_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',728),
-  ('pointer',1,'p_pointer','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',757),
-  ('pointer',2,'p_pointer','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',758),
-  ('pointer',2,'p_pointer','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',759),
-  ('pointer',3,'p_pointer','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',760),
-  ('type_qualifier_list',1,'p_type_qualifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',777),
-  ('type_qualifier_list',2,'p_type_qualifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',778),
-  ('parameter_type_list',1,'p_parameter_type_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',786),
-  ('parameter_type_list',3,'p_parameter_type_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',787),
-  ('parameter_list',1,'p_parameter_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',796),
-  ('parameter_list',3,'p_parameter_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',797),
-  ('parameter_declaration',2,'p_parameter_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',805),
-  ('parameter_declaration',2,'p_parameter_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',806),
-  ('parameter_declaration',1,'p_parameter_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',807),
-  ('identifier_list',1,'p_identifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',815),
-  ('identifier_list',3,'p_identifier_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',816),
-  ('type_name',1,'p_type_name','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',828),
-  ('type_name',2,'p_type_name','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',829),
-  ('abstract_declarator',1,'p_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',845),
-  ('abstract_declarator',1,'p_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',846),
-  ('abstract_declarator',2,'p_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',847),
-  ('direct_abstract_declarator',3,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',866),
-  ('direct_abstract_declarator',2,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',867),
-  ('direct_abstract_declarator',3,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',868),
-  ('direct_abstract_declarator',3,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',869),
-  ('direct_abstract_declarator',4,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',870),
-  ('direct_abstract_declarator',2,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',871),
-  ('direct_abstract_declarator',3,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',872),
-  ('direct_abstract_declarator',3,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',873),
-  ('direct_abstract_declarator',4,'p_direct_abstract_declarator','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',874),
-  ('initializer',1,'p_initializer','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',911),
-  ('initializer',3,'p_initializer','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',912),
-  ('initializer',4,'p_initializer','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',913),
-  ('initializer_list',1,'p_initializer_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',917),
-  ('initializer_list',3,'p_initializer_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',918),
-  ('statement',1,'p_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',922),
-  ('statement',1,'p_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',923),
-  ('statement',1,'p_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',924),
-  ('statement',1,'p_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',925),
-  ('statement',1,'p_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',926),
-  ('statement',1,'p_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',927),
-  ('labeled_statement',3,'p_labeled_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',931),
-  ('labeled_statement',4,'p_labeled_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',932),
-  ('labeled_statement',3,'p_labeled_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',933),
-  ('compound_statement',2,'p_compound_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',937),
-  ('compound_statement',3,'p_compound_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',938),
-  ('compound_statement',3,'p_compound_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',939),
-  ('compound_statement',4,'p_compound_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',940),
-  ('compound_statement',3,'p_compound_statement_error','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',944),
-  ('declaration_list',1,'p_declaration_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',949),
-  ('declaration_list',2,'p_declaration_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',950),
-  ('statement_list',1,'p_statement_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',954),
-  ('statement_list',2,'p_statement_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',955),
-  ('expression_statement',1,'p_expression_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',959),
-  ('expression_statement',2,'p_expression_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',960),
-  ('expression_statement',2,'p_expression_statement_error','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',963),
-  ('selection_statement',5,'p_selection_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',968),
-  ('selection_statement',7,'p_selection_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',969),
-  ('selection_statement',5,'p_selection_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',970),
-  ('iteration_statement',5,'p_iteration_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',974),
-  ('iteration_statement',7,'p_iteration_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',975),
-  ('iteration_statement',6,'p_iteration_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',976),
-  ('iteration_statement',7,'p_iteration_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',977),
-  ('jump_statement',3,'p_jump_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',981),
-  ('jump_statement',2,'p_jump_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',982),
-  ('jump_statement',2,'p_jump_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',983),
-  ('jump_statement',2,'p_jump_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',984),
-  ('jump_statement',3,'p_jump_statement','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',985),
-  ('external_declaration',1,'p_external_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',989),
-  ('external_declaration',1,'p_external_declaration','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',990),
-  ('function_definition',4,'p_function_definition','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',996),
-  ('function_definition',3,'p_function_definition','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',997),
-  ('function_definition',3,'p_function_definition','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',998),
-  ('function_definition',2,'p_function_definition','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',999),
-  ('define',3,'p_define','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1003),
-  ('define',4,'p_define','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1004),
-  ('define',4,'p_define','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1005),
-  ('define',5,'p_define','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1006),
-  ('define',6,'p_define','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1007),
-  ('define',6,'p_define','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1008),
-  ('define',7,'p_define','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1009),
-  ('define',3,'p_define_error','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1042),
-  ('macro_parameter_list',1,'p_macro_parameter_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1071),
-  ('macro_parameter_list',3,'p_macro_parameter_list','/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py',1072),
+    ("S'", 1, None, None, None),
+    ('translation_unit', 0, 'p_translation_unit', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 57),
+    ('translation_unit', 2, 'p_translation_unit', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 58),
+    ('translation_unit', 2, 'p_translation_unit', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 59),
+    ('identifier', 1, 'p_identifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 67),
+    ('identifier', 3, 'p_identifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 68),
+    ('identifier', 3, 'p_identifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 69),
+    ('identifier', 3, 'p_identifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 70),
+    ('identifier', 3, 'p_identifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 71),
+    ('constant', 1, 'p_constant', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 87),
+    ('constant', 1, 'p_constant', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 88),
+    ('string_literal', 1, 'p_string_literal', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 111),
+    ('multi_string_literal', 1, 'p_multi_string_literal', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 115),
+    ('multi_string_literal', 1, 'p_multi_string_literal', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 116),
+    ('multi_string_literal', 2, 'p_multi_string_literal', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 117),
+    ('multi_string_literal', 2, 'p_multi_string_literal', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 118),
+    ('macro_param', 1, 'p_macro_param', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 127),
+    ('macro_param', 2, 'p_macro_param', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 128),
+    ('primary_expression', 1, 'p_primary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 136),
+    ('primary_expression', 1, 'p_primary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 137),
+    ('primary_expression', 1, 'p_primary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 138),
+    ('primary_expression', 3, 'p_primary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 139),
+    ('postfix_expression', 1, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 147),
+    ('postfix_expression', 4, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 148),
+    ('postfix_expression', 3, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 149),
+    ('postfix_expression', 4, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 150),
+    ('postfix_expression', 3, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 151),
+    ('postfix_expression', 3, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 152),
+    ('postfix_expression', 2, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 153),
+    ('postfix_expression', 2, 'p_postfix_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 154),
+    ('argument_expression_list', 1, 'p_argument_expression_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 187),
+    ('argument_expression_list', 3, 'p_argument_expression_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 188),
+    ('asm_expression', 5, 'p_asm_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 197),
+    ('asm_expression', 7, 'p_asm_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 198),
+    ('asm_expression', 9, 'p_asm_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 199),
+    ('asm_expression', 11, 'p_asm_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 200),
+    ('str_opt_expr_pair_list', 0, 'p_str_opt_expr_pair_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 212),
+    ('str_opt_expr_pair_list', 1, 'p_str_opt_expr_pair_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 213),
+    ('str_opt_expr_pair_list', 3, 'p_str_opt_expr_pair_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 214),
+    ('str_opt_expr_pair', 1, 'p_str_opt_expr_pair', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 218),
+    ('str_opt_expr_pair', 4, 'p_str_opt_expr_pair', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 219),
+    ('volatile_opt', 0, 'p_volatile_opt', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 223),
+    ('volatile_opt', 1, 'p_volatile_opt', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 224),
+    ('unary_expression', 1, 'p_unary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 239),
+    ('unary_expression', 2, 'p_unary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 240),
+    ('unary_expression', 2, 'p_unary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 241),
+    ('unary_expression', 2, 'p_unary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 242),
+    ('unary_expression', 2, 'p_unary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 243),
+    ('unary_expression', 4, 'p_unary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 244),
+    ('unary_expression', 1, 'p_unary_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 245),
+    ('unary_operator', 1, 'p_unary_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 262),
+    ('unary_operator', 1, 'p_unary_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 263),
+    ('unary_operator', 1, 'p_unary_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 264),
+    ('unary_operator', 1, 'p_unary_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 265),
+    ('unary_operator', 1, 'p_unary_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 266),
+    ('unary_operator', 1, 'p_unary_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 267),
+    ('cast_expression', 1, 'p_cast_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 272),
+    ('cast_expression', 4, 'p_cast_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 273),
+    ('multiplicative_expression', 1, 'p_multiplicative_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 287),
+    ('multiplicative_expression', 3, 'p_multiplicative_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 288),
+    ('multiplicative_expression', 3, 'p_multiplicative_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 289),
+    ('multiplicative_expression', 3, 'p_multiplicative_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 290),
+    ('additive_expression', 1, 'p_additive_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 305),
+    ('additive_expression', 3, 'p_additive_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 306),
+    ('additive_expression', 3, 'p_additive_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 307),
+    ('shift_expression', 1, 'p_shift_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 322),
+    ('shift_expression', 3, 'p_shift_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 323),
+    ('shift_expression', 3, 'p_shift_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 324),
+    ('relational_expression', 1, 'p_relational_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 341),
+    ('relational_expression', 3, 'p_relational_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 342),
+    ('relational_expression', 3, 'p_relational_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 343),
+    ('relational_expression', 3, 'p_relational_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 344),
+    ('relational_expression', 3, 'p_relational_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 345),
+    ('equality_expression', 1, 'p_equality_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 360),
+    ('equality_expression', 3, 'p_equality_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 361),
+    ('equality_expression', 3, 'p_equality_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 362),
+    ('and_expression', 1, 'p_and_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 372),
+    ('and_expression', 3, 'p_and_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 373),
+    ('exclusive_or_expression', 1, 'p_exclusive_or_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 382),
+    ('exclusive_or_expression', 3, 'p_exclusive_or_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 383),
+    ('inclusive_or_expression', 1, 'p_inclusive_or_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 392),
+    ('inclusive_or_expression', 3, 'p_inclusive_or_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 393),
+    ('logical_and_expression', 1, 'p_logical_and_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 402),
+    ('logical_and_expression', 3, 'p_logical_and_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 403),
+    ('logical_or_expression', 1, 'p_logical_or_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 412),
+    ('logical_or_expression', 3, 'p_logical_or_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 413),
+    ('conditional_expression', 1, 'p_conditional_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 422),
+    ('conditional_expression', 5, 'p_conditional_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 423),
+    ('assignment_expression', 1, 'p_assignment_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 444),
+    ('assignment_expression', 3, 'p_assignment_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 445),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 460),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 461),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 462),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 463),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 464),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 465),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 466),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 467),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 468),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 469),
+    ('assignment_operator', 1, 'p_assignment_operator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 470),
+    ('expression', 1, 'p_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 475),
+    ('expression', 3, 'p_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 476),
+    ('constant_expression', 1, 'p_constant_expression', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 482),
+    ('declaration', 2, 'p_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 487),
+    ('declaration_impl', 1, 'p_declaration_impl', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 494),
+    ('declaration_impl', 2, 'p_declaration_impl', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 495),
+    ('declaration_specifiers', 1, 'p_declaration_specifiers', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 519),
+    ('declaration_specifiers', 2, 'p_declaration_specifiers', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 520),
+    ('declaration_specifiers', 1, 'p_declaration_specifiers', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 521),
+    ('declaration_specifiers', 2, 'p_declaration_specifiers', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 522),
+    ('declaration_specifiers', 1, 'p_declaration_specifiers', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 523),
+    ('declaration_specifiers', 2, 'p_declaration_specifiers', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 524),
+    ('init_declarator_list', 1, 'p_init_declarator_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 532),
+    ('init_declarator_list', 3, 'p_init_declarator_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 533),
+    ('init_declarator', 1, 'p_init_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 541),
+    ('init_declarator', 3, 'p_init_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 542),
+    ('storage_class_specifier', 1, 'p_storage_class_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 549),
+    ('storage_class_specifier', 1, 'p_storage_class_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 550),
+    ('storage_class_specifier', 1, 'p_storage_class_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 551),
+    ('storage_class_specifier', 1, 'p_storage_class_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 552),
+    ('storage_class_specifier', 1, 'p_storage_class_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 553),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 558),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 559),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 560),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 561),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 562),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 563),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 564),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 565),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 566),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 567),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 568),
+    ('type_specifier', 1, 'p_type_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 569),
+    ('struct_or_union_specifier', 5, 'p_struct_or_union_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 578),
+    ('struct_or_union_specifier', 5, 'p_struct_or_union_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 579),
+    ('struct_or_union_specifier', 4, 'p_struct_or_union_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 580),
+    ('struct_or_union_specifier', 2, 'p_struct_or_union_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 581),
+    ('struct_or_union_specifier', 2, 'p_struct_or_union_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 582),
+    ('struct_or_union', 1, 'p_struct_or_union', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 598),
+    ('struct_or_union', 1, 'p_struct_or_union', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 599),
+    ('struct_declaration_list', 1, 'p_struct_declaration_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 604),
+    ('struct_declaration_list', 2, 'p_struct_declaration_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 605),
+    ('struct_declaration', 3, 'p_struct_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 613),
+    ('struct_declaration', 2, 'p_struct_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 614),
+    ('specifier_qualifier_list', 2, 'p_specifier_qualifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 628),
+    ('specifier_qualifier_list', 1, 'p_specifier_qualifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 629),
+    ('specifier_qualifier_list', 2, 'p_specifier_qualifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 630),
+    ('specifier_qualifier_list', 1, 'p_specifier_qualifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 631),
+    ('struct_declarator_list', 1, 'p_struct_declarator_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 640),
+    ('struct_declarator_list', 3, 'p_struct_declarator_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 641),
+    ('struct_declarator', 1, 'p_struct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 649),
+    ('struct_declarator', 2, 'p_struct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 650),
+    ('struct_declarator', 3, 'p_struct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 651),
+    ('enum_specifier', 4, 'p_enum_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 662),
+    ('enum_specifier', 5, 'p_enum_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 663),
+    ('enum_specifier', 2, 'p_enum_specifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 664),
+    ('enumerator_list', 1, 'p_enumerator_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 677),
+    ('enumerator_list', 2, 'p_enumerator_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 678),
+    ('enumerator_list_iso', 1, 'p_enumerator_list_iso', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 685),
+    ('enumerator_list_iso', 3, 'p_enumerator_list_iso', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 686),
+    ('enumerator', 1, 'p_enumerator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 694),
+    ('enumerator', 3, 'p_enumerator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 695),
+    ('type_qualifier', 1, 'p_type_qualifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 703),
+    ('type_qualifier', 1, 'p_type_qualifier', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 704),
+    ('declarator', 2, 'p_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 709),
+    ('declarator', 1, 'p_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 710),
+    ('direct_declarator', 1, 'p_direct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 722),
+    ('direct_declarator', 3, 'p_direct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 723),
+    ('direct_declarator', 4, 'p_direct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 724),
+    ('direct_declarator', 3, 'p_direct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 725),
+    ('direct_declarator', 4, 'p_direct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 726),
+    ('direct_declarator', 4, 'p_direct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 727),
+    ('direct_declarator', 3, 'p_direct_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 728),
+    ('pointer', 1, 'p_pointer', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 757),
+    ('pointer', 2, 'p_pointer', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 758),
+    ('pointer', 2, 'p_pointer', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 759),
+    ('pointer', 3, 'p_pointer', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 760),
+    ('type_qualifier_list', 1, 'p_type_qualifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 777),
+    ('type_qualifier_list', 2, 'p_type_qualifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 778),
+    ('parameter_type_list', 1, 'p_parameter_type_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 786),
+    ('parameter_type_list', 3, 'p_parameter_type_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 787),
+    ('parameter_list', 1, 'p_parameter_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 796),
+    ('parameter_list', 3, 'p_parameter_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 797),
+    ('parameter_declaration', 2, 'p_parameter_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 805),
+    ('parameter_declaration', 2, 'p_parameter_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 806),
+    ('parameter_declaration', 1, 'p_parameter_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 807),
+    ('identifier_list', 1, 'p_identifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 815),
+    ('identifier_list', 3, 'p_identifier_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 816),
+    ('type_name', 1, 'p_type_name', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 828),
+    ('type_name', 2, 'p_type_name', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 829),
+    ('abstract_declarator', 1, 'p_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 845),
+    ('abstract_declarator', 1, 'p_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 846),
+    ('abstract_declarator', 2, 'p_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 847),
+    ('direct_abstract_declarator', 3, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 866),
+    ('direct_abstract_declarator', 2, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 867),
+    ('direct_abstract_declarator', 3, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 868),
+    ('direct_abstract_declarator', 3, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 869),
+    ('direct_abstract_declarator', 4, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 870),
+    ('direct_abstract_declarator', 2, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 871),
+    ('direct_abstract_declarator', 3, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 872),
+    ('direct_abstract_declarator', 3, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 873),
+    ('direct_abstract_declarator', 4, 'p_direct_abstract_declarator', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 874),
+    ('initializer', 1, 'p_initializer', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 911),
+    ('initializer', 3, 'p_initializer', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 912),
+    ('initializer', 4, 'p_initializer', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 913),
+    ('initializer_list', 1, 'p_initializer_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 917),
+    ('initializer_list', 3, 'p_initializer_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 918),
+    ('statement', 1, 'p_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 922),
+    ('statement', 1, 'p_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 923),
+    ('statement', 1, 'p_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 924),
+    ('statement', 1, 'p_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 925),
+    ('statement', 1, 'p_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 926),
+    ('statement', 1, 'p_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 927),
+    ('labeled_statement', 3, 'p_labeled_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 931),
+    ('labeled_statement', 4, 'p_labeled_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 932),
+    ('labeled_statement', 3, 'p_labeled_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 933),
+    ('compound_statement', 2, 'p_compound_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 937),
+    ('compound_statement', 3, 'p_compound_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 938),
+    ('compound_statement', 3, 'p_compound_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 939),
+    ('compound_statement', 4, 'p_compound_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 940),
+    ('compound_statement', 3, 'p_compound_statement_error', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 944),
+    ('declaration_list', 1, 'p_declaration_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 949),
+    ('declaration_list', 2, 'p_declaration_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 950),
+    ('statement_list', 1, 'p_statement_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 954),
+    ('statement_list', 2, 'p_statement_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 955),
+    ('expression_statement', 1, 'p_expression_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 959),
+    ('expression_statement', 2, 'p_expression_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 960),
+    ('expression_statement', 2, 'p_expression_statement_error', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 963),
+    ('selection_statement', 5, 'p_selection_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 968),
+    ('selection_statement', 7, 'p_selection_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 969),
+    ('selection_statement', 5, 'p_selection_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 970),
+    ('iteration_statement', 5, 'p_iteration_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 974),
+    ('iteration_statement', 7, 'p_iteration_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 975),
+    ('iteration_statement', 6, 'p_iteration_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 976),
+    ('iteration_statement', 7, 'p_iteration_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 977),
+    ('jump_statement', 3, 'p_jump_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 981),
+    ('jump_statement', 2, 'p_jump_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 982),
+    ('jump_statement', 2, 'p_jump_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 983),
+    ('jump_statement', 2, 'p_jump_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 984),
+    ('jump_statement', 3, 'p_jump_statement', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 985),
+    ('external_declaration', 1, 'p_external_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 989),
+    ('external_declaration', 1, 'p_external_declaration', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 990),
+    ('function_definition', 4, 'p_function_definition', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 996),
+    ('function_definition', 3, 'p_function_definition', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 997),
+    ('function_definition', 3, 'p_function_definition', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 998),
+    ('function_definition', 2, 'p_function_definition', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 999),
+    ('define', 3, 'p_define', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1003),
+    ('define', 4, 'p_define', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1004),
+    ('define', 4, 'p_define', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1005),
+    ('define', 5, 'p_define', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1006),
+    ('define', 6, 'p_define', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1007),
+    ('define', 6, 'p_define', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1008),
+    ('define', 7, 'p_define', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1009),
+    ('define', 3, 'p_define_error', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1042),
+    ('macro_parameter_list', 1, 'p_macro_parameter_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1071),
+    ('macro_parameter_list', 3, 'p_macro_parameter_list', '/Users/tim/Desktop/ctypesgen/ctypesgencore/parser/cgrammar.py', 1072),
 ]

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/pplexer.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/pplexer.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/pplexer.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -10,7 +10,14 @@
 
 __docformat__ = 'restructuredtext'
 
-import os, re, shlex, sys, tokenize, lex, yacc, traceback
+import os
+import re
+import shlex
+import sys
+import tokenize
+import lex
+import yacc
+import traceback
 import ctypes
 from lex import TOKEN
 
@@ -21,15 +28,15 @@
     'PTR_OP', 'INC_OP', 'DEC_OP', 'LEFT_OP', 'RIGHT_OP', 'LE_OP', 'GE_OP',
     'EQ_OP', 'NE_OP', 'AND_OP', 'OR_OP', 'MUL_ASSIGN', 'DIV_ASSIGN',
     'MOD_ASSIGN', 'ADD_ASSIGN', 'SUB_ASSIGN', 'LEFT_ASSIGN', 'RIGHT_ASSIGN',
-    'AND_ASSIGN', 'XOR_ASSIGN', 'OR_ASSIGN',  'PERIOD', 'ELLIPSIS',
+    'AND_ASSIGN', 'XOR_ASSIGN', 'OR_ASSIGN', 'PERIOD', 'ELLIPSIS',
 
     'LPAREN', 'NEWLINE',
-    
+
     'PP_DEFINE', 'PP_DEFINE_NAME', 'PP_DEFINE_MACRO_NAME', 'PP_MACRO_PARAM',
     'PP_STRINGIFY', 'PP_IDENTIFIER_PASTE', 'PP_END_DEFINE'
 )
 
-states = [('DEFINE',"exclusive")]
+states = [('DEFINE', "exclusive")]
 
 subs = {
     'D': '[0-9]',
@@ -41,8 +48,12 @@
 }
 # Helper: substitute {foo} with subs[foo] in string (makes regexes more lexy)
 sub_pattern = re.compile('{([^}]*)}')
+
+
 def sub_repl_match(m):
     return subs[m.groups()[0]]
+
+
 def sub(s):
     return sub_pattern.sub(sub_repl_match, s)
 
@@ -53,7 +64,9 @@
 # Numbers represented as int and float types.
 # For all other tokens, type is just str representation.
 
+
 class StringLiteral(str):
+
     def __new__(cls, value):
         assert value[0] == '"' and value[-1] == '"'
         # Unescaping probably not perfect but close enough.
@@ -125,6 +138,7 @@
     r'?': (r'\?', '?')
 }
 
+
 def punctuator_regex(punctuators):
     punctuator_regexes = [v[0] for v in punctuators.values()]
     punctuator_regexes.sort(lambda a, b: -cmp(len(a), len(b)))
@@ -133,45 +147,51 @@
 # Process line-number directives from the preprocessor
 # See http://docs.freebsd.org/info/cpp/cpp.info.Output.html
 DIRECTIVE = r'\#\s+(\d+)\s+"([^"]+)"[ \d]*\n'
+
+
 @TOKEN(DIRECTIVE)
 def t_ANY_directive(t):
     t.lexer.filename = t.groups[2]
     t.lexer.lineno = int(t.groups[1])
     return None
 
+
 @TOKEN(punctuator_regex(punctuators))
 def t_ANY_punctuator(t):
     t.type = punctuators[t.value][1]
     return t
 
 IDENTIFIER = sub('{L}({L}|{D})*')
+
+
 @TOKEN(IDENTIFIER)
 def t_INITIAL_identifier(t):
     t.type = 'IDENTIFIER'
     return t
 
+
 @TOKEN(IDENTIFIER)
 def t_DEFINE_identifier(t):
     if t.lexer.next_is_define_name:
         # This identifier is the name of a macro
         # We need to look ahead and see if this macro takes parameters or not.
         if t.lexpos + len(t.value) < t.lexer.lexlen and \
-            t.lexer.lexdata[t.lexpos + len(t.value)] == '(':
-            
+                t.lexer.lexdata[t.lexpos + len(t.value)] == '(':
+
             t.type = 'PP_DEFINE_MACRO_NAME'
-            
+
             # Look ahead and read macro parameter list
             lexdata = t.lexer.lexdata
             pos = t.lexpos + len(t.value) + 1
             while lexdata[pos] not in '\n)':
-                pos+=1
-            params = lexdata[t.lexpos+len(t.value)+1 : pos]
+                pos += 1
+            params = lexdata[t.lexpos + len(t.value) + 1: pos]
             paramlist = [x.strip() for x in params.split(",") if x.strip()]
             t.lexer.macro_params = paramlist
-                    
+
         else:
             t.type = 'PP_DEFINE_NAME'
-        
+
         t.lexer.next_is_define_name = False
     elif t.value in t.lexer.macro_params:
         t.type = 'PP_MACRO_PARAM'
@@ -179,19 +199,21 @@
         t.type = 'IDENTIFIER'
     return t
 
-FLOAT_LITERAL = sub(r"(?P<p1>{D}+)?(?P<dp>[.]?)(?P<p2>(?(p1){D}*|{D}+))" \
+FLOAT_LITERAL = sub(r"(?P<p1>{D}+)?(?P<dp>[.]?)(?P<p2>(?(p1){D}*|{D}+))"
                     r"(?P<exp>(?:[Ee][+-]?{D}+)?)(?P<suf>{FS}?)(?!\w)")
+
+
 @TOKEN(FLOAT_LITERAL)
 def t_ANY_float(t):
     t.type = 'PP_NUMBER'
     m = t.lexer.lexmatch
-    
+
     p1 = m.group("p1")
     dp = m.group("dp")
     p2 = m.group("p2")
     exp = m.group("exp")
     suf = m.group("suf")
-    
+
     if dp or exp or (suf and suf in ("Ff")):
         s = m.group(0)
         if suf:
@@ -203,58 +225,67 @@
         t.value = "l" + p1
     else:
         t.value = "i" + p1
-        
+
     return t
 
 INT_LITERAL = sub(r"(?P<p1>(?:0x{H}+)|(?:{D}+))(?P<suf>{IS})")
+
+
 @TOKEN(INT_LITERAL)
 def t_ANY_int(t):
     t.type = 'PP_NUMBER'
     m = t.lexer.lexmatch
-    
+
     if "L" in m.group(3) or "l" in m.group(2):
         prefix = "l"
     else:
         prefix = "i"
-    
+
     g1 = m.group(2)
     if g1.startswith("0x"):
         # Convert base from hexadecimal
-        g1 = str(long(g1[2:],16))
-    elif g1[0]=="0":
+        g1 = str(long(g1[2:], 16))
+    elif g1[0] == "0":
         # Convert base from octal
-        g1 = str(long(g1,8))
-    
+        g1 = str(long(g1, 8))
+
     t.value = prefix + g1
-        
+
     return t
 
 CHARACTER_CONSTANT = sub(r"L?'(\\.|[^\\'])+'")
+
+
 @TOKEN(CHARACTER_CONSTANT)
 def t_ANY_character_constant(t):
     t.type = 'CHARACTER_CONSTANT'
     return t
 
 STRING_LITERAL = sub(r'L?"(\\.|[^\\"])*"')
+
+
 @TOKEN(STRING_LITERAL)
 def t_ANY_string_literal(t):
     t.type = 'STRING_LITERAL'
     t.value = StringLiteral(t.value)
     return t
 
+
 @TOKEN(r'\(')
 def t_ANY_lparen(t):
-    if t.lexpos == 0 or t.lexer.lexdata[t.lexpos-1] not in (' \t\f\v\n'):
+    if t.lexpos == 0 or t.lexer.lexdata[t.lexpos - 1] not in (' \t\f\v\n'):
         t.type = 'LPAREN'
     else:
         t.type = '('
     return t
 
+
 @TOKEN(r'\n')
 def t_INITIAL_newline(t):
     t.lexer.lineno += 1
     return None
 
+
 @TOKEN(r'\#define')
 def t_INITIAL_pp_define(t):
     t.type = 'PP_DEFINE'
@@ -263,33 +294,37 @@
     t.lexer.macro_params = set()
     return t
 
+
 @TOKEN(r'\n')
 def t_DEFINE_newline(t):
     t.type = 'PP_END_DEFINE'
     t.lexer.begin("INITIAL")
     del t.lexer.macro_params
-    
+
     # Damage control in case the token immediately after the #define failed
     # to handle this
     t.lexer.next_is_define_name = False
     return t
 
+
 @TOKEN(r'(\#\#)|(\#)')
 def t_DEFINE_pp_param_op(t):
-    if t.value=='#':
+    if t.value == '#':
         t.type = 'PP_STRINGIFY'
     else:
         t.type = 'PP_IDENTIFIER_PASTE'
     return t
 
+
 def t_INITIAL_error(t):
     t.type = 'OTHER'
     return t
 
+
 def t_DEFINE_error(t):
     t.type = 'OTHER'
     t.value = t.value[0]
-    t.lexer.lexpos+=1 # Skip it if it's an error in a #define
+    t.lexer.lexpos += 1  # Skip it if it's an error in a #define
     return t
 
 t_ANY_ignore = ' \t\v\f\r'

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/preprocessor.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/preprocessor.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/preprocessor.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -10,7 +10,15 @@
 
 __docformat__ = 'restructuredtext'
 
-import os, re, shlex, sys, tokenize, lex, yacc, traceback, subprocess
+import os
+import re
+import shlex
+import sys
+import tokenize
+import lex
+import yacc
+import traceback
+import subprocess
 import ctypes
 from lex import TOKEN
 import pplexer
@@ -19,7 +27,9 @@
 # Lexers
 # --------------------------------------------------------------------------
 
+
 class PreprocessorLexer(lex.Lexer):
+
     def __init__(self):
         lex.Lexer.__init__(self)
         self.filename = '<input>'
@@ -27,7 +37,7 @@
 
     def input(self, data, filename=None):
         if filename:
-            self.filename = filename 
+            self.filename = filename
         self.lasttoken = None
         self.input_stack = []
 
@@ -61,7 +71,9 @@
 
         return result
 
+
 class TokenListLexer(object):
+
     def __init__(self, tokens):
         self.tokens = tokens
         self.pos = 0
@@ -74,6 +86,7 @@
         else:
             return None
 
+
 def symbol_to_token(sym):
     if isinstance(sym, yacc.YaccSymbol):
         return sym.value
@@ -82,6 +95,7 @@
     else:
         assert False, 'Not a symbol: %r' % sym
 
+
 def create_token(type, value, production=None):
     '''Create a token of type and value, at the position where 'production'
     was reduced.  Don`t specify production if the token is built-in'''
@@ -101,8 +115,10 @@
 # Grammars
 # --------------------------------------------------------------------------
 
+
 class PreprocessorParser(object):
-    def __init__(self,options,cparser):
+
+    def __init__(self, options, cparser):
         self.defines = ["inline=", "__inline__=", "__extension__=",
                         "_Bool=uint8_t", "__const=const", "__asm__(x)=",
                         "__asm(x)=", "CTYPESGEN=1"]
@@ -121,45 +137,45 @@
                              lextab='lextab',
                              outputdir=os.path.dirname(__file__),
                              module=pplexer)
-        
+
         self.options = options
-        self.cparser = cparser # An instance of CParser
+        self.cparser = cparser  # An instance of CParser
 
     def parse(self, filename):
         """Parse a file and save its output"""
-        
+
         cmd = self.options.cpp
         if sys.platform == 'darwin':
             cmd += " -U __BLOCKS__"
         cmd += " -U __GNUC__"
         cmd += " -dD"
         for path in self.options.include_search_paths:
-            cmd += " -I%s" % path 
+            cmd += " -I%s" % path
         for define in self.defines:
             cmd += ' "-D%s"' % define
-        cmd += " " + filename.replace('\\','/')
+        cmd += " " + filename.replace('\\', '/')
 
         self.cparser.handle_status(cmd)
-        
+
         if sys.platform == 'win32':
             cmd = ['sh.exe', '-c', cmd]
 
         pp = subprocess.Popen(cmd,
-                              shell = True,
-                              stdout = subprocess.PIPE,
-                              stderr = subprocess.PIPE)
+                              shell=True,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE)
         ppout, pperr = pp.communicate()
-        
+
         for line in pperr.split("\n"):
             if line:
                 self.cparser.handle_pp_error(line)
-        
+
         # We separate lines that are #defines and lines that are source code
         # We put all the source lines first, then all the #define lines.
-        
-        source_lines= []
+
+        source_lines = []
         define_lines = []
-        
+
         for line in ppout.split("\n"):
             line = line.rstrip('\r')
             line = line + "\n"
@@ -167,35 +183,35 @@
                 # Line number information has to go with both groups
                 source_lines.append(line)
                 define_lines.append(line)
-            
+
             elif line.startswith("#define"):
                 source_lines.append("\n")
                 define_lines.append(line)
-            
+
             elif line.startswith("#"):
                 # It's a directive, but not a #define. Remove it
                 source_lines.append("\n")
                 define_lines.append("\n")
-            
+
             else:
                 source_lines.append(line)
                 define_lines.append("\n")
-        
+
         text = "".join(source_lines + define_lines)
-        
+
         if self.options.save_preprocessed_headers:
-            self.cparser.handle_status("Saving preprocessed headers to %s." % \
-                self.options.save_preprocessed_headers)
+            self.cparser.handle_status("Saving preprocessed headers to %s." %
+                                       self.options.save_preprocessed_headers)
             try:
                 f = file(self.options.save_preprocessed_headers, "w")
                 f.write(text)
                 f.close()
             except IOError:
                 self.cparser.handle_error("Couldn't save headers.")
-        
+
         self.lexer.input(text)
         self.output = []
-        
+
         while True:
             token = self.lexer.token()
             if token is not None:

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/parser/yacc.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/parser/yacc.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/parser/yacc.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -11,16 +11,16 @@
 # modify it under the terms of the GNU Lesser General Public
 # License as published by the Free Software Foundation; either
 # version 2.1 of the License, or (at your option) any later version.
-# 
+#
 # This library is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 # Lesser General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU Lesser General Public
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-# 
+#
 # See the file COPYING for a complete copy of the LGPL.
 #
 #
@@ -60,16 +60,20 @@
 # Change these to modify the default behavior of yacc (if you wish)
 #-----------------------------------------------------------------------------
 
-yaccdebug   = 1                # Debugging mode.  If set, yacc generates a
-                               # a 'parser.out' file in the current directory
+yaccdebug = 1                # Debugging mode.  If set, yacc generates a
+# a 'parser.out' file in the current directory
 
-debug_file  = 'parser.out'     # Default name of the debugging file
-tab_module  = 'parsetab'       # Default name of the table module
-default_lr  = 'LALR'           # Default LR table generation method
+debug_file = 'parser.out'     # Default name of the debugging file
+tab_module = 'parsetab'       # Default name of the table module
+default_lr = 'LALR'           # Default LR table generation method
 
 error_count = 3                # Number of symbols that must be shifted to leave recovery mode
 
-import re, types, sys, cStringIO, os.path
+import re
+import types
+import sys
+import cStringIO
+import os.path
 
 # <tm> 1 July 2008
 try:
@@ -77,6 +81,7 @@
 except ImportError:
     # Preserve backwards compatibility with older versions of Python
     import md5
+
     class Dummy:
         pass
     hashlib = Dummy()
@@ -84,8 +89,11 @@
     del Dummy, md5
 
 # Exception raised for yacc-related errors
-class YaccError(Exception):   pass
 
+
+class YaccError(Exception):
+    pass
+
 #-----------------------------------------------------------------------------
 #                        ===  LR Parsing Engine ===
 #
@@ -103,11 +111,14 @@
 #        .lexpos     = Starting lex position
 #        .endlexpos  = Ending lex position (optional, set automatically)
 
+
 class YaccSymbol:
     filename = ''  # <ah>
-    def __str__(self):    return self.type
-    def __repr__(self):   return str(self)
 
+    def __str__(self): return self.type
+
+    def __repr__(self): return str(self)
+
 # This class is a wrapper around the objects actually passed to each
 # grammar rule.   Index lookup and assignment actually assign the
 # .value attribute of the underlying YaccSymbol object.
@@ -117,64 +128,71 @@
 # for a symbol.  The lexspan() method returns a tuple (lexpos,endlexpos)
 # representing the range of positional information for a symbol.
 
+
 class YaccProduction:
-    def __init__(self,s,stack=None):
+
+    def __init__(self, s, stack=None):
         self.slice = s
         self.pbstack = []
         self.stack = stack
 
-    def __getitem__(self,n):
-        if type(n) == types.IntType:
-             if n >= 0: return self.slice[n].value
-             else: return self.stack[n].value
+    def __getitem__(self, n):
+        if isinstance(n, types.IntType):
+            if n >= 0:
+                return self.slice[n].value
+            else:
+                return self.stack[n].value
         else:
-             return [s.value for s in self.slice[n.start:n.stop:n.step]]
+            return [s.value for s in self.slice[n.start:n.stop:n.step]]
 
-    def __setitem__(self,n,v):
+    def __setitem__(self, n, v):
         self.slice[n].value = v
 
     def __len__(self):
         return len(self.slice)
-    
-    def lineno(self,n):
-        return getattr(self.slice[n],"lineno",0)
 
-    def linespan(self,n):
-        startline = getattr(self.slice[n],"lineno",0)
-        endline = getattr(self.slice[n],"endlineno",startline)
-        return startline,endline
+    def lineno(self, n):
+        return getattr(self.slice[n], "lineno", 0)
 
-    def lexpos(self,n):
-        return getattr(self.slice[n],"lexpos",0)
+    def linespan(self, n):
+        startline = getattr(self.slice[n], "lineno", 0)
+        endline = getattr(self.slice[n], "endlineno", startline)
+        return startline, endline
 
-    def lexspan(self,n):
-        startpos = getattr(self.slice[n],"lexpos",0)
-        endpos = getattr(self.slice[n],"endlexpos",startpos)
-        return startpos,endpos
+    def lexpos(self, n):
+        return getattr(self.slice[n], "lexpos", 0)
 
-    def pushback(self,n):
+    def lexspan(self, n):
+        startpos = getattr(self.slice[n], "lexpos", 0)
+        endpos = getattr(self.slice[n], "endlexpos", startpos)
+        return startpos, endpos
+
+    def pushback(self, n):
         if n <= 0:
             raise ValueError, "Expected a positive value"
-        if n > (len(self.slice)-1):
-            raise ValueError, "Can't push %d tokens. Only %d are available." % (n,len(self.slice)-1)
-        for i in range(0,n):
-            self.pbstack.append(self.slice[-i-1])
+        if n > (len(self.slice) - 1):
+            raise ValueError, "Can't push %d tokens. Only %d are available." % (n, len(
+                self.slice) - 1)
+        for i in range(0, n):
+            self.pbstack.append(self.slice[-i - 1])
 
 # The LR Parsing engine.   This is defined as a class so that multiple parsers
 # can exist in the same process.  A user never instantiates this directly.
 # Instead, the global yacc() function should be used to create a suitable Parser
-# object. 
+# object.
 
+
 class Parser:
     # <ah> Remove magic (use ParserPrototype)
+
     def __init__(self):
         # Reset internal state
         self.productions = None          # List of productions
-        self.errorfunc   = None          # Error handling function
-        self.action      = { }           # LR Action table
-        self.goto        = { }           # LR goto table
-        self.require     = { }           # Attribute require table
-        self.method      = "Unknown LR"  # Table construction method used
+        self.errorfunc = None          # Error handling function
+        self.action = {}           # LR Action table
+        self.goto = {}           # LR goto table
+        self.require = {}           # Attribute require table
+        self.method = "Unknown LR"  # Table construction method used
 
         # <ah> 25 Jan 2007
         self.statestackstack = []
@@ -188,7 +206,7 @@
         del self.symstack[:]
         sym = YaccSymbol()
         sym.type = '$end'
-        sym.parser = self # <tm> 25 June 2008
+        sym.parser = self  # <tm> 25 June 2008
         self.symstack.append(sym)
         self.statestack.append(0)
 
@@ -204,14 +222,14 @@
         # <ah> 25 Jan 2007
         self.statestack[:] = self.statestackstack.pop()
         self.symstack[:] = self.symstackstack.pop()
-        
-    def parse(self,input=None,lexer=None,debug=0):
+
+    def parse(self, input=None, lexer=None, debug=0):
         lookahead = None                 # Current lookahead symbol
-        lookaheadstack = [ ]             # Stack of lookahead symbols
+        lookaheadstack = []             # Stack of lookahead symbols
         actions = self.action            # Local reference to action table
-        goto    = self.goto              # Local reference to goto table
-        prod    = self.productions       # Local reference to production list
-        pslice  = YaccProduction(None)   # Production object passed to grammar rules
+        goto = self.goto              # Local reference to goto table
+        prod = self.productions       # Local reference to production list
+        pslice = YaccProduction(None)   # Production object passed to grammar rules
         pslice.parser = self             # Parser object
         self.errorcount = 0              # Used during error recovery
 
@@ -221,7 +239,7 @@
             lexer = lex.lexer
 
         pslice.lexer = lexer
-        
+
         # If input was supplied, pass to lexer
         if input:
             lexer.input(input)
@@ -229,22 +247,22 @@
         # Tokenize function
         get_token = lexer.token
 
-        statestack = [ ]                # Stack of parsing states
+        statestack = []                # Stack of parsing states
         self.statestack = statestack
-        symstack   = [ ]                # Stack of grammar symbols
+        symstack = []                # Stack of grammar symbols
         self.symstack = symstack
 
         pslice.stack = symstack         # Put in the production
-        errtoken   = None               # Err token
+        errtoken = None               # Err token
 
         # The start state is assumed to be (0,$end)
         statestack.append(0)
         sym = YaccSymbol()
         sym.type = '$end'
-        sym.parser = self # <tm> 25 June 2008
+        sym.parser = self  # <tm> 25 June 2008
         symstack.append(sym)
-        
-        while 1:
+
+        while True:
             # Get the next symbol on the input.  If a lookahead symbol
             # is already set, we just use that. Otherwise, we'll pull
             # the next token off of the lookaheadstack or from the lexer
@@ -258,14 +276,15 @@
                 if not lookahead:
                     lookahead = YaccSymbol()
                     lookahead.type = '$end'
-                    lookahead.parser = self # <tm> 25 June 2008
+                    lookahead.parser = self  # <tm> 25 June 2008
             if debug:
-                errorlead = ("%s . %s" % (" ".join([xx.type for xx in symstack][1:]), str(lookahead))).lstrip()
+                errorlead = ("%s . %s" %
+                             (" ".join([xx.type for xx in symstack][1:]), str(lookahead))).lstrip()
 
             # Check the action table
             s = statestack[-1]
             ltype = lookahead.type
-            t = actions.get((s,ltype),None)
+            t = actions.get((s, ltype), None)
 
             if debug > 1:
                 print 'action', t
@@ -285,14 +304,14 @@
                     # Decrease error count on successful shift
                     if self.errorcount > 0:
                         self.errorcount -= 1
-                        
+
                     continue
-                
+
                 if t < 0:
                     # reduce a symbol on the stack, emit a production
                     p = prod[-t]
                     pname = p.name
-                    plen  = p.len
+                    plen = p.len
 
                     # Get production function
                     sym = YaccSymbol()
@@ -302,21 +321,21 @@
                         sys.stderr.write("%-60s reduce %d\n" % (errorlead, -t))
 
                     if plen:
-                        targ = symstack[-plen-1:]
+                        targ = symstack[-plen - 1:]
                         targ[0] = sym
                         try:
                             sym.lineno = targ[1].lineno
                             sym.filename = targ[1].filename
-                            sym.endlineno = getattr(targ[-1],"endlineno",targ[-1].lineno)
+                            sym.endlineno = getattr(targ[-1], "endlineno", targ[-1].lineno)
                             sym.lexpos = targ[1].lexpos
-                            sym.endlexpos = getattr(targ[-1],"endlexpos",targ[-1].lexpos)
+                            sym.endlexpos = getattr(targ[-1], "endlexpos", targ[-1].lexpos)
                         except AttributeError:
                             sym.lineno = 0
                         del symstack[-plen:]
                         del statestack[-plen:]
                     else:
                         sym.lineno = 0
-                        targ = [ sym ]
+                        targ = [sym]
                     pslice.slice = targ
                     pslice.pbstack = []
                     # Call the grammar rule with our special slice object
@@ -330,15 +349,15 @@
                         lookahead = None
 
                     symstack.append(sym)
-                    statestack.append(goto[statestack[-1],pname])
+                    statestack.append(goto[statestack[-1], pname])
                     continue
 
                 if t == 0:
                     n = symstack[-1]
-                    return getattr(n,"value",None)
+                    return getattr(n, "value", None)
                     sys.stderr.write(errorlead, "\n")
 
-            if t == None:
+            if t is None:
                 if debug:
                     sys.stderr.write(errorlead + "\n")
                 # We have some kind of parsing error here.  To handle
@@ -354,19 +373,19 @@
                 if not self.errorcount:
                     self.errorcount = error_count
                     errtoken = lookahead
-                    
+
                     # <tm> 24 June 2008
                     # Let EOF error token get through so errorfunc would have
                     # access to the parser.
-                    
+
                     if self.errorfunc:
-                        global errok,token,restart
+                        global errok, token, restart
                         errok = self.errok        # Set some special functions available in error recovery
                         token = get_token
                         restart = self.restart
                         tok = self.errorfunc(errtoken)
                         del errok, token, restart   # Delete special functions
-                        
+
                         if not self.errorcount:
                             # User must have done some kind of panic
                             # mode recovery on their own.  The
@@ -376,10 +395,14 @@
                             continue
                     else:
                         if errtoken:
-                            if hasattr(errtoken,"lineno"): lineno = lookahead.lineno
-                            else: lineno = 0
+                            if hasattr(errtoken, "lineno"):
+                                lineno = lookahead.lineno
+                            else:
+                                lineno = 0
                             if lineno:
-                                sys.stderr.write("yacc: Syntax error at line %d, token=%s\n" % (lineno, errtoken.type))
+                                sys.stderr.write(
+                                    "yacc: Syntax error at line %d, token=%s\n" %
+                                    (lineno, errtoken.type))
                             else:
                                 sys.stderr.write("yacc: Syntax error, token=%s" % errtoken.type)
                         else:
@@ -388,7 +411,7 @@
 
                 else:
                     self.errorcount = error_count
-                
+
                 # case 1:  the statestack only has 1 entry on it.  If we're in this state, the
                 # entire parse has been rolled back and we're completely hosed.   The token is
                 # discarded and we just keep going.
@@ -406,7 +429,7 @@
                 # Start nuking entries on the stack
                 if lookahead.type == '$end':
                     # Whoa. We're really hosed here. Bail out
-                    return 
+                    return
 
                 if lookahead.type != 'error':
                     sym = symstack[-1]
@@ -417,7 +440,7 @@
                         continue
                     t = YaccSymbol()
                     t.type = 'error'
-                    if hasattr(lookahead,"lineno"):
+                    if hasattr(lookahead, "lineno"):
                         t.lineno = lookahead.lineno
                     t.value = lookahead
                     lookaheadstack.append(lookahead)
@@ -441,7 +464,7 @@
 # is completely self contained--meaning that it is safe to repeatedly
 # call yacc() with different grammars in the same application.
 # -----------------------------------------------------------------------------
-        
+
 # -----------------------------------------------------------------------------
 # validate_file()
 #
@@ -453,9 +476,11 @@
 # to try and detect duplicates.
 # -----------------------------------------------------------------------------
 
+
 def validate_file(filename):
-    base,ext = os.path.splitext(filename)
-    if ext != '.py': return 1          # No idea. Assume it's okay.
+    base, ext = os.path.splitext(filename)
+    if ext != '.py':
+        return 1          # No idea. Assume it's okay.
 
     try:
         f = open(filename)
@@ -466,7 +491,7 @@
 
     # Match def p_funcname(
     fre = re.compile(r'\s*def\s+(p_[a-zA-Z_0-9]*)\(')
-    counthash = { }
+    counthash = {}
     linen = 1
     noerror = 1
     for l in lines:
@@ -477,25 +502,34 @@
             if not prev:
                 counthash[name] = linen
             else:
-                sys.stderr.write("%s:%d: Function %s redefined. Previously defined on line %d\n" % (filename,linen,name,prev))
+                sys.stderr.write(
+                    "%s:%d: Function %s redefined. Previously defined on line %d\n" %
+                    (filename, linen, name, prev))
                 noerror = 0
         linen += 1
     return noerror
 
-# This function looks for functions that might be grammar rules, but which don't have the proper p_suffix.
+# This function looks for functions that might be grammar rules, but which
+# don't have the proper p_suffix.
+
+
 def validate_dict(d):
-    for n,v in d.items(): 
-        if n[0:2] == 'p_' and type(v) in (types.FunctionType, types.MethodType): continue
-        if n[0:2] == 't_': continue
+    for n, v in d.items():
+        if n[0:2] == 'p_' and type(v) in (types.FunctionType, types.MethodType):
+            continue
+        if n[0:2] == 't_':
+            continue
 
         if n[0:2] == 'p_':
             sys.stderr.write("yacc: Warning. '%s' not defined as a function\n" % n)
-        if 1 and isinstance(v,types.FunctionType) and v.func_code.co_argcount == 1:
+        if 1 and isinstance(v, types.FunctionType) and v.func_code.co_argcount == 1:
             try:
                 doc = v.__doc__.split(" ")
                 if doc[1] == ':':
-                    sys.stderr.write("%s:%d: Warning. Possible grammar rule '%s' defined without p_ prefix.\n" % (v.func_code.co_filename, v.func_code.co_firstlineno,n))
-            except StandardError:
+                    sys.stderr.write(
+                        "%s:%d: Warning. Possible grammar rule '%s' defined without p_ prefix.\n" %
+                        (v.func_code.co_filename, v.func_code.co_firstlineno, n))
+            except Exception:
                 pass
 
 # -----------------------------------------------------------------------------
@@ -506,50 +540,52 @@
 # -----------------------------------------------------------------------------
 
 # Initialize all of the global variables used during grammar construction
+
+
 def initialize_vars():
-    global Productions, Prodnames, Prodmap, Terminals 
+    global Productions, Prodnames, Prodmap, Terminals
     global Nonterminals, First, Follow, Precedence, LRitems
     global Errorfunc, Signature, Requires
 
-    Productions  = [None]  # A list of all of the productions.  The first
-                           # entry is always reserved for the purpose of
-                           # building an augmented grammar
-                        
-    Prodnames    = { }     # A dictionary mapping the names of nonterminals to a list of all
-                           # productions of that nonterminal.
-                        
-    Prodmap      = { }     # A dictionary that is only used to detect duplicate
-                           # productions.
+    Productions = [None]  # A list of all of the productions.  The first
+    # entry is always reserved for the purpose of
+    # building an augmented grammar
 
-    Terminals    = { }     # A dictionary mapping the names of terminal symbols to a
-                           # list of the rules where they are used.
+    Prodnames = {}     # A dictionary mapping the names of nonterminals to a list of all
+    # productions of that nonterminal.
 
-    Nonterminals = { }     # A dictionary mapping names of nonterminals to a list
-                           # of rule numbers where they are used.
+    Prodmap = {}     # A dictionary that is only used to detect duplicate
+    # productions.
 
-    First        = { }     # A dictionary of precomputed FIRST(x) symbols
-    
-    Follow       = { }     # A dictionary of precomputed FOLLOW(x) symbols
+    Terminals = {}     # A dictionary mapping the names of terminal symbols to a
+    # list of the rules where they are used.
 
-    Precedence   = { }     # Precedence rules for each terminal. Contains tuples of the
-                           # form ('right',level) or ('nonassoc', level) or ('left',level)
+    Nonterminals = {}     # A dictionary mapping names of nonterminals to a list
+    # of rule numbers where they are used.
 
-    LRitems      = [ ]     # A list of all LR items for the grammar.  These are the
-                           # productions with the "dot" like E -> E . PLUS E
+    First = {}     # A dictionary of precomputed FIRST(x) symbols
 
-    Errorfunc    = None    # User defined error handler
-    
+    Follow = {}     # A dictionary of precomputed FOLLOW(x) symbols
+
+    Precedence = {}     # Precedence rules for each terminal. Contains tuples of the
+    # form ('right',level) or ('nonassoc', level) or ('left',level)
+
+    LRitems = []     # A list of all LR items for the grammar.  These are the
+    # productions with the "dot" like E -> E . PLUS E
+
+    Errorfunc = None    # User defined error handler
+
     # <tm> 1 July 2008 changed to use hashlib
-    Signature    = hashlib.md5()   # Digital signature of the grammar rules, precedence
-                                   # and other information.  Used to determined when a
-                                   # parsing table needs to be regenerated.
+    Signature = hashlib.md5()   # Digital signature of the grammar rules, precedence
+    # and other information.  Used to determined when a
+    # parsing table needs to be regenerated.
 
-    Requires     = { }     # Requires list
+    Requires = {}     # Requires list
 
     # File objects used when creating the parser.out debugging file
     global _vf, _vfc
-    _vf           = cStringIO.StringIO()
-    _vfc          = cStringIO.StringIO()
+    _vf = cStringIO.StringIO()
+    _vfc = cStringIO.StringIO()
 
 # -----------------------------------------------------------------------------
 # class Production:
@@ -569,27 +605,29 @@
 #       func     - Action function
 #       prec     - Precedence level
 #       lr_next  - Next LR item. Example, if we are ' E -> E . PLUS E'
-#                  then lr_next refers to 'E -> E PLUS . E'   
+#                  then lr_next refers to 'E -> E PLUS . E'
 #       lr_index - LR item index (location of the ".") in the prod list.
 #       lookaheads - LALR lookahead symbols for this item
 #       len      - Length of the production (number of symbols on right hand side)
 # -----------------------------------------------------------------------------
 
+
 class Production:
-    def __init__(self,**kw):
-        for k,v in kw.items():
-            setattr(self,k,v)
+
+    def __init__(self, **kw):
+        for k, v in kw.items():
+            setattr(self, k, v)
         self.lr_index = -1
         self.lr0_added = 0    # Flag indicating whether or not added to LR0 closure
         self.lr1_added = 0    # Flag indicating whether or not added to LR1
-        self.usyms = [ ]
-        self.lookaheads = { }
-        self.lk_added = { }
-        self.setnumbers = [ ]
-        
+        self.usyms = []
+        self.lookaheads = {}
+        self.lk_added = {}
+        self.setnumbers = []
+
     def __str__(self):
         if self.prod:
-            s = "%s -> %s" % (self.name," ".join(self.prod))
+            s = "%s -> %s" % (self.name, " ".join(self.prod))
         else:
             s = "%s -> <empty>" % self.name
         return s
@@ -598,32 +636,34 @@
         return str(self)
 
     # Compute lr_items from the production
-    def lr_item(self,n):
-        if n > len(self.prod): return None
+    def lr_item(self, n):
+        if n > len(self.prod):
+            return None
         p = Production()
         p.name = self.name
         p.prod = list(self.prod)
         p.number = self.number
         p.lr_index = n
-        p.lookaheads = { }
+        p.lookaheads = {}
         p.setnumbers = self.setnumbers
-        p.prod.insert(n,".")
+        p.prod.insert(n, ".")
         p.prod = tuple(p.prod)
         p.len = len(p.prod)
         p.usyms = self.usyms
 
         # Precompute list of productions immediately following
         try:
-            p.lrafter = Prodnames[p.prod[n+1]]
-        except (IndexError,KeyError) as e:
+            p.lrafter = Prodnames[p.prod[n + 1]]
+        except (IndexError, KeyError) as e:
             p.lrafter = []
         try:
-            p.lrbefore = p.prod[n-1]
+            p.lrbefore = p.prod[n - 1]
         except IndexError:
             p.lrbefore = None
 
         return p
 
+
 class MiniProduction:
     pass
 
@@ -644,46 +684,53 @@
 #                     |  productionn
 #              name2 ::= production1
 #                     |  production2
-#                    ... 
+#                    ...
 # -----------------------------------------------------------------------------
 
-def add_production(f,file,line,prodname,syms):
-    
-    if Terminals.has_key(prodname):
-        sys.stderr.write("%s:%d: Illegal rule name '%s'. Already defined as a token.\n" % (file,line,prodname))
+
+def add_production(f, file, line, prodname, syms):
+
+    if prodname in Terminals:
+        sys.stderr.write(
+            "%s:%d: Illegal rule name '%s'. Already defined as a token.\n" %
+            (file, line, prodname))
         return -1
     if prodname == 'error':
-        sys.stderr.write("%s:%d: Illegal rule name '%s'. error is a reserved word.\n" % (file,line,prodname))
+        sys.stderr.write(
+            "%s:%d: Illegal rule name '%s'. error is a reserved word.\n" %
+            (file, line, prodname))
         return -1
-                
+
     if not _is_identifier.match(prodname):
-        sys.stderr.write("%s:%d: Illegal rule name '%s'\n" % (file,line,prodname))
+        sys.stderr.write("%s:%d: Illegal rule name '%s'\n" % (file, line, prodname))
         return -1
 
     for x in range(len(syms)):
         s = syms[x]
         if s[0] in "'\"":
-             try:
-                 c = eval(s)
-                 if (len(c) > 1):
-                      sys.stderr.write("%s:%d: Literal token %s in rule '%s' may only be a single character\n" % (file,line,s, prodname)) 
-                      return -1
-                 if not Terminals.has_key(c):
-                      Terminals[c] = []
-                 syms[x] = c
-                 continue
-             except SyntaxError:
-                 pass
+            try:
+                c = eval(s)
+                if (len(c) > 1):
+                    sys.stderr.write(
+                        "%s:%d: Literal token %s in rule '%s' may only be a single character\n" %
+                        (file, line, s, prodname))
+                    return -1
+                if c not in Terminals:
+                    Terminals[c] = []
+                syms[x] = c
+                continue
+            except SyntaxError:
+                pass
         if not _is_identifier.match(s) and s != '%prec':
-            sys.stderr.write("%s:%d: Illegal name '%s' in rule '%s'\n" % (file,line,s, prodname))
+            sys.stderr.write("%s:%d: Illegal name '%s' in rule '%s'\n" % (file, line, s, prodname))
             return -1
 
     # See if the rule is already in the rulemap
-    map = "%s -> %s" % (prodname,syms)
-    if Prodmap.has_key(map):
+    map = "%s -> %s" % (prodname, syms)
+    if map in Prodmap:
         m = Prodmap[map]
-        sys.stderr.write("%s:%d: Duplicate rule %s.\n" % (file,line, m))
-        sys.stderr.write("%s:%d: Previous definition at %s:%d\n" % (file,line, m.file, m.line))
+        sys.stderr.write("%s:%d: Duplicate rule %s.\n" % (file, line, m))
+        sys.stderr.write("%s:%d: Previous definition at %s:%d\n" % (file, line, m.file, m.line))
         return -1
 
     p = Production()
@@ -694,26 +741,29 @@
     p.func = f
     p.number = len(Productions)
 
-            
     Productions.append(p)
     Prodmap[map] = p
-    if not Nonterminals.has_key(prodname):
-        Nonterminals[prodname] = [ ]
-    
+    if prodname not in Nonterminals:
+        Nonterminals[prodname] = []
+
     # Add all terminals to Terminals
     i = 0
     while i < len(p.prod):
         t = p.prod[i]
         if t == '%prec':
             try:
-                precname = p.prod[i+1]
+                precname = p.prod[i + 1]
             except IndexError:
-                sys.stderr.write("%s:%d: Syntax error. Nothing follows %%prec.\n" % (p.file,p.line))
+                sys.stderr.write(
+                    "%s:%d: Syntax error. Nothing follows %%prec.\n" %
+                    (p.file, p.line))
                 return -1
 
-            prec = Precedence.get(precname,None)
+            prec = Precedence.get(precname, None)
             if not prec:
-                sys.stderr.write("%s:%d: Nothing known about the precedence of '%s'\n" % (p.file,p.line,precname))
+                sys.stderr.write(
+                    "%s:%d: Nothing known about the precedence of '%s'\n" %
+                    (p.file, p.line, precname))
                 return -1
             else:
                 p.prec = prec
@@ -721,58 +771,59 @@
             del p.prod[i]
             continue
 
-        if Terminals.has_key(t):
+        if t in Terminals:
             Terminals[t].append(p.number)
             # Is a terminal.  We'll assign a precedence to p based on this
-            if not hasattr(p,"prec"):
-                p.prec = Precedence.get(t,('right',0))
+            if not hasattr(p, "prec"):
+                p.prec = Precedence.get(t, ('right', 0))
         else:
-            if not Nonterminals.has_key(t):
-                Nonterminals[t] = [ ]
+            if t not in Nonterminals:
+                Nonterminals[t] = []
             Nonterminals[t].append(p.number)
         i += 1
 
-    if not hasattr(p,"prec"):
-        p.prec = ('right',0)
-        
+    if not hasattr(p, "prec"):
+        p.prec = ('right', 0)
+
     # Set final length of productions
-    p.len  = len(p.prod)
+    p.len = len(p.prod)
     p.prod = tuple(p.prod)
 
     # Calculate unique syms in the production
-    p.usyms = [ ]
+    p.usyms = []
     for s in p.prod:
         if s not in p.usyms:
             p.usyms.append(s)
-    
+
     # Add to the global productions list
     try:
         Prodnames[p.name].append(p)
     except KeyError:
-        Prodnames[p.name] = [ p ]
+        Prodnames[p.name] = [p]
     return 0
 
 # Given a raw rule function, this function rips out its doc string
 # and adds rules to the grammar
 
+
 def add_function(f):
     line = f.func_code.co_firstlineno
     file = f.func_code.co_filename
     error = 0
 
-    if isinstance(f,types.MethodType):
+    if isinstance(f, types.MethodType):
         reqdargs = 2
     else:
         reqdargs = 1
-        
+
     if f.func_code.co_argcount > reqdargs:
-        sys.stderr.write("%s:%d: Rule '%s' has too many arguments.\n" % (file,line,f.__name__))
+        sys.stderr.write("%s:%d: Rule '%s' has too many arguments.\n" % (file, line, f.__name__))
         return -1
 
     if f.func_code.co_argcount < reqdargs:
-        sys.stderr.write("%s:%d: Rule '%s' requires an argument.\n" % (file,line,f.__name__))
+        sys.stderr.write("%s:%d: Rule '%s' requires an argument.\n" % (file, line, f.__name__))
         return -1
-          
+
     if f.__doc__:
         # Split the doc string into lines
         pstrings = f.__doc__.splitlines()
@@ -781,18 +832,19 @@
         for ps in pstrings:
             dline += 1
             p = ps.split()
-            if not p: continue
+            if not p:
+                continue
             try:
                 if p[0] == '|':
                     # This is a continuation of a previous rule
                     if not lastp:
-                        sys.stderr.write("%s:%d: Misplaced '|'.\n" % (file,dline))
+                        sys.stderr.write("%s:%d: Misplaced '|'.\n" % (file, dline))
                         return -1
                     prodname = lastp
                     if len(p) > 1:
                         syms = p[1:]
                     else:
-                        syms = [ ]
+                        syms = []
                 else:
                     prodname = p[0]
                     lastp = prodname
@@ -800,21 +852,21 @@
                     if len(p) > 2:
                         syms = p[2:]
                     else:
-                        syms = [ ]
+                        syms = []
                     if assign != ':' and assign != '::=':
-                        sys.stderr.write("%s:%d: Syntax error. Expected ':'\n" % (file,dline))
+                        sys.stderr.write("%s:%d: Syntax error. Expected ':'\n" % (file, dline))
                         return -1
-                         
- 
-                e = add_production(f,file,dline,prodname,syms)
+
+                e = add_production(f, file, dline, prodname, syms)
                 error += e
 
-                
-            except StandardError:
-                sys.stderr.write("%s:%d: Syntax error in rule '%s'\n" % (file,dline,ps))
+            except Exception:
+                sys.stderr.write("%s:%d: Syntax error in rule '%s'\n" % (file, dline, ps))
                 error -= 1
     else:
-        sys.stderr.write("%s:%d: No documentation string specified in function '%s'\n" % (file,line,f.__name__))
+        sys.stderr.write(
+            "%s:%d: No documentation string specified in function '%s'\n" %
+            (file, line, f.__name__))
     return error
 
 
@@ -826,16 +878,17 @@
     Print a warning for any nonterminals that can't be reached.
     (Unused terminals have already had their warning.)
     '''
-    Reachable = { }
+    Reachable = {}
     for s in Terminals.keys() + Nonterminals.keys():
         Reachable[s] = 0
 
-    mark_reachable_from( Productions[0].prod[0], Reachable )
+    mark_reachable_from(Productions[0].prod[0], Reachable)
 
     for s in Nonterminals.keys():
         if not Reachable[s]:
             sys.stderr.write("yacc: Symbol '%s' is unreachable.\n" % s)
 
+
 def mark_reachable_from(s, Reachable):
     '''
     Mark all symbols that are reachable from symbol s.
@@ -844,7 +897,7 @@
         # We've already reached symbol s.
         return
     Reachable[s] = 1
-    for p in Prodnames.get(s,[]):
+    for p in Prodnames.get(s, []):
         for r in p.prod:
             mark_reachable_from(r, Reachable)
 
@@ -855,6 +908,8 @@
 # infinite recursion cycles (grammar rules where there is no possible way
 # to derive a string of only terminals).
 # -----------------------------------------------------------------------------
+
+
 def compute_terminates():
     '''
     Raise an error for any symbols that don't terminate.
@@ -874,9 +929,9 @@
         Terminates[n] = 0
 
     # Then propagate termination until no change:
-    while 1:
+    while True:
         some_change = 0
-        for (n,pl) in Prodnames.items():
+        for (n, pl) in Prodnames.items():
             # Nonterminal n terminates iff any of its productions terminates.
             for p in pl:
                 # Production p terminates iff all of its rhs symbols terminate.
@@ -904,9 +959,9 @@
             break
 
     some_error = 0
-    for (s,terminates) in Terminates.items():
+    for (s, terminates) in Terminates.items():
         if not terminates:
-            if not Prodnames.has_key(s) and not Terminals.has_key(s) and s != 'error':
+            if s not in Prodnames and s not in Terminals and s != 'error':
                 # s is used-but-not-defined, and we've already warned of that,
                 # so it would be overkill to say that it's also non-terminating.
                 pass
@@ -921,42 +976,49 @@
 #
 # This function examines all of the supplied rules to see if they seem valid.
 # -----------------------------------------------------------------------------
+
+
 def verify_productions(cycle_check=1):
     error = 0
     for p in Productions:
-        if not p: continue
+        if not p:
+            continue
 
         for s in p.prod:
-            if not Prodnames.has_key(s) and not Terminals.has_key(s) and s != 'error':
-                sys.stderr.write("%s:%d: Symbol '%s' used, but not defined as a token or a rule.\n" % (p.file,p.line,s))
+            if s not in Prodnames and s not in Terminals and s != 'error':
+                sys.stderr.write(
+                    "%s:%d: Symbol '%s' used, but not defined as a token or a rule.\n" %
+                    (p.file, p.line, s))
                 error = 1
                 continue
 
-    unused_tok = 0 
+    unused_tok = 0
     # Now verify all of the tokens
     if yaccdebug:
         _vf.write("Unused terminals:\n\n")
-    for s,v in Terminals.items():
+    for s, v in Terminals.items():
         if s != 'error' and not v:
             sys.stderr.write("yacc: Warning. Token '%s' defined, but not used.\n" % s)
-            if yaccdebug: _vf.write("   %s\n"% s)
+            if yaccdebug:
+                _vf.write("   %s\n" % s)
             unused_tok += 1
 
     # Print out all of the productions
     if yaccdebug:
         _vf.write("\nGrammar\n\n")
-        for i in range(1,len(Productions)):
+        for i in range(1, len(Productions)):
             _vf.write("Rule %-5d %s\n" % (i, Productions[i]))
-        
+
     unused_prod = 0
     # Verify the use of all productions
-    for s,v in Nonterminals.items():
+    for s, v in Nonterminals.items():
         if not v:
             p = Prodnames[s][0]
-            sys.stderr.write("%s:%d: Warning. Rule '%s' defined, but not used.\n" % (p.file,p.line, s))
+            sys.stderr.write(
+                "%s:%d: Warning. Rule '%s' defined, but not used.\n" %
+                (p.file, p.line, s))
             unused_prod += 1
 
-    
     if unused_tok == 1:
         sys.stderr.write("yacc: Warning. There is 1 unused token.\n")
     if unused_tok > 1:
@@ -969,13 +1031,11 @@
 
     if yaccdebug:
         _vf.write("\nTerminals, with rules where they appear\n\n")
-        ks = Terminals.keys()
-        ks.sort()
+        ks = sorted(Terminals.keys())
         for k in ks:
             _vf.write("%-20s : %s\n" % (k, " ".join([str(s) for s in Terminals[k]])))
         _vf.write("\nNonterminals, with rules where they appear\n\n")
-        ks = Nonterminals.keys()
-        ks.sort()
+        ks = sorted(Nonterminals.keys())
         for k in ks:
             _vf.write("%-20s : %s\n" % (k, " ".join([str(s) for s in Nonterminals[k]])))
 
@@ -997,18 +1057,20 @@
 #
 # Creates the list
 #
-#  [E -> . E PLUS E, E -> E . PLUS E, E -> E PLUS . E, E -> E PLUS E . ] 
+#  [E -> . E PLUS E, E -> E . PLUS E, E -> E PLUS . E, E -> E PLUS E . ]
 # -----------------------------------------------------------------------------
 
+
 def build_lritems():
     for p in Productions:
         lastlri = p
         lri = p.lr_item(0)
         i = 0
-        while 1:
+        while True:
             lri = p.lr_item(i)
             lastlri.lr_next = lri
-            if not lri: break
+            if not lri:
+                break
             lri.lr_num = len(LRitems)
             LRitems.append(lri)
             lastlri = lri
@@ -1025,6 +1087,7 @@
 # Given a list of precedence rules, add to the precedence table.
 # -----------------------------------------------------------------------------
 
+
 def add_precedence(plist):
     plevel = 0
     error = 0
@@ -1037,11 +1100,11 @@
                 sys.stderr.write("yacc: Invalid precedence '%s'\n" % prec)
                 return -1
             for t in terms:
-                if Precedence.has_key(t):
+                if t in Precedence:
                     sys.stderr.write("yacc: Precedence already specified for terminal '%s'\n" % t)
                     error += 1
                     continue
-                Precedence[t] = (prec,plevel)
+                Precedence[t] = (prec, plevel)
         except:
             sys.stderr.write("yacc: Invalid precedence table.\n")
             error += 1
@@ -1055,11 +1118,15 @@
 # is the starting symbol.
 # -----------------------------------------------------------------------------
 
+
 def augment_grammar(start=None):
     if not start:
         start = Productions[1].name
-    Productions[0] = Production(name="S'",prod=[start],number=0,len=1,prec=('right',0),func=None)
-    Productions[0].usyms = [ start ]
+    Productions[0] = Production(
+        name="S'", prod=[start],
+        number=0, len=1, prec=('right', 0),
+        func=None)
+    Productions[0].usyms = [start]
     Nonterminals[start].append(0)
 
 
@@ -1074,7 +1141,7 @@
 def first(beta):
 
     # We are computing First(x1,x2,x3,...,xn)
-    result = [ ]
+    result = []
     for x in beta:
         x_produces_empty = 0
 
@@ -1083,7 +1150,8 @@
             if f == '<empty>':
                 x_produces_empty = 1
             else:
-                if f not in result: result.append(f)
+                if f not in result:
+                    result.append(f)
 
         if x_produces_empty:
             # We have to consider the next x in beta,
@@ -1108,22 +1176,22 @@
 def compute_follow(start=None):
     # Add '$end' to the follow list of the start symbol
     for k in Nonterminals.keys():
-        Follow[k] = [ ]
+        Follow[k] = []
 
     if not start:
         start = Productions[1].name
-        
-    Follow[start] = [ '$end' ]
-        
-    while 1:
+
+    Follow[start] = ['$end']
+
+    while True:
         didadd = 0
         for p in Productions[1:]:
             # Here is the production set
             for i in range(len(p.prod)):
                 B = p.prod[i]
-                if Nonterminals.has_key(B):
+                if B in Nonterminals:
                     # Okay. We got a non-terminal in a production
-                    fst = first(p.prod[i+1:])
+                    fst = first(p.prod[i + 1:])
                     hasempty = 0
                     for f in fst:
                         if f != '<empty>' and f not in Follow[B]:
@@ -1131,13 +1199,14 @@
                             didadd = 1
                         if f == '<empty>':
                             hasempty = 1
-                    if hasempty or i == (len(p.prod)-1):
+                    if hasempty or i == (len(p.prod) - 1):
                         # Add elements of follow(a) to follow(b)
                         for f in Follow[p.name]:
                             if f not in Follow[B]:
                                 Follow[B].append(f)
                                 didadd = 1
-        if not didadd: break
+        if not didadd:
+            break
 
     if 0 and yaccdebug:
         _vf.write('\nFollow:\n')
@@ -1149,6 +1218,8 @@
 #
 # Compute the value of FIRST1(X) for all symbols
 # -------------------------------------------------------------------------
+
+
 def compute_first1():
 
     # Terminals:
@@ -1156,7 +1227,7 @@
         First[t] = [t]
 
     First['$end'] = ['$end']
-    First['#'] = ['#'] # what's this for?
+    First['#'] = ['#']  # what's this for?
 
     # Nonterminals:
 
@@ -1165,13 +1236,13 @@
         First[n] = []
 
     # Then propagate symbols until no change:
-    while 1:
+    while True:
         some_change = 0
         for n in Nonterminals.keys():
             for p in Prodnames[n]:
                 for f in first(p.prod):
                     if f not in First[n]:
-                        First[n].append( f )
+                        First[n].append(f)
                         some_change = 1
         if not some_change:
             break
@@ -1180,7 +1251,7 @@
         _vf.write('\nFirst:\n')
         for k in Nonterminals.keys():
             _vf.write("%-20s : %s\n" %
-                (k, " ".join([str(s) for s in First[k]])))
+                      (k, " ".join([str(s) for s in First[k]])))
 
 # -----------------------------------------------------------------------------
 #                           === SLR Generation ===
@@ -1190,41 +1261,45 @@
 # -----------------------------------------------------------------------------
 
 # Global variables for the LR parsing engine
+
+
 def lr_init_vars():
     global _lr_action, _lr_goto, _lr_method
     global _lr_goto_cache, _lr0_cidhash
-    
-    _lr_action       = { }        # Action table
-    _lr_goto         = { }        # Goto table
-    _lr_method       = "Unknown"  # LR method used
-    _lr_goto_cache   = { }
-    _lr0_cidhash     = { }
 
+    _lr_action = {}        # Action table
+    _lr_goto = {}        # Goto table
+    _lr_method = "Unknown"  # LR method used
+    _lr_goto_cache = {}
+    _lr0_cidhash = {}
 
+
 # Compute the LR(0) closure operation on I, where I is a set of LR(0) items.
 # prodlist is a list of productions.
 
 _add_count = 0       # Counter used to detect cycles
 
+
 def lr0_closure(I):
     global _add_count
-    
+
     _add_count += 1
     prodlist = Productions
-    
-    # Add everything in I to J        
+
+    # Add everything in I to J
     J = I[:]
     didadd = 1
     while didadd:
         didadd = 0
         for j in J:
             for x in j.lrafter:
-                if x.lr0_added == _add_count: continue
+                if x.lr0_added == _add_count:
+                    continue
                 # Add B --> .G to J
                 J.append(x.lr_next)
                 x.lr0_added = _add_count
                 didadd = 1
-               
+
     return J
 
 # Compute the LR(0) goto function goto(I,X) where I is a set
@@ -1234,45 +1309,49 @@
 # objects).  With uniqueness, we can later do fast set comparisons using
 # id(obj) instead of element-wise comparison.
 
-def lr0_goto(I,x):
+
+def lr0_goto(I, x):
     # First we look for a previously cached entry
-    g = _lr_goto_cache.get((id(I),x),None)
-    if g: return g
+    g = _lr_goto_cache.get((id(I), x), None)
+    if g:
+        return g
 
     # Now we generate the goto set in a way that guarantees uniqueness
     # of the result
-    
-    s = _lr_goto_cache.get(x,None)
+
+    s = _lr_goto_cache.get(x, None)
     if not s:
-        s = { }
+        s = {}
         _lr_goto_cache[x] = s
 
-    gs = [ ]
+    gs = []
     for p in I:
         n = p.lr_next
         if n and n.lrbefore == x:
-            s1 = s.get(id(n),None)
+            s1 = s.get(id(n), None)
             if not s1:
-                s1 = { }
+                s1 = {}
                 s[id(n)] = s1
             gs.append(n)
             s = s1
-    g = s.get('$end',None)
+    g = s.get('$end', None)
     if not g:
         if gs:
             g = lr0_closure(gs)
             s['$end'] = g
         else:
             s['$end'] = gs
-    _lr_goto_cache[(id(I),x)] = g
+    _lr_goto_cache[(id(I), x)] = g
     return g
 
-_lr0_cidhash = { }
+_lr0_cidhash = {}
 
 # Compute the LR(0) sets of item function
+
+
 def lr0_items():
-    
-    C = [ lr0_closure([Productions[0].lr_next]) ]
+
+    C = [lr0_closure([Productions[0].lr_next])]
     i = 0
     for I in C:
         _lr0_cidhash[id(I)] = i
@@ -1285,18 +1364,20 @@
         i += 1
 
         # Collect all of the symbols that could possibly be in the goto(I,X) sets
-        asyms = { }
+        asyms = {}
         for ii in I:
             for s in ii.usyms:
                 asyms[s] = None
 
         for x in asyms.keys():
-            g = lr0_goto(I,x)
-            if not g:  continue
-            if _lr0_cidhash.has_key(id(g)): continue
-            _lr0_cidhash[id(g)] = len(C)            
+            g = lr0_goto(I, x)
+            if not g:
+                continue
+            if id(g) in _lr0_cidhash:
+                continue
+            _lr0_cidhash[id(g)] = len(C)
             C.append(g)
-            
+
     return C
 
 # -----------------------------------------------------------------------------
@@ -1318,7 +1399,7 @@
 #  J. Tremblay and P. Sorenson, "The Theory and Practice of Compiler Writing",
 #      McGraw-Hill Book Company, (1985).
 #
-# Note:  This implementation is a complete replacement of the LALR(1) 
+# Note:  This implementation is a complete replacement of the LALR(1)
 #        implementation in PLY-1.x releases.   That version was based on
 #        a less efficient algorithm and it had bugs in its implementation.
 # -----------------------------------------------------------------------------
@@ -1327,23 +1408,26 @@
 # compute_nullable_nonterminals()
 #
 # Creates a dictionary containing all of the non-terminals that might produce
-# an empty production.   
+# an empty production.
 # -----------------------------------------------------------------------------
 
+
 def compute_nullable_nonterminals():
     nullable = {}
     num_nullable = 0
-    while 1:
-       for p in Productions[1:]:
-           if p.len == 0:
+    while True:
+        for p in Productions[1:]:
+            if p.len == 0:
                 nullable[p.name] = 1
                 continue
-           for t in p.prod:
-                if not nullable.has_key(t): break
-           else:
+            for t in p.prod:
+                if t not in nullable:
+                    break
+            else:
                 nullable[p.name] = 1
-       if len(nullable) == num_nullable: break
-       num_nullable = len(nullable)
+        if len(nullable) == num_nullable:
+            break
+        num_nullable = len(nullable)
     return nullable
 
 # -----------------------------------------------------------------------------
@@ -1357,16 +1441,18 @@
 # The input C is the set of LR(0) items.
 # -----------------------------------------------------------------------------
 
+
 def find_nonterminal_transitions(C):
-     trans = []
-     for state in range(len(C)):
-         for p in C[state]:
-             if p.lr_index < p.len - 1:
-                  t = (state,p.prod[p.lr_index+1])
-                  if Nonterminals.has_key(t[1]):
-                        if t not in trans: trans.append(t)
-         state = state + 1
-     return trans
+    trans = []
+    for state in range(len(C)):
+        for p in C[state]:
+            if p.lr_index < p.len - 1:
+                t = (state, p.prod[p.lr_index + 1])
+                if t[1] in Nonterminals:
+                    if t not in trans:
+                        trans.append(t)
+        state = state + 1
+    return trans
 
 # -----------------------------------------------------------------------------
 # dr_relation()
@@ -1377,22 +1463,24 @@
 # Returns a list of terminals.
 # -----------------------------------------------------------------------------
 
-def dr_relation(C,trans,nullable):
-    dr_set = { }
-    state,N = trans
+
+def dr_relation(C, trans, nullable):
+    dr_set = {}
+    state, N = trans
     terms = []
 
-    g = lr0_goto(C[state],N)
+    g = lr0_goto(C[state], N)
     for p in g:
-       if p.lr_index < p.len - 1:
-           a = p.prod[p.lr_index+1]
-           if Terminals.has_key(a):
-               if a not in terms: terms.append(a)
+        if p.lr_index < p.len - 1:
+            a = p.prod[p.lr_index + 1]
+            if a in Terminals:
+                if a not in terms:
+                    terms.append(a)
 
     # This extra bit is to handle the start state
     if state == 0 and N == Productions[0].prod[0]:
-       terms.append('$end')
- 
+        terms.append('$end')
+
     return terms
 
 # -----------------------------------------------------------------------------
@@ -1401,18 +1489,19 @@
 # Computes the READS() relation (p,A) READS (t,C).
 # -----------------------------------------------------------------------------
 
+
 def reads_relation(C, trans, empty):
     # Look for empty transitions
     rel = []
     state, N = trans
 
-    g = lr0_goto(C[state],N)
-    j = _lr0_cidhash.get(id(g),-1)
+    g = lr0_goto(C[state], N)
+    j = _lr0_cidhash.get(id(g), -1)
     for p in g:
         if p.lr_index < p.len - 1:
-             a = p.prod[p.lr_index + 1]
-             if empty.has_key(a):
-                  rel.append((j,a))
+            a = p.prod[p.lr_index + 1]
+            if a in empty:
+                rel.append((j, a))
 
     return rel
 
@@ -1422,30 +1511,31 @@
 # Determines the lookback and includes relations
 #
 # LOOKBACK:
-# 
+#
 # This relation is determined by running the LR(0) state machine forward.
 # For example, starting with a production "N : . A B C", we run it forward
 # to obtain "N : A B C ."   We then build a relationship between this final
 # state and the starting state.   These relationships are stored in a dictionary
-# lookdict.   
+# lookdict.
 #
 # INCLUDES:
 #
-# Computes the INCLUDE() relation (p,A) INCLUDES (p',B).   
+# Computes the INCLUDE() relation (p,A) INCLUDES (p',B).
 #
 # This relation is used to determine non-terminal transitions that occur
 # inside of other non-terminal transition states.   (p,A) INCLUDES (p', B)
 # if the following holds:
 #
-#       B -> LAT, where T -> epsilon and p' -L-> p 
+#       B -> LAT, where T -> epsilon and p' -L-> p
 #
 # L is essentially a prefix (which may be empty), T is a suffix that must be
 # able to derive an empty string.  State p' must lead to state p with the string L.
-# 
+#
 # -----------------------------------------------------------------------------
 
-def compute_lookback_includes(C,trans,nullable):
-    
+
+def compute_lookback_includes(C, trans, nullable):
+
     lookdict = {}          # Dictionary of lookback relations
     includedict = {}       # Dictionary of include relations
 
@@ -1453,58 +1543,65 @@
     dtrans = {}
     for t in trans:
         dtrans[t] = 1
-    
+
     # Loop over all transitions and compute lookbacks and includes
-    for state,N in trans:
+    for state, N in trans:
         lookb = []
         includes = []
         for p in C[state]:
-            if p.name != N: continue
-        
+            if p.name != N:
+                continue
+
             # Okay, we have a name match.  We now follow the production all the way
             # through the state machine until we get the . on the right hand side
 
             lr_index = p.lr_index
             j = state
             while lr_index < p.len - 1:
-                 lr_index = lr_index + 1
-                 t = p.prod[lr_index]
+                lr_index = lr_index + 1
+                t = p.prod[lr_index]
 
-                 # Check to see if this symbol and state are a non-terminal transition
-                 if dtrans.has_key((j,t)):
-                       # Yes.  Okay, there is some chance that this is an includes relation
-                       # the only way to know for certain is whether the rest of the 
-                       # production derives empty
+                # Check to see if this symbol and state are a non-terminal transition
+                if (j, t) in dtrans:
+                    # Yes.  Okay, there is some chance that this is an includes relation
+                    # the only way to know for certain is whether the rest of the
+                    # production derives empty
 
-                       li = lr_index + 1
-                       while li < p.len:
-                            if Terminals.has_key(p.prod[li]): break      # No forget it
-                            if not nullable.has_key(p.prod[li]): break
-                            li = li + 1
-                       else:
-                            # Appears to be a relation between (j,t) and (state,N)
-                            includes.append((j,t))
+                    li = lr_index + 1
+                    while li < p.len:
+                        if p.prod[li] in Terminals:
+                            break      # No forget it
+                        if p.prod[li] not in nullable:
+                            break
+                        li = li + 1
+                    else:
+                        # Appears to be a relation between (j,t) and (state,N)
+                        includes.append((j, t))
 
-                 g = lr0_goto(C[j],t)               # Go to next set             
-                 j = _lr0_cidhash.get(id(g),-1)     # Go to next state
-             
+                g = lr0_goto(C[j], t)               # Go to next set
+                j = _lr0_cidhash.get(id(g), -1)     # Go to next state
+
             # When we get here, j is the final state, now we have to locate the production
             for r in C[j]:
-                 if r.name != p.name: continue
-                 if r.len != p.len:   continue
-                 i = 0
-                 # This look is comparing a production ". A B C" with "A B C ."
-                 while i < r.lr_index:
-                      if r.prod[i] != p.prod[i+1]: break
-                      i = i + 1
-                 else:
-                      lookb.append((j,r))
+                if r.name != p.name:
+                    continue
+                if r.len != p.len:
+                    continue
+                i = 0
+                # This look is comparing a production ". A B C" with "A B C ."
+                while i < r.lr_index:
+                    if r.prod[i] != p.prod[i + 1]:
+                        break
+                    i = i + 1
+                else:
+                    lookb.append((j, r))
         for i in includes:
-             if not includedict.has_key(i): includedict[i] = []
-             includedict[i].append((state,N))
-        lookdict[(state,N)] = lookb
+            if i not in includedict:
+                includedict[i] = []
+            includedict[i].append((state, N))
+        lookdict[(state, N)] = lookb
 
-    return lookdict,includedict
+    return lookdict, includedict
 
 # -----------------------------------------------------------------------------
 # digraph()
@@ -1523,37 +1620,41 @@
 #          FP   - Set-valued function
 # ------------------------------------------------------------------------------
 
-def digraph(X,R,FP):
-    N = { }
+
+def digraph(X, R, FP):
+    N = {}
     for x in X:
-       N[x] = 0
+        N[x] = 0
     stack = []
-    F = { }
+    F = {}
     for x in X:
-        if N[x] == 0: traverse(x,N,stack,F,X,R,FP)
+        if N[x] == 0:
+            traverse(x, N, stack, F, X, R, FP)
     return F
 
-def traverse(x,N,stack,F,X,R,FP):
+
+def traverse(x, N, stack, F, X, R, FP):
     stack.append(x)
     d = len(stack)
     N[x] = d
     F[x] = FP(x)             # F(X) <- F'(x)
-    
+
     rel = R(x)               # Get y's related to x
     for y in rel:
         if N[y] == 0:
-             traverse(y,N,stack,F,X,R,FP)
-        N[x] = min(N[x],N[y])
-        for a in F.get(y,[]):
-            if a not in F[x]: F[x].append(a)
+            traverse(y, N, stack, F, X, R, FP)
+        N[x] = min(N[x], N[y])
+        for a in F.get(y, []):
+            if a not in F[x]:
+                F[x].append(a)
     if N[x] == d:
-       N[stack[-1]] = sys.maxint
-       F[stack[-1]] = F[x]
-       element = stack.pop()
-       while element != x:
-           N[stack[-1]] = sys.maxint
-           F[stack[-1]] = F[x]
-           element = stack.pop()
+        N[stack[-1]] = sys.maxsize
+        F[stack[-1]] = F[x]
+        element = stack.pop()
+        while element != x:
+            N[stack[-1]] = sys.maxsize
+            F[stack[-1]] = F[x]
+            element = stack.pop()
 
 # -----------------------------------------------------------------------------
 # compute_read_sets()
@@ -1567,38 +1668,40 @@
 # Returns a set containing the read sets
 # -----------------------------------------------------------------------------
 
+
 def compute_read_sets(C, ntrans, nullable):
-    FP = lambda x: dr_relation(C,x,nullable)
-    R =  lambda x: reads_relation(C,x,nullable)
-    F = digraph(ntrans,R,FP)
+    FP = lambda x: dr_relation(C, x, nullable)
+    R = lambda x: reads_relation(C, x, nullable)
+    F = digraph(ntrans, R, FP)
     return F
 
 # -----------------------------------------------------------------------------
 # compute_follow_sets()
 #
-# Given a set of LR(0) items, a set of non-terminal transitions, a readset, 
+# Given a set of LR(0) items, a set of non-terminal transitions, a readset,
 # and an include set, this function computes the follow sets
 #
 # Follow(p,A) = Read(p,A) U U {Follow(p',B) | (p,A) INCLUDES (p',B)}
 #
-# Inputs:    
+# Inputs:
 #            ntrans     = Set of nonterminal transitions
 #            readsets   = Readset (previously computed)
 #            inclsets   = Include sets (previously computed)
 #
-# Returns a set containing the follow sets      
+# Returns a set containing the follow sets
 # -----------------------------------------------------------------------------
 
-def compute_follow_sets(ntrans,readsets,inclsets):
-     FP = lambda x: readsets[x]
-     R  = lambda x: inclsets.get(x,[])
-     F = digraph(ntrans,R,FP)
-     return F
 
+def compute_follow_sets(ntrans, readsets, inclsets):
+    FP = lambda x: readsets[x]
+    R = lambda x: inclsets.get(x, [])
+    F = digraph(ntrans, R, FP)
+    return F
+
 # -----------------------------------------------------------------------------
 # add_lookaheads()
 #
-# Attaches the lookahead symbols to grammar rules. 
+# Attaches the lookahead symbols to grammar rules.
 #
 # Inputs:    lookbacks         -  Set of lookback relations
 #            followset         -  Computed follow set
@@ -1607,15 +1710,17 @@
 # in the lookbacks set
 # -----------------------------------------------------------------------------
 
-def add_lookaheads(lookbacks,followset):
-    for trans,lb in lookbacks.items():
+
+def add_lookaheads(lookbacks, followset):
+    for trans, lb in lookbacks.items():
         # Loop over productions in lookback
-        for state,p in lb:
-             if not p.lookaheads.has_key(state):
-                  p.lookaheads[state] = []
-             f = followset.get(trans,[])
-             for a in f:
-                  if a not in p.lookaheads[state]: p.lookaheads[state].append(a)
+        for state, p in lb:
+            if state not in p.lookaheads:
+                p.lookaheads[state] = []
+            f = followset.get(trans, [])
+            for a in f:
+                if a not in p.lookaheads[state]:
+                    p.lookaheads[state].append(a)
 
 # -----------------------------------------------------------------------------
 # add_lalr_lookaheads()
@@ -1624,6 +1729,7 @@
 # with LALR parsing
 # -----------------------------------------------------------------------------
 
+
 def add_lalr_lookaheads(C):
     # Determine all of the nullable nonterminals
     nullable = compute_nullable_nonterminals()
@@ -1632,40 +1738,42 @@
     trans = find_nonterminal_transitions(C)
 
     # Compute read sets
-    readsets = compute_read_sets(C,trans,nullable)
+    readsets = compute_read_sets(C, trans, nullable)
 
     # Compute lookback/includes relations
-    lookd, included = compute_lookback_includes(C,trans,nullable)
+    lookd, included = compute_lookback_includes(C, trans, nullable)
 
     # Compute LALR FOLLOW sets
-    followsets = compute_follow_sets(trans,readsets,included)
-    
+    followsets = compute_follow_sets(trans, readsets, included)
+
     # Add all of the lookaheads
-    add_lookaheads(lookd,followsets)
+    add_lookaheads(lookd, followsets)
 
 # -----------------------------------------------------------------------------
 # lr_parse_table()
 #
 # This function constructs the parse tables for SLR or LALR
 # -----------------------------------------------------------------------------
+
+
 def lr_parse_table(method):
     global _lr_method
     goto = _lr_goto           # Goto array
     action = _lr_action       # Action array
-    actionp = { }             # Action production array (temporary)
+    actionp = {}             # Action production array (temporary)
 
     _lr_method = method
-    
+
     n_srconflict = 0
     n_rrconflict = 0
 
     if yaccdebug:
-        sys.stderr.write("yacc: Generating %s parsing table...\n" % method)        
+        sys.stderr.write("yacc: Generating %s parsing table...\n" % method)
         _vf.write("\n\nParsing method: %s\n\n" % method)
-        
+
     # Step 1: Construct C = { I0, I1, ... IN}, collection of LR(0) items
     # This determines the number of states
-    
+
     C = lr0_items()
 
     if method == 'LALR':
@@ -1675,8 +1783,8 @@
     st = 0
     for I in C:
         # Loop over each production in I
-        actlist = [ ]              # List of actions
-        
+        actlist = []              # List of actions
+
         if yaccdebug:
             _vf.write("\nstate %d\n\n" % st)
             for p in I:
@@ -1688,8 +1796,8 @@
                 if p.prod[-1] == ".":
                     if p.name == "S'":
                         # Start symbol. Accept!
-                        action[st,"$end"] = 0
-                        actionp[st,"$end"] = p
+                        action[st, "$end"] = 0
+                        actionp[st, "$end"] = p
                     else:
                         # We are at the end of a production.  Reduce!
                         if method == 'LALR':
@@ -1697,59 +1805,72 @@
                         else:
                             laheads = Follow[p.name]
                         for a in laheads:
-                            actlist.append((a,p,"reduce using rule %d (%s)" % (p.number,p)))
-                            r = action.get((st,a),None)
+                            actlist.append((a, p, "reduce using rule %d (%s)" % (p.number, p)))
+                            r = action.get((st, a), None)
                             if r is not None:
                                 # Whoa. Have a shift/reduce or reduce/reduce conflict
                                 if r > 0:
                                     # Need to decide on shift or reduce here
                                     # By default we favor shifting. Need to add
                                     # some precedence rules here.
-                                    sprec,slevel = Productions[actionp[st,a].number].prec                                    
-                                    rprec,rlevel = Precedence.get(a,('right',0))
-                                    if (slevel < rlevel) or ((slevel == rlevel) and (rprec == 'left')):
-                                        # We really need to reduce here.  
-                                        action[st,a] = -p.number
-                                        actionp[st,a] = p
+                                    sprec, slevel = Productions[actionp[st, a].number].prec
+                                    rprec, rlevel = Precedence.get(a, ('right', 0))
+                                    if (slevel < rlevel) or (
+                                            (slevel == rlevel) and (rprec == 'left')):
+                                        # We really need to reduce here.
+                                        action[st, a] = -p.number
+                                        actionp[st, a] = p
                                         if not slevel and not rlevel:
-                                            _vfc.write("shift/reduce conflict in state %d resolved as reduce.\n" % st)
-                                            _vf.write("  ! shift/reduce conflict for %s resolved as reduce.\n" % a)
+                                            _vfc.write(
+                                                "shift/reduce conflict in state %d resolved as reduce.\n" % st)
+                                            _vf.write(
+                                                "  ! shift/reduce conflict for %s resolved as reduce.\n" % a)
                                             n_srconflict += 1
                                     elif (slevel == rlevel) and (rprec == 'nonassoc'):
-                                        action[st,a] = None
+                                        action[st, a] = None
                                     else:
                                         # Hmmm. Guess we'll keep the shift
                                         if not rlevel:
-                                            _vfc.write("shift/reduce conflict in state %d resolved as shift.\n" % st)
-                                            _vf.write("  ! shift/reduce conflict for %s resolved as shift.\n" % a)
-                                            n_srconflict +=1                                    
+                                            _vfc.write(
+                                                "shift/reduce conflict in state %d resolved as shift.\n" % st)
+                                            _vf.write(
+                                                "  ! shift/reduce conflict for %s resolved as shift.\n" % a)
+                                            n_srconflict += 1
                                 elif r < 0:
                                     # Reduce/reduce conflict.   In this case, we favor the rule
                                     # that was defined first in the grammar file
                                     oldp = Productions[-r]
                                     pp = Productions[p.number]
                                     if oldp.line > pp.line:
-                                        action[st,a] = -p.number
-                                        actionp[st,a] = p
+                                        action[st, a] = -p.number
+                                        actionp[st, a] = p
                                     # sys.stderr.write("Reduce/reduce conflict in state %d\n" % st)
                                     n_rrconflict += 1
-                                    _vfc.write("reduce/reduce conflict in state %d resolved using rule %d (%s).\n" % (st, actionp[st,a].number, actionp[st,a]))
-                                    _vf.write("  ! reduce/reduce conflict for %s resolved using rule %d (%s).\n" % (a,actionp[st,a].number, actionp[st,a]))
+                                    _vfc.write(
+                                        "reduce/reduce conflict in state %d resolved using rule %d (%s).\n" %
+                                        (st, actionp[
+                                            st, a].number, actionp[
+                                            st, a]))
+                                    _vf.write(
+                                        "  ! reduce/reduce conflict for %s resolved using rule %d (%s).\n" %
+                                        (a, actionp[
+                                            st, a].number, actionp[
+                                            st, a]))
                                 else:
                                     sys.stderr.write("Unknown conflict in state %d\n" % st)
                             else:
-                                action[st,a] = -p.number
-                                actionp[st,a] = p
+                                action[st, a] = -p.number
+                                actionp[st, a] = p
                 else:
                     i = p.lr_index
-                    a = p.prod[i+1]       # Get symbol right after the "."
-                    if Terminals.has_key(a):
-                        g = lr0_goto(I,a)
-                        j = _lr0_cidhash.get(id(g),-1)
+                    a = p.prod[i + 1]       # Get symbol right after the "."
+                    if a in Terminals:
+                        g = lr0_goto(I, a)
+                        j = _lr0_cidhash.get(id(g), -1)
                         if j >= 0:
                             # We are in a shift state
-                            actlist.append((a,p,"shift and go to state %d" % j))
-                            r = action.get((st,a),None)
+                            actlist.append((a, p, "shift and go to state %d" % j))
+                            r = action.get((st, a), None)
                             if r is not None:
                                 # Whoa have a shift/reduce or shift/shift conflict
                                 if r > 0:
@@ -1760,65 +1881,70 @@
                                     #   -  if precedence of reduce rule is higher, we reduce.
                                     #   -  if precedence of reduce is same and left assoc, we reduce.
                                     #   -  otherwise we shift
-                                    rprec,rlevel = Productions[actionp[st,a].number].prec
-                                    sprec,slevel = Precedence.get(a,('right',0))
-                                    if (slevel > rlevel) or ((slevel == rlevel) and (rprec != 'left')):
+                                    rprec, rlevel = Productions[actionp[st, a].number].prec
+                                    sprec, slevel = Precedence.get(a, ('right', 0))
+                                    if (slevel > rlevel) or (
+                                            (slevel == rlevel) and (rprec != 'left')):
                                         # We decide to shift here... highest precedence to shift
-                                        action[st,a] = j
-                                        actionp[st,a] = p
+                                        action[st, a] = j
+                                        actionp[st, a] = p
                                         if not rlevel:
                                             n_srconflict += 1
-                                            _vfc.write("shift/reduce conflict in state %d resolved as shift.\n" % st)
-                                            _vf.write("  ! shift/reduce conflict for %s resolved as shift.\n" % a)
+                                            _vfc.write(
+                                                "shift/reduce conflict in state %d resolved as shift.\n" % st)
+                                            _vf.write(
+                                                "  ! shift/reduce conflict for %s resolved as shift.\n" % a)
                                     elif (slevel == rlevel) and (rprec == 'nonassoc'):
-                                        action[st,a] = None
-                                    else:                                            
+                                        action[st, a] = None
+                                    else:
                                         # Hmmm. Guess we'll keep the reduce
                                         if not slevel and not rlevel:
-                                            n_srconflict +=1
-                                            _vfc.write("shift/reduce conflict in state %d resolved as reduce.\n" % st)
-                                            _vf.write("  ! shift/reduce conflict for %s resolved as reduce.\n" % a)
-                                            
+                                            n_srconflict += 1
+                                            _vfc.write(
+                                                "shift/reduce conflict in state %d resolved as reduce.\n" % st)
+                                            _vf.write(
+                                                "  ! shift/reduce conflict for %s resolved as reduce.\n" % a)
+
                                 else:
                                     sys.stderr.write("Unknown conflict in state %d\n" % st)
                             else:
-                                action[st,a] = j
-                                actionp[st,a] = p
-                                
-            except StandardError as e:
+                                action[st, a] = j
+                                actionp[st, a] = p
+
+            except Exception as e:
                 raise YaccError, "Hosed in lr_parse_table", e
 
         # Print the actions associated with each terminal
         if yaccdebug:
-          _actprint = { }
-          for a,p,m in actlist:
-            if action.has_key((st,a)):
-                if p is actionp[st,a]:
-                    _vf.write("    %-15s %s\n" % (a,m))
-                    _actprint[(a,m)] = 1
-          _vf.write("\n")
-          for a,p,m in actlist:
-            if action.has_key((st,a)):
-                if p is not actionp[st,a]:
-                    if not _actprint.has_key((a,m)):
-                        _vf.write("  ! %-15s [ %s ]\n" % (a,m))
-                        _actprint[(a,m)] = 1
-            
+            _actprint = {}
+            for a, p, m in actlist:
+                if (st, a) in action:
+                    if p is actionp[st, a]:
+                        _vf.write("    %-15s %s\n" % (a, m))
+                        _actprint[(a, m)] = 1
+            _vf.write("\n")
+            for a, p, m in actlist:
+                if (st, a) in action:
+                    if p is not actionp[st, a]:
+                        if (a, m) not in _actprint:
+                            _vf.write("  ! %-15s [ %s ]\n" % (a, m))
+                            _actprint[(a, m)] = 1
+
         # Construct the goto table for this state
         if yaccdebug:
             _vf.write("\n")
-        nkeys = { }
+        nkeys = {}
         for ii in I:
             for s in ii.usyms:
-                if Nonterminals.has_key(s):
+                if s in Nonterminals:
                     nkeys[s] = None
         for n in nkeys.keys():
-            g = lr0_goto(I,n)
-            j = _lr0_cidhash.get(id(g),-1)            
+            g = lr0_goto(I, n)
+            j = _lr0_cidhash.get(id(g), -1)
             if j >= 0:
-                goto[st,n] = j
+                goto[st, n] = j
                 if yaccdebug:
-                    _vf.write("    %-30s shift and go to state %d\n" % (n,j))
+                    _vf.write("    %-30s shift and go to state %d\n" % (n, j))
 
         st += 1
 
@@ -1842,10 +1968,11 @@
 # This function writes the LR parsing tables to a file
 # -----------------------------------------------------------------------------
 
-def lr_write_tables(modulename=tab_module,outputdir=''):
-    filename = os.path.join(outputdir,modulename) + ".py"
+
+def lr_write_tables(modulename=tab_module, outputdir=''):
+    filename = os.path.join(outputdir, modulename) + ".py"
     try:
-        f = open(filename,"w")
+        f = open(filename, "w")
 
         f.write("""
 # %s
@@ -1858,28 +1985,28 @@
 
         # Change smaller to 0 to go back to original tables
         smaller = 1
-                
+
         # Factor out names to try and make smaller
         if smaller:
-            items = { }
-        
-            for k,v in _lr_action.items():
+            items = {}
+
+            for k, v in _lr_action.items():
                 i = items.get(k[1])
                 if not i:
-                    i = ([],[])
+                    i = ([], [])
                     items[k[1]] = i
                 i[0].append(k[0])
                 i[1].append(v)
 
             f.write("\n_lr_action_items = {")
-            for k,v in items.items():
+            for k, v in items.items():
                 f.write("%r:([" % k)
                 for i in v[0]:
                     f.write("%r," % i)
                 f.write("],[")
                 for i in v[1]:
                     f.write("%r," % i)
-                           
+
                 f.write("]),")
             f.write("}\n")
 
@@ -1890,34 +2017,34 @@
        _lr_action[(_x,_k)] = _y
 del _lr_action_items
 """)
-            
+
         else:
-            f.write("\n_lr_action = { ");
-            for k,v in _lr_action.items():
-                f.write("(%r,%r):%r," % (k[0],k[1],v))
-            f.write("}\n");
+            f.write("\n_lr_action = { ")
+            for k, v in _lr_action.items():
+                f.write("(%r,%r):%r," % (k[0], k[1], v))
+            f.write("}\n")
 
         if smaller:
             # Factor out names to try and make smaller
-            items = { }
-        
-            for k,v in _lr_goto.items():
+            items = {}
+
+            for k, v in _lr_goto.items():
                 i = items.get(k[1])
                 if not i:
-                    i = ([],[])
+                    i = ([], [])
                     items[k[1]] = i
                 i[0].append(k[0])
                 i[1].append(v)
 
             f.write("\n_lr_goto_items = {")
-            for k,v in items.items():
+            for k, v in items.items():
                 f.write("%r:([" % k)
                 for i in v[0]:
                     f.write("%r," % i)
                 f.write("],[")
                 for i in v[1]:
                     f.write("%r," % i)
-                           
+
                 f.write("]),")
             f.write("}\n")
 
@@ -1929,23 +2056,24 @@
 del _lr_goto_items
 """)
         else:
-            f.write("\n_lr_goto = { ");
-            for k,v in _lr_goto.items():
-                f.write("(%r,%r):%r," % (k[0],k[1],v))                    
-            f.write("}\n");
+            f.write("\n_lr_goto = { ")
+            for k, v in _lr_goto.items():
+                f.write("(%r,%r):%r," % (k[0], k[1], v))
+            f.write("}\n")
 
         # Write production table
         f.write("_lr_productions = [\n")
         for p in Productions:
             if p:
                 if (p.func):
-                    f.write("  (%r,%d,%r,%r,%d),\n" % (p.name, p.len, p.func.__name__,p.file,p.line))
+                    f.write("  (%r,%d,%r,%r,%d),\n" %
+                            (p.name, p.len, p.func.__name__, p.file, p.line))
                 else:
                     f.write("  (%r,%d,None,None,None),\n" % (p.name, p.len))
             else:
                 f.write("  None,\n")
         f.write("]\n")
-        
+
         f.close()
 
     except IOError as e:
@@ -1953,21 +2081,22 @@
         print e
         return
 
-def lr_read_tables(module=tab_module,optimize=0):
+
+def lr_read_tables(module=tab_module, optimize=0):
     global _lr_action, _lr_goto, _lr_productions, _lr_method
     try:
         exec "import %s as parsetab" % module
-        
+
         if (optimize) or (Signature.digest() == parsetab._lr_signature):
             _lr_action = parsetab._lr_action
-            _lr_goto   = parsetab._lr_goto
+            _lr_goto = parsetab._lr_goto
             _lr_productions = parsetab._lr_productions
             _lr_method = parsetab._lr_method
             return 1
         else:
             return 0
-        
-    except (ImportError,AttributeError):
+
+    except (ImportError, AttributeError):
         return 0
 
 
@@ -1976,9 +2105,9 @@
 # with Python 2.0 where types.ObjectType is undefined.
 
 try:
-   _INSTANCETYPE = (types.InstanceType, types.ObjectType)
+    _INSTANCETYPE = (types.InstanceType, types.ObjectType)
 except AttributeError:
-   _INSTANCETYPE = types.InstanceType
+    _INSTANCETYPE = types.InstanceType
 
 # -----------------------------------------------------------------------------
 # yacc(module)
@@ -1987,54 +2116,58 @@
 # -----------------------------------------------------------------------------
 
 # <ah> Add parserclass parameter.
-def yacc(method=default_lr, debug=yaccdebug, module=None, tabmodule=tab_module, start=None, check_recursion=1, optimize=0,write_tables=1,debugfile=debug_file,outputdir='', parserclass=Parser):
+
+
+def yacc(
+        method=default_lr, debug=yaccdebug, module=None, tabmodule=tab_module, start=None,
+        check_recursion=1, optimize=0, write_tables=1, debugfile=debug_file, outputdir='',
+        parserclass=Parser):
     global yaccdebug
     yaccdebug = debug
-    
+
     initialize_vars()
-    files = { }
+    files = {}
     error = 0
 
-
     # Add parsing method to signature
     Signature.update(method)
-    
+
     # If a "module" parameter was supplied, extract its dictionary.
     # Note: a module may in fact be an instance as well.
-    
+
     if module:
         # User supplied a module object.
         if isinstance(module, types.ModuleType):
             ldict = module.__dict__
         elif isinstance(module, _INSTANCETYPE):
-            _items = [(k,getattr(module,k)) for k in dir(module)]
-            ldict = { }
+            _items = [(k, getattr(module, k)) for k in dir(module)]
+            ldict = {}
             for i in _items:
                 ldict[i[0]] = i[1]
         else:
-            raise ValueError,"Expected a module"
-        
+            raise ValueError, "Expected a module"
+
     else:
         # No module given.  We might be able to get information from the caller.
         # Throw an exception and unwind the traceback to get the globals
-        
+
         try:
             raise RuntimeError
         except RuntimeError:
-            e,b,t = sys.exc_info()
+            e, b, t = sys.exc_info()
             f = t.tb_frame
             f = f.f_back           # Walk out to our calling function
             ldict = f.f_globals    # Grab its globals dictionary
 
     # Add starting symbol to signature
     if not start:
-        start = ldict.get("start",None)
+        start = ldict.get("start", None)
     if start:
         Signature.update(start)
 
     # If running in optimized mode.  We're going to
 
-    if (optimize and lr_read_tables(tabmodule,1)):
+    if (optimize and lr_read_tables(tabmodule, 1)):
         # Read parse table
         del Productions[:]
         for p in _lr_productions:
@@ -2043,99 +2176,102 @@
             else:
                 m = MiniProduction()
                 m.name = p[0]
-                m.len  = p[1]
+                m.len = p[1]
                 m.file = p[3]
                 m.line = p[4]
                 if p[2]:
                     m.func = ldict[p[2]]
                 Productions.append(m)
-        
+
     else:
         # Get the tokens map
-        if (module and isinstance(module,_INSTANCETYPE)):
-            tokens = getattr(module,"tokens",None)
+        if (module and isinstance(module, _INSTANCETYPE)):
+            tokens = getattr(module, "tokens", None)
         else:
-            tokens = ldict.get("tokens",None)
-    
+            tokens = ldict.get("tokens", None)
+
         if not tokens:
-            raise YaccError,"module does not define a list 'tokens'"
-        if not (isinstance(tokens,types.ListType) or isinstance(tokens,types.TupleType)):
-            raise YaccError,"tokens must be a list or tuple."
+            raise YaccError, "module does not define a list 'tokens'"
+        if not (isinstance(tokens, types.ListType) or isinstance(tokens, types.TupleType)):
+            raise YaccError, "tokens must be a list or tuple."
 
         # Check to see if a requires dictionary is defined.
-        requires = ldict.get("require",None)
+        requires = ldict.get("require", None)
         if requires:
-            if not (isinstance(requires,types.DictType)):
-                raise YaccError,"require must be a dictionary."
+            if not (isinstance(requires, types.DictType)):
+                raise YaccError, "require must be a dictionary."
 
-            for r,v in requires.items():
+            for r, v in requires.items():
                 try:
-                    if not (isinstance(v,types.ListType)):
+                    if not (isinstance(v, types.ListType)):
                         raise TypeError
                     v1 = [x.split(".") for x in v]
                     Requires[r] = v1
-                except StandardError:
-                    print "Invalid specification for rule '%s' in require. Expected a list of strings" % r            
+                except Exception:
+                    print "Invalid specification for rule '%s' in require. Expected a list of strings" % r
 
-        
         # Build the dictionary of terminals.  We a record a 0 in the
         # dictionary to track whether or not a terminal is actually
         # used in the grammar
 
         if 'error' in tokens:
             print "yacc: Illegal token 'error'.  Is a reserved word."
-            raise YaccError,"Illegal token name"
+            raise YaccError, "Illegal token name"
 
         for n in tokens:
-            if Terminals.has_key(n):
+            if n in Terminals:
                 print "yacc: Warning. Token '%s' multiply defined." % n
-            Terminals[n] = [ ]
+            Terminals[n] = []
 
-        Terminals['error'] = [ ]
+        Terminals['error'] = []
 
         # Get the precedence map (if any)
-        prec = ldict.get("precedence",None)
+        prec = ldict.get("precedence", None)
         if prec:
-            if not (isinstance(prec,types.ListType) or isinstance(prec,types.TupleType)):
-                raise YaccError,"precedence must be a list or tuple."
+            if not (isinstance(prec, types.ListType) or isinstance(prec, types.TupleType)):
+                raise YaccError, "precedence must be a list or tuple."
             add_precedence(prec)
             Signature.update(repr(prec))
 
         for n in tokens:
-            if not Precedence.has_key(n):
-                Precedence[n] = ('right',0)         # Default, right associative, 0 precedence
+            if n not in Precedence:
+                Precedence[n] = ('right', 0)         # Default, right associative, 0 precedence
 
         # Look for error handler
-        ef = ldict.get('p_error',None)
+        ef = ldict.get('p_error', None)
         if ef:
-            if isinstance(ef,types.FunctionType):
+            if isinstance(ef, types.FunctionType):
                 ismethod = 0
             elif isinstance(ef, types.MethodType):
                 ismethod = 1
             else:
-                raise YaccError,"'p_error' defined, but is not a function or method."                
+                raise YaccError, "'p_error' defined, but is not a function or method."
             eline = ef.func_code.co_firstlineno
             efile = ef.func_code.co_filename
             files[efile] = None
 
-            if (ef.func_code.co_argcount != 1+ismethod):
-                raise YaccError,"%s:%d: p_error() requires 1 argument." % (efile,eline)
+            if (ef.func_code.co_argcount != 1 + ismethod):
+                raise YaccError, "%s:%d: p_error() requires 1 argument." % (efile, eline)
             global Errorfunc
             Errorfunc = ef
         else:
             print "yacc: Warning. no p_error() function is defined."
-            
+
         # Get the list of built-in functions with p_ prefix
-        symbols = [ldict[f] for f in ldict.keys()
-               if (type(ldict[f]) in (types.FunctionType, types.MethodType) and ldict[f].__name__[:2] == 'p_'
-                   and ldict[f].__name__ != 'p_error')]
+        symbols = [
+            ldict[f] for f in ldict.keys() if (
+                type(
+                    ldict[f]) in (
+                    types.FunctionType,
+                    types.MethodType) and ldict[f].__name__[
+                    :2] == 'p_' and ldict[f].__name__ != 'p_error')]
 
         # Check for non-empty symbols
         if len(symbols) == 0:
-            raise YaccError,"no rules of the form p_rulename are defined."
-    
+            raise YaccError, "no rules of the form p_rulename are defined."
+
         # Sort the symbols by line number
-        symbols.sort(lambda x,y: cmp(x.func_code.co_firstlineno,y.func_code.co_firstlineno))
+        symbols.sort(lambda x, y: cmp(x.func_code.co_firstlineno, y.func_code.co_firstlineno))
 
         # Add all of the symbols to the grammar
         for f in symbols:
@@ -2148,11 +2284,11 @@
         for f in symbols:
             if f.__doc__:
                 Signature.update(f.__doc__)
-    
+
         lr_init_vars()
 
         if error:
-            raise YaccError,"Unable to construct parser."
+            raise YaccError, "Unable to construct parser."
 
         if not lr_read_tables(tabmodule):
 
@@ -2164,39 +2300,43 @@
             # Validate dictionary
             validate_dict(ldict)
 
-            if start and not Prodnames.has_key(start):
-                raise YaccError,"Bad starting symbol '%s'" % start
-        
-            augment_grammar(start)    
+            if start and start not in Prodnames:
+                raise YaccError, "Bad starting symbol '%s'" % start
+
+            augment_grammar(start)
             error = verify_productions(cycle_check=check_recursion)
-            otherfunc = [ldict[f] for f in ldict.keys()
-               if (type(f) in (types.FunctionType,types.MethodType) and ldict[f].__name__[:2] != 'p_')]
+            otherfunc = [
+                ldict[f] for f in ldict.keys() if (
+                    type(f) in (
+                        types.FunctionType,
+                        types.MethodType) and ldict[f].__name__[
+                        :2] != 'p_')]
 
             if error:
-                raise YaccError,"Unable to construct parser."
-            
+                raise YaccError, "Unable to construct parser."
+
             build_lritems()
             compute_first1()
             compute_follow(start)
-        
-            if method in ['SLR','LALR']:
+
+            if method in ['SLR', 'LALR']:
                 lr_parse_table(method)
             else:
                 raise YaccError, "Unknown parsing method '%s'" % method
 
             if write_tables:
-                lr_write_tables(tabmodule,outputdir)        
-    
+                lr_write_tables(tabmodule, outputdir)
+
             if yaccdebug:
                 try:
-                    f = open(os.path.join(outputdir,debugfile),"w")
+                    f = open(os.path.join(outputdir, debugfile), "w")
                     f.write(_vfc.getvalue())
                     f.write("\n\n")
                     f.write(_vf.getvalue())
                     f.close()
                 except IOError as e:
-                    print "yacc: can't create '%s'" % debugfile,e
-        
+                    print "yacc: can't create '%s'" % debugfile, e
+
     # Made it here.   Create a parser object and set up its internal state.
     # Set global parse() method to bound method of parser object.
 
@@ -2204,7 +2344,7 @@
     g.productions = Productions
     g.errorfunc = Errorfunc
     g.action = _lr_action
-    g.goto   = _lr_goto
+    g.goto = _lr_goto
     g.method = _lr_method
     g.require = Requires
 
@@ -2220,7 +2360,10 @@
     return g
 
 # <ah> Allow multiple instances of parser
+
+
 class ParserPrototype(object):
+
     def __init__(self, magic=None):
         if magic != "xyzzy":
             raise YaccError, 'Use yacc()'
@@ -2231,7 +2374,7 @@
         parser.productions = self.productions
         parser.errorfunc = self.errorfunc
         parser.action = self.action
-        parser.goto   = self.goto
+        parser.goto = self.goto
         parser.method = self.method
         parser.require = self.require
         return parser
@@ -2239,23 +2382,23 @@
 # yacc_cleanup function.  Delete all of the global variables
 # used during table construction
 
+
 def yacc_cleanup():
     global _lr_action, _lr_goto, _lr_method, _lr_goto_cache
     del _lr_action, _lr_goto, _lr_method, _lr_goto_cache
 
-    global Productions, Prodnames, Prodmap, Terminals 
+    global Productions, Prodnames, Prodmap, Terminals
     global Nonterminals, First, Follow, Precedence, LRitems
     global Errorfunc, Signature, Requires
-    
+
     del Productions, Prodnames, Prodmap, Terminals
     del Nonterminals, First, Follow, Precedence, LRitems
     del Errorfunc, Signature, Requires
-    
+
     global _vf, _vfc
     del _vf, _vfc
-    
-    
+
+
 # Stub that raises an error if parsing is attempted without first calling yacc()
-def parse(*args,**kwargs):
+def parse(*args, **kwargs):
     raise YaccError, "yacc: No parser built with yacc()"
-

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/printer/__init__.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/printer/__init__.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/printer/__init__.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -7,4 +7,4 @@
 
 from printer import WrapperPrinter
 
-__all__ = ["WrapperPrinter"]
\ No newline at end of file
+__all__ = ["WrapperPrinter"]

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/printer/defaultheader.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/printer/defaultheader.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/printer/defaultheader.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -6,4 +6,4 @@
 Do not modify this file.
 '''
 
-__docformat__ =  'restructuredtext'
+__docformat__ = 'restructuredtext'

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/printer/preamble.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/printer/preamble.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/printer/preamble.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -1,4 +1,6 @@
-import ctypes, os, sys
+import ctypes
+import os
+import sys
 from ctypes import *
 
 _int_types = (c_int16, c_int32)
@@ -13,12 +15,14 @@
 del t
 del _int_types
 
+
 class c_void(Structure):
     # c_void_p is a buggy return type, converting to int, so
     # POINTER(None) == c_void_p is actually written as
     # POINTER(c_void), so it can be treated as a real pointer.
     _fields_ = [('dummy', c_int)]
 
+
 def POINTER(obj):
     p = ctypes.POINTER(obj)
 
@@ -34,7 +38,9 @@
 
     return p
 
+
 class UserString:
+
     def __init__(self, seq):
         if isinstance(seq, basestring):
             self.data = seq
@@ -42,12 +48,19 @@
             self.data = seq.data[:]
         else:
             self.data = str(seq)
+
     def __str__(self): return str(self.data)
+
     def __repr__(self): return repr(self.data)
+
     def __int__(self): return int(self.data)
+
     def __long__(self): return long(self.data)
+
     def __float__(self): return float(self.data)
+
     def __complex__(self): return complex(self.data)
+
     def __hash__(self): return hash(self.data)
 
     def __cmp__(self, string):
@@ -55,13 +68,17 @@
             return cmp(self.data, string.data)
         else:
             return cmp(self.data, string)
+
     def __contains__(self, char):
         return char in self.data
 
     def __len__(self): return len(self.data)
+
     def __getitem__(self, index): return self.__class__(self.data[index])
+
     def __getslice__(self, start, end):
-        start = max(start, 0); end = max(end, 0)
+        start = max(start, 0)
+        end = max(end, 0)
         return self.__class__(self.data[start:end])
 
     def __add__(self, other):
@@ -71,24 +88,30 @@
             return self.__class__(self.data + other)
         else:
             return self.__class__(self.data + str(other))
+
     def __radd__(self, other):
         if isinstance(other, basestring):
             return self.__class__(other + self.data)
         else:
             return self.__class__(str(other) + self.data)
+
     def __mul__(self, n):
-        return self.__class__(self.data*n)
+        return self.__class__(self.data * n)
     __rmul__ = __mul__
+
     def __mod__(self, args):
         return self.__class__(self.data % args)
 
     # the following methods are defined in alphabetical order:
     def capitalize(self): return self.__class__(self.data.capitalize())
+
     def center(self, width, *args):
         return self.__class__(self.data.center(width, *args))
-    def count(self, sub, start=0, end=sys.maxint):
+
+    def count(self, sub, start=0, end=sys.maxsize):
         return self.data.count(sub, start, end)
-    def decode(self, encoding=None, errors=None): # XXX improve this?
+
+    def decode(self, encoding=None, errors=None):  # XXX improve this?
         if encoding:
             if errors:
                 return self.__class__(self.data.decode(encoding, errors))
@@ -96,7 +119,8 @@
                 return self.__class__(self.data.decode(encoding))
         else:
             return self.__class__(self.data.decode())
-    def encode(self, encoding=None, errors=None): # XXX improve this?
+
+    def encode(self, encoding=None, errors=None):  # XXX improve this?
         if encoding:
             if errors:
                 return self.__class__(self.data.encode(encoding, errors))
@@ -104,56 +128,91 @@
                 return self.__class__(self.data.encode(encoding))
         else:
             return self.__class__(self.data.encode())
-    def endswith(self, suffix, start=0, end=sys.maxint):
+
+    def endswith(self, suffix, start=0, end=sys.maxsize):
         return self.data.endswith(suffix, start, end)
+
     def expandtabs(self, tabsize=8):
         return self.__class__(self.data.expandtabs(tabsize))
-    def find(self, sub, start=0, end=sys.maxint):
+
+    def find(self, sub, start=0, end=sys.maxsize):
         return self.data.find(sub, start, end)
-    def index(self, sub, start=0, end=sys.maxint):
+
+    def index(self, sub, start=0, end=sys.maxsize):
         return self.data.index(sub, start, end)
+
     def isalpha(self): return self.data.isalpha()
+
     def isalnum(self): return self.data.isalnum()
+
     def isdecimal(self): return self.data.isdecimal()
+
     def isdigit(self): return self.data.isdigit()
+
     def islower(self): return self.data.islower()
+
     def isnumeric(self): return self.data.isnumeric()
+
     def isspace(self): return self.data.isspace()
+
     def istitle(self): return self.data.istitle()
+
     def isupper(self): return self.data.isupper()
+
     def join(self, seq): return self.data.join(seq)
+
     def ljust(self, width, *args):
         return self.__class__(self.data.ljust(width, *args))
+
     def lower(self): return self.__class__(self.data.lower())
+
     def lstrip(self, chars=None): return self.__class__(self.data.lstrip(chars))
+
     def partition(self, sep):
         return self.data.partition(sep)
+
     def replace(self, old, new, maxsplit=-1):
         return self.__class__(self.data.replace(old, new, maxsplit))
-    def rfind(self, sub, start=0, end=sys.maxint):
+
+    def rfind(self, sub, start=0, end=sys.maxsize):
         return self.data.rfind(sub, start, end)
-    def rindex(self, sub, start=0, end=sys.maxint):
+
+    def rindex(self, sub, start=0, end=sys.maxsize):
         return self.data.rindex(sub, start, end)
+
     def rjust(self, width, *args):
         return self.__class__(self.data.rjust(width, *args))
+
     def rpartition(self, sep):
         return self.data.rpartition(sep)
+
     def rstrip(self, chars=None): return self.__class__(self.data.rstrip(chars))
+
     def split(self, sep=None, maxsplit=-1):
         return self.data.split(sep, maxsplit)
+
     def rsplit(self, sep=None, maxsplit=-1):
         return self.data.rsplit(sep, maxsplit)
+
     def splitlines(self, keepends=0): return self.data.splitlines(keepends)
-    def startswith(self, prefix, start=0, end=sys.maxint):
+
+    def startswith(self, prefix, start=0, end=sys.maxsize):
         return self.data.startswith(prefix, start, end)
+
     def strip(self, chars=None): return self.__class__(self.data.strip(chars))
+
     def swapcase(self): return self.__class__(self.data.swapcase())
+
     def title(self): return self.__class__(self.data.title())
+
     def translate(self, *args):
         return self.__class__(self.data.translate(*args))
+
     def upper(self): return self.__class__(self.data.upper())
+
     def zfill(self, width): return self.__class__(self.data.zfill(width))
 
+
 class MutableString(UserString):
     """mutable string objects
 
@@ -169,33 +228,45 @@
     errors that would be very hard to track down.
 
     A faster and better solution is to rewrite your program using lists."""
+
     def __init__(self, string=""):
         self.data = string
+
     def __hash__(self):
-        raise TypeError, "unhashable type (it is mutable)"
+        raise TypeError("unhashable type (it is mutable)")
+
     def __setitem__(self, index, sub):
         if index < 0:
             index += len(self.data)
-        if index < 0 or index >= len(self.data): raise IndexError
-        self.data = self.data[:index] + sub + self.data[index+1:]
+        if index < 0 or index >= len(self.data):
+            raise IndexError
+        self.data = self.data[:index] + sub + self.data[index + 1:]
+
     def __delitem__(self, index):
         if index < 0:
             index += len(self.data)
-        if index < 0 or index >= len(self.data): raise IndexError
-        self.data = self.data[:index] + self.data[index+1:]
+        if index < 0 or index >= len(self.data):
+            raise IndexError
+        self.data = self.data[:index] + self.data[index + 1:]
+
     def __setslice__(self, start, end, sub):
-        start = max(start, 0); end = max(end, 0)
+        start = max(start, 0)
+        end = max(end, 0)
         if isinstance(sub, UserString):
-            self.data = self.data[:start]+sub.data+self.data[end:]
+            self.data = self.data[:start] + sub.data + self.data[end:]
         elif isinstance(sub, basestring):
-            self.data = self.data[:start]+sub+self.data[end:]
+            self.data = self.data[:start] + sub + self.data[end:]
         else:
-            self.data =  self.data[:start]+str(sub)+self.data[end:]
+            self.data = self.data[:start] + str(sub) + self.data[end:]
+
     def __delslice__(self, start, end):
-        start = max(start, 0); end = max(end, 0)
+        start = max(start, 0)
+        end = max(end, 0)
         self.data = self.data[:start] + self.data[end:]
+
     def immutable(self):
         return UserString(self.data)
+
     def __iadd__(self, other):
         if isinstance(other, UserString):
             self.data += other.data
@@ -204,10 +275,12 @@
         else:
             self.data += str(other)
         return self
+
     def __imul__(self, n):
         self.data *= n
         return self
 
+
 class String(MutableString, Union):
 
     _fields_ = [('raw', POINTER(c_char)),
@@ -221,7 +294,7 @@
 
     def __len__(self):
         return self.data and len(self.data) or 0
-    
+
     def from_param(cls, obj):
         # Convert None or 0
         if obj is None or obj == 0:
@@ -234,15 +307,15 @@
         # Convert from str
         elif isinstance(obj, str):
             return cls(obj)
-        
+
         # Convert from c_char_p
         elif isinstance(obj, c_char_p):
             return obj
-        
+
         # Convert from POINTER(c_char)
         elif isinstance(obj, POINTER(c_char)):
             return obj
-        
+
         # Convert from raw pointer
         elif isinstance(obj, int):
             return cls(cast(obj, POINTER(c_char)))
@@ -252,6 +325,7 @@
             return String.from_param(obj._as_parameter_)
     from_param = classmethod(from_param)
 
+
 def ReturnString(obj):
     return String.from_param(obj)
 
@@ -262,29 +336,35 @@
 #
 # Non-primitive return values wrapped with UNCHECKED won't be
 # typechecked, and will be converted to c_void_p.
+
+
 def UNCHECKED(type):
     if (hasattr(type, "_type_") and isinstance(type._type_, str)
-        and type._type_ != "P"):
+            and type._type_ != "P"):
         return type
     else:
         return c_void_p
 
 # ctypes doesn't have direct support for variadic functions, so we have to write
 # our own wrapper class
+
+
 class _variadic_function(object):
-    def __init__(self,func,restype,argtypes):
-        self.func=func
-        self.func.restype=restype
-        self.argtypes=argtypes
+
+    def __init__(self, func, restype, argtypes):
+        self.func = func
+        self.func.restype = restype
+        self.argtypes = argtypes
+
     def _as_parameter_(self):
         # So we can pass this variadic function as a function pointer
         return self.func
-    def __call__(self,*args):
-        fixed_args=[]
-        i=0
+
+    def __call__(self, *args):
+        fixed_args = []
+        i = 0
         for argtype in self.argtypes:
             # Typecheck what we can
             fixed_args.append(argtype.from_param(args[i]))
-            i+=1
-        return self.func(*fixed_args+list(args[i:]))
-
+            i += 1
+        return self.func(*fixed_args + list(args[i:]))

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/printer/printer.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/printer/printer.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/printer/printer.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -1,40 +1,45 @@
 #!/usr/bin/env python
 
-import os, sys, time
+import os
+import sys
+import time
 from ctypesgencore.descriptions import *
 from ctypesgencore.ctypedescs import *
 from ctypesgencore.messages import *
 
-import ctypesgencore.libraryloader # So we can get the path to it
-import test # So we can find the path to local files in the printer package
+import ctypesgencore.libraryloader  # So we can get the path to it
+import test  # So we can find the path to local files in the printer package
 
-def path_to_local_file(name,known_local_module = test):
-    basedir=os.path.dirname(known_local_module.__file__)
-    return os.path.join(basedir,name)
 
+def path_to_local_file(name, known_local_module=test):
+    basedir = os.path.dirname(known_local_module.__file__)
+    return os.path.join(basedir, name)
+
+
 class WrapperPrinter:
-    def __init__(self,outpath,options,data):
+
+    def __init__(self, outpath, options, data):
         status_message("Writing to %s." % outpath)
-        
-        self.file=file(outpath,"w")
-        self.options=options
 
+        self.file = file(outpath, "w")
+        self.options = options
+
         if self.options.strip_build_path and \
-          self.options.strip_build_path[-1] != os.path.sep:
+                self.options.strip_build_path[-1] != os.path.sep:
             self.options.strip_build_path += os.path.sep
-        
+
         self.print_header()
         print >>self.file
-        
+
         self.print_preamble()
         print >>self.file
-        
+
         self.print_loader()
         print >>self.file
-                
-        self.print_group(self.options.libraries,"libraries",self.print_library)
-        self.print_group(self.options.modules,"modules",self.print_module)
-        
+
+        self.print_group(self.options.libraries, "libraries", self.print_library)
+        self.print_group(self.options.modules, "modules", self.print_module)
+
         method_table = {
             'function': self.print_function,
             'macro': self.print_macro,
@@ -45,89 +50,89 @@
             'enum': self.print_enum,
             'constant': self.print_constant
         }
-        
-        for kind,desc in data.output_order:
+
+        for kind, desc in data.output_order:
             if desc.included:
                 method_table[kind](desc)
                 print >>self.file
-        
-        self.print_group(self.options.inserted_files,"inserted files",
+
+        self.print_group(self.options.inserted_files, "inserted files",
                          self.insert_file)
-    
-    def print_group(self,list,name,function):
+
+    def print_group(self, list, name, function):
         if list:
-            print >>self.file,"# Begin %s" % name
+            print >>self.file, "# Begin %s" % name
             print >>self.file
             for obj in list:
                 function(obj)
             print >>self.file
-            print >>self.file,"# %d %s" % (len(list),name)
-            print >>self.file,"# End %s" % name
+            print >>self.file, "# %d %s" % (len(list), name)
+            print >>self.file, "# End %s" % name
         else:
-            print >>self.file,"# No %s" % name
+            print >>self.file, "# No %s" % name
         print >>self.file
-    
-    def srcinfo(self,src):
-        if src==None:
+
+    def srcinfo(self, src):
+        if src is None:
             print >>self.file
         else:
-            filename,lineno = src
-            if filename in ("<built-in>","<command line>"):
+            filename, lineno = src
+            if filename in ("<built-in>", "<command line>"):
                 print >>self.file, "# %s" % filename
             else:
                 if self.options.strip_build_path and \
-                  filename.startswith(self.options.strip_build_path):
+                        filename.startswith(self.options.strip_build_path):
                     filename = filename[len(self.options.strip_build_path):]
                 print >>self.file, "# %s: %s" % (filename, lineno)
-    
+
     def template_subs(self):
-        template_subs={
+        template_subs = {
             'date': time.ctime(),
             'argv': ' '.join([x for x in sys.argv if not x.startswith("--strip-build-path")]),
             'name': os.path.basename(self.options.headers[0])
         }
-        
-        for opt,value in self.options.__dict__.iteritems():
-            if type(value)==str:
-                template_subs[opt]=value
-            elif isinstance(value,(list,tuple)):
-                template_subs[opt]=(os.path.sep).join(value)
+
+        for opt, value in self.options.__dict__.iteritems():
+            if isinstance(value, str):
+                template_subs[opt] = value
+            elif isinstance(value, (list, tuple)):
+                template_subs[opt] = (os.path.sep).join(value)
             else:
-                template_subs[opt]=repr(value)
-        
+                template_subs[opt] = repr(value)
+
         return template_subs
-    
+
     def print_header(self):
         template_file = None
-        
+
         if self.options.header_template:
             path = self.options.header_template
             try:
-                template_file = file(path,"r")
+                template_file = file(path, "r")
             except IOError:
-                error_message("Cannot load header template from file \"%s\" " \
-                    " - using default template." % path, cls = 'missing-file')
-        
+                error_message("Cannot load header template from file \"%s\" "
+                              " - using default template." % path, cls='missing-file')
+
         if not template_file:
             path = path_to_local_file("defaultheader.py")
-            template_file = file(path,"r")
-        
-        template_subs=self.template_subs()
+            template_file = file(path, "r")
+
+        template_subs = self.template_subs()
         self.file.write(template_file.read() % template_subs)
-        
+
         template_file.close()
-    
+
     def print_preamble(self):
         path = path_to_local_file("preamble.py")
-        
+
         print >>self.file, "# Begin preamble"
         print >>self.file
-        preamble_file=file(path,"r")
+        preamble_file = file(path, "r")
         self.file.write(preamble_file.read())
         preamble_file.close()
         print >>self.file
         print >>self.file, "# End preamble"
-    
+
     def print_loader(self):
         print >>self.file, "_libs = {}"
         print >>self.file, "_libdirs = %s" % self.options.compile_libdirs
@@ -135,92 +140,95 @@
         print >>self.file, "# Begin loader"
         print >>self.file
         path = path_to_local_file("libraryloader.py",
-                                      ctypesgencore.libraryloader)
-        loader_file=file(path,"r")
+                                  ctypesgencore.libraryloader)
+        loader_file = file(path, "r")
         self.file.write(loader_file.read())
         loader_file.close()
         print >>self.file
         print >>self.file, "# End loader"
         print >>self.file
         print >>self.file, "add_library_search_dirs([%s])" % \
-                ", ".join([repr(d) for d in self.options.runtime_libdirs])
-    
-    def print_library(self,library):
-        print >>self.file, '_libs["%s"] = load_library("%s")'%(library,library)
-    
-    def print_module(self,module):
+            ", ".join([repr(d) for d in self.options.runtime_libdirs])
+
+    def print_library(self, library):
+        print >>self.file, '_libs["%s"] = load_library("%s")' % (library, library)
+
+    def print_module(self, module):
         print >>self.file, 'from %s import *' % name
-    
-    def print_constant(self,constant):
+
+    def print_constant(self, constant):
         print >>self.file, '%s = %s' % \
-            (constant.name,constant.value.py_string(False)),
+            (constant.name, constant.value.py_string(False)),
         self.srcinfo(constant.src)
-    
-    def print_typedef(self,typedef):
+
+    def print_typedef(self, typedef):
         print >>self.file, '%s = %s' % \
-            (typedef.name,typedef.ctype.py_string()),
+            (typedef.name, typedef.ctype.py_string()),
         self.srcinfo(typedef.src)
-    
+
     def print_struct(self, struct):
         self.srcinfo(struct.src)
         base = {'union': 'Union', 'struct': 'Structure'}[struct.variety]
         print >>self.file, 'class %s_%s(%s):' % \
             (struct.variety, struct.tag, base)
         print >>self.file, '    pass'
-    
+
     def print_struct_members(self, struct):
-        if struct.opaque: return
+        if struct.opaque:
+            return
         print >>self.file, '%s_%s.__slots__ = [' % (struct.variety, struct.tag)
-        for name,ctype in struct.members:
+        for name, ctype in struct.members:
             print >>self.file, "    '%s'," % name
         print >>self.file, ']'
         print >>self.file, '%s_%s._fields_ = [' % (struct.variety, struct.tag)
-        for name,ctype in struct.members:
-            if isinstance(ctype,CtypesBitfield):
+        for name, ctype in struct.members:
+            if isinstance(ctype, CtypesBitfield):
                 print >>self.file, "    ('%s', %s, %s)," % \
                     (name, ctype.py_string(), ctype.bitfield.py_string(False))
             else:
                 print >>self.file, "    ('%s', %s)," % (name, ctype.py_string())
         print >>self.file, ']'
-    
-    def print_enum(self,enum):
+
+    def print_enum(self, enum):
         print >>self.file, 'enum_%s = c_int' % enum.tag,
         self.srcinfo(enum.src)
         # Values of enumerator are output as constants.
-    
+
     def print_function(self, function):
         if function.variadic:
             self.print_variadic_function(function)
         else:
             self.print_fixed_function(function)
-    
+
     def print_fixed_function(self, function):
         self.srcinfo(function.src)
         if function.source_library:
             print >>self.file, "if hasattr(_libs[%r], %r):" % \
-                (function.source_library,function.c_name())
+                (function.source_library, function.c_name())
             print >>self.file, "    %s = _libs[%r].%s" % \
-                (function.py_name(),function.source_library,function.c_name())
+                (function.py_name(), function.source_library, function.c_name())
             print >>self.file, "    %s.restype = %s" % \
-                (function.py_name(),function.restype.py_string())
-            print >>self.file, "    %s.argtypes = [%s]" % (function.py_name(),
+                (function.py_name(), function.restype.py_string())
+            print >>self.file, "    %s.argtypes = [%s]" % (
+                function.py_name(),
                 ', '.join([a.py_string() for a in function.argtypes]))
         else:
             print >>self.file, "for _lib in _libs.values():"
             print >>self.file, "    if hasattr(_lib, %r):" % function.c_name()
-            print >>self.file, "        %s = _lib.%s" % (function.py_name(),function.c_name())
-            print >>self.file, "        %s.restype = %s" % (function.py_name(),function.restype.py_string())
-            print >>self.file, "        %s.argtypes = [%s]" % (function.py_name(),
-                ', '.join([a.py_string() for a in function.argtypes]))
+            print >>self.file, "        %s = _lib.%s" % (function.py_name(), function.c_name())
+            print >>self.file, "        %s.restype = %s" % (
+                function.py_name(), function.restype.py_string())
+            print >>self.file, "        %s.argtypes = [%s]" % (
+                function.py_name(), ', '.join([a.py_string() for a in function.argtypes]))
             print >>self.file, "        break"
-    
-    def print_variadic_function(self,function):
+
+    def print_variadic_function(self, function):
         self.srcinfo(function.src)
         if function.source_library:
             print >>self.file, "if hasattr(_libs[%r], %r):" % \
-                (function.source_library,function.c_name())
+                (function.source_library, function.c_name())
             print >>self.file, "    _func = _libs[%r].%s" % \
-                (function.source_library,function.c_name())
+                (function.source_library, function.c_name())
             print >>self.file, "    _restype = %s" % function.restype.py_string()
             print >>self.file, "    _argtypes = [%s]" % \
                 ', '.join([a.py_string() for a in function.argtypes])
@@ -237,7 +245,6 @@
             print >>self.file, "        %s = _variadic_function(_func,_restype,_argtypes)" % \
                 function.py_name()
 
-    
     def print_variable(self, variable):
         self.srcinfo(variable.src)
         if variable.source_library:
@@ -259,40 +266,40 @@
             print >>self.file, "        break"
             print >>self.file, '    except:'
             print >>self.file, '        pass'
-    
+
     def print_macro(self, macro):
         if macro.params:
             self.print_func_macro(macro)
         else:
             self.print_simple_macro(macro)
-    
+
     def print_simple_macro(self, macro):
         # The macro translator makes heroic efforts but it occasionally fails.
         # We want to contain the failures as much as possible.
         # Hence the try statement.
         self.srcinfo(macro.src)
         print >>self.file, "try:"
-        print >>self.file, "    %s = %s" % (macro.name,macro.expr.py_string(True))
+        print >>self.file, "    %s = %s" % (macro.name, macro.expr.py_string(True))
         print >>self.file, "except:"
         print >>self.file, "    pass"
-    
+
     def print_func_macro(self, macro):
         self.srcinfo(macro.src)
         print >>self.file, "def %s(%s):" % \
-            (macro.name,", ".join(macro.params))
+            (macro.name, ", ".join(macro.params))
         print >>self.file, "    return %s" % macro.expr.py_string(True)
-    
-    def insert_file(self,filename):
+
+    def insert_file(self, filename):
         try:
-            inserted_file = file(filename,"r")
+            inserted_file = file(filename, "r")
         except IOError:
             error_message("Cannot open file \"%s\". Skipped it." % filename,
-                          cls = 'missing-file')
-        
-        print >>self.file,"# Begin \"%s\"" % filename
+                          cls='missing-file')
+
+        print >>self.file, "# Begin \"%s\"" % filename
         print >>self.file
         self.file.write(inserted_file.read())
         print >>self.file
-        print >>self.file,"# End \"%s\"" % filename
-              
+        print >>self.file, "# End \"%s\"" % filename
+
         inserted_file.close()

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/printer/test.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/printer/test.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/printer/test.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -3,4 +3,4 @@
 to defaulttemplate.py and defaultloader.py.
 """
 
-pass
\ No newline at end of file
+pass

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/processor/__init__.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/processor/__init__.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/processor/__init__.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -9,4 +9,4 @@
 
 __all__ = ["process"]
 
-from pipeline import process
\ No newline at end of file
+from pipeline import process

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/processor/dependencies.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/processor/dependencies.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/processor/dependencies.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -9,58 +9,69 @@
 from ctypesgencore.ctypedescs import *
 from ctypesgencore.messages import *
 
+
 def find_dependencies(data, opts):
     """Visit each description in `data` and figure out which other descriptions
 it depends on, putting the results in desc.requirements. Also find errors in
 ctypedecls or expressions attached to the description and transfer them to the
 description."""
-    
+
     struct_names = {}
     enum_names = {}
     typedef_names = {}
     ident_names = {}
-    
+
     # Start the lookup tables with names from imported modules
-    
+
     for name in opts.other_known_names:
         typedef_names[name] = None
         ident_names[name] = None
         if name.startswith("struct_") or name.startswith("enum_"):
             variety = name.split("_")[0]
             tag = "_".join(name.split("_")[1:])
-            struct_names[(variety,tag)] = None
+            struct_names[(variety, tag)] = None
         if name.startswith("enum_"):
             enum_names[name] = None
-    
+
     def depend(desc, nametable, name):
         """Try to add `name` as a requirement for `desc`, looking `name` up in
 `nametable`. Returns True if found."""
 
         if name in nametable:
             requirement = nametable[name]
-            if requirement: desc.add_requirements([requirement])
+            if requirement:
+                desc.add_requirements([requirement])
             return True
         else:
             return False
-    
+
     def find_dependencies_for(desc, kind):
         """Find all the descriptions that `desc` depends on and add them as
-dependencies for `desc`. Also collect error messages regarding `desc` and 
+dependencies for `desc`. Also collect error messages regarding `desc` and
 convert unlocateable descriptions into error messages."""
 
-        if kind == "constant": roots = [desc.value]
-        if kind == "struct": roots = []
-        if kind == "struct-body": roots = [desc.ctype]
-        if kind == "enum": roots = []
-        if kind == "typedef": roots = [desc.ctype]
-        if kind == "function": roots = desc.argtypes + [desc.restype]
-        if kind == "variable": roots = [desc.ctype]
+        if kind == "constant":
+            roots = [desc.value]
+        if kind == "struct":
+            roots = []
+        if kind == "struct-body":
+            roots = [desc.ctype]
+        if kind == "enum":
+            roots = []
+        if kind == "typedef":
+            roots = [desc.ctype]
+        if kind == "function":
+            roots = desc.argtypes + [desc.restype]
+        if kind == "variable":
+            roots = [desc.ctype]
         if kind == "macro":
-            if desc.expr: roots = [desc.expr]
-            else: roots = []
-        
-        cstructs,cenums,ctypedefs,errors,identifiers = [], [], [], [], []
-        
+            if desc.expr:
+                roots = [desc.expr]
+            else:
+                roots = []
+
+        cstructs, cenums, ctypedefs, errors, identifiers = [], [], [], [], []
+
         for root in roots:
             s, e, t, errs, i = visit_type_and_collect_info(root)
             cstructs.extend(s)
@@ -68,42 +79,42 @@
             ctypedefs.extend(t)
             errors.extend(errs)
             identifiers.extend(i)
-        
+
         unresolvables = []
-        
+
         for cstruct in cstructs:
             if kind == "struct" and desc.variety == cstruct.variety and \
-                desc.tag == cstruct.tag:
+                    desc.tag == cstruct.tag:
                 continue
             if not depend(desc, struct_names, (cstruct.variety, cstruct.tag)):
-                unresolvables.append("%s \"%s\"" % \
-                    (cstruct.variety, cstruct.tag))
-        
+                unresolvables.append("%s \"%s\"" %
+                                     (cstruct.variety, cstruct.tag))
+
         for cenum in cenums:
             if kind == "enum" and desc.tag == cenum.tag:
                 continue
             if not depend(desc, enum_names, cenum.tag):
                 unresolvables.append("enum \"%s\"" % cenum.tag)
-        
+
         for ctypedef in ctypedefs:
             if not depend(desc, typedef_names, ctypedef):
                 unresolvables.append("typedef \"%s\"" % ctypedef)
-        
+
         for ident in identifiers:
             if isinstance(desc, MacroDescription) and \
-                desc.params and ident in desc.params:
+                    desc.params and ident in desc.params:
                 continue
             if not depend(desc, ident_names, ident):
                 unresolvables.append("identifier \"%s\"" % ident)
-        
+
         for u in unresolvables:
-            errors.append(("%s depends on an unknown %s." % \
-                          (desc.casual_name(), u), None))
-        
+            errors.append(("%s depends on an unknown %s." %
+                           (desc.casual_name(), u), None))
+
         for err, cls in errors:
             err += " %s will not be output" % desc.casual_name()
-            desc.error(err, cls = cls)
-        
+            desc.error(err, cls=cls)
+
     def add_to_lookup_table(desc, kind):
         """Add `desc` to the lookup table so that other descriptions that use
 it can find it."""
@@ -125,13 +136,13 @@
     # no other type of description can look ahead like that.
 
     for kind, desc in data.output_order:
-        if kind!="macro":
+        if kind != "macro":
             find_dependencies_for(desc, kind)
             add_to_lookup_table(desc, kind)
 
     for kind, desc in data.output_order:
-        if kind=="macro":
+        if kind == "macro":
             add_to_lookup_table(desc, kind)
     for kind, desc in data.output_order:
-        if kind=="macro":
+        if kind == "macro":
             find_dependencies_for(desc, kind)

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/processor/operations.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/processor/operations.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/processor/operations.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -6,195 +6,208 @@
 ctypesgencore.processor.pipeline calls the operations module.
 """
 
-import ctypes, re, os, sys, keyword
+import ctypes
+import re
+import os
+import sys
+import keyword
 from ctypesgencore.descriptions import *
 from ctypesgencore.messages import *
 import ctypesgencore.libraryloader
 
 # Processor functions
 
-def automatically_typedef_structs(data,options):
+
+def automatically_typedef_structs(data, options):
     """automatically_typedef_structs() aliases "struct_<tag>" to "<tag>" for
     every struct and union."""
     # XXX Check if it has already been aliased in the C code.
-    
+
     for struct in data.structs:
-        if not struct.ctype.anonymous: # Don't alias anonymous structs
-            typedef=TypedefDescription(struct.tag,
-                                       struct.ctype,
-                                       src=struct.src)
+        if not struct.ctype.anonymous:  # Don't alias anonymous structs
+            typedef = TypedefDescription(struct.tag,
+                                         struct.ctype,
+                                         src=struct.src)
             typedef.add_requirements(set([struct]))
-            
+
             data.typedefs.append(typedef)
-            data.all.insert(data.all.index(struct)+1,typedef)
+            data.all.insert(data.all.index(struct) + 1, typedef)
             data.output_order.append(("typedef", typedef))
 
+
 def remove_NULL(data, options):
     """remove_NULL() removes any NULL definitions from the C headers because
 ctypesgen supplies its own NULL definition."""
-    
+
     for macro in data.macros:
-        if macro.name=="NULL":
+        if macro.name == "NULL":
             macro.include_rule = "never"
 
-def remove_descriptions_in_system_headers(data,opts):
+
+def remove_descriptions_in_system_headers(data, opts):
     """remove_descriptions_in_system_headers() removes descriptions if they came
     from files outside of the header files specified from the command line."""
-    
+
     known_headers = [os.path.basename(x) for x in opts.headers]
-    
+
     for description in data.all:
-        if description.src!=None:
+        if description.src is not None:
             if description.src[0] == "<command line>":
                 description.include_rule = "if_needed"
             elif description.src[0] == "<built-in>":
                 if not opts.builtin_symbols:
-                    description.include_rule="if_needed"
+                    description.include_rule = "if_needed"
             elif os.path.basename(description.src[0]) not in known_headers:
                 if not opts.all_headers:
                     # If something else requires this, include it even though
                     # it is in a system header file.
-                    description.include_rule="if_needed"
+                    description.include_rule = "if_needed"
 
-def remove_macros(data,opts):
+
+def remove_macros(data, opts):
     """remove_macros() removes macros if --no-macros is set."""
     if not opts.include_macros:
         for macro in data.macros:
             macro.include_rule = "never"
 
-def filter_by_regexes_exclude(data,opts):
+
+def filter_by_regexes_exclude(data, opts):
     """filter_by_regexes_exclude() uses regular expressions specified by options
     dictionary to filter symbols."""
     if opts.exclude_symbols:
-        expr=re.compile(opts.exclude_symbols)
+        expr = re.compile(opts.exclude_symbols)
         for object in data.all:
             if expr.match(object.py_name()):
-                object.include_rule="never"
+                object.include_rule = "never"
 
-def filter_by_regexes_include(data,opts):
+
+def filter_by_regexes_include(data, opts):
     """filter_by_regexes_include() uses regular expressions specified by options
     dictionary to re-include symbols previously rejected by other operations."""
     if opts.include_symbols:
-        expr=re.compile(opts.include_symbols)
+        expr = re.compile(opts.include_symbols)
         for object in data.all:
-            if object.include_rule!="never":
+            if object.include_rule != "never":
                 if expr.match(object.py_name()):
-                    object.include_rule="yes"
+                    object.include_rule = "yes"
 
-def fix_conflicting_names(data,opts):
+
+def fix_conflicting_names(data, opts):
     """If any descriptions from the C code would overwrite Python builtins or
     other important names, fix_conflicting_names() adds underscores to resolve
     the name conflict."""
-    
+
     # This is the order of priority for names
     descriptions = data.functions + data.variables + data.structs + \
         data.typedefs + data.enums + data.constants + data.macros
-    
+
     # This dictionary maps names to a string representing where the name
     # came from.
-    important_names={}
-    
-    preamble_names=set()
-    preamble_names=preamble_names.union(['DarwinLibraryLoader',
-        'LibraryLoader', 'LinuxLibraryLoader', 'WindowsLibraryLoader',
-        '_WindowsLibrary', 'add_library_search_dirs', '_environ_path', 'ctypes',
-        'load_library', 'loader', 'os', 're', 'sys'])
-    preamble_names=preamble_names.union(['ArgumentError', 'CFUNCTYPE',
-        'POINTER', 'ReturnString', 'String', 'Structure', 'UNCHECKED', 'Union',
-        'UserString', '_variadic_function', 'addressof', 'c_buffer', 'c_byte',
-        'c_char', 'c_char_p', 'c_double', 'c_float', 'c_int', 'c_int16',
-        'c_int32', 'c_int64', 'c_int8', 'c_long', 'c_longlong', 'c_ptrdiff_t',
-        'c_short', 'c_size_t', 'c_ubyte', 'c_uint', 'c_uint16', 'c_uint32',
-        'c_uint64', 'c_uint8', 'c_ulong', 'c_ulonglong', 'c_ushort', 'c_void',
-        'c_void_p', 'c_voidp', 'c_wchar', 'c_wchar_p', 'cast', 'ctypes', 'os',
-        'pointer', 'sizeof'])
+    important_names = {}
+
+    preamble_names = set()
+    preamble_names = preamble_names.union(
+        ['DarwinLibraryLoader', 'LibraryLoader', 'LinuxLibraryLoader', 'WindowsLibraryLoader',
+         '_WindowsLibrary', 'add_library_search_dirs', '_environ_path', 'ctypes', 'load_library',
+         'loader', 'os', 're', 'sys'])
+    preamble_names = preamble_names.union(
+        ['ArgumentError', 'CFUNCTYPE', 'POINTER', 'ReturnString', 'String', 'Structure',
+         'UNCHECKED', 'Union', 'UserString', '_variadic_function', 'addressof', 'c_buffer',
+         'c_byte', 'c_char', 'c_char_p', 'c_double', 'c_float', 'c_int', 'c_int16', 'c_int32',
+         'c_int64', 'c_int8', 'c_long', 'c_longlong', 'c_ptrdiff_t', 'c_short', 'c_size_t',
+         'c_ubyte', 'c_uint', 'c_uint16', 'c_uint32', 'c_uint64', 'c_uint8', 'c_ulong',
+         'c_ulonglong', 'c_ushort', 'c_void', 'c_void_p', 'c_voidp', 'c_wchar', 'c_wchar_p', 'cast',
+         'ctypes', 'os', 'pointer', 'sizeof'])
     for name in preamble_names:
         important_names[name] = "a name needed by ctypes or ctypesgen"
-    for name in dir(__builtins__): important_names[name] = "a Python builtin"
+    for name in dir(__builtins__):
+        important_names[name] = "a Python builtin"
     for name in opts.other_known_names:
         important_names[name] = "a name from an included Python module"
-    for name in keyword.kwlist: important_names[name] = "a Python keyword"
-    
+    for name in keyword.kwlist:
+        important_names[name] = "a Python keyword"
+
     for description in descriptions:
         if description.py_name() in important_names:
             conflict_name = important_names[description.py_name()]
-            
-            original_name=description.casual_name()
+
+            original_name = description.casual_name()
             while description.py_name() in important_names:
                 if isinstance(description,
-                                (StructDescription, EnumDescription)):
-                    description.tag+="_"
+                              (StructDescription, EnumDescription)):
+                    description.tag += "_"
                 else:
-                    description.name="_"+description.name
-            
+                    description.name = "_" + description.name
+
             if not description.dependents:
-                description.warning("%s has been renamed to %s due to a name " \
-                    "conflict with %s." % \
-                    (original_name,
-                    description.casual_name(),
-                    conflict_name),
-                    cls = 'rename')
+                description.warning("%s has been renamed to %s due to a name "
+                                    "conflict with %s." %
+                                    (original_name,
+                                     description.casual_name(),
+                                     conflict_name),
+                                    cls='rename')
             else:
-                description.warning("%s has been renamed to %s due to a name " \
-                    "conflict with %s. Other objects depend on %s - those " \
-                    "objects will be skipped." % \
-                    (original_name, description.casual_name(),
-                    conflict_name, original_name),
-                    cls = 'rename')
-                
+                description.warning("%s has been renamed to %s due to a name "
+                                    "conflict with %s. Other objects depend on %s - those "
+                                    "objects will be skipped." %
+                                    (original_name, description.casual_name(),
+                                     conflict_name, original_name),
+                                    cls='rename')
+
                 for dependent in description.dependents:
                     dependent.include_rule = "never"
-            
-            if description.include_rule=="yes":
+
+            if description.include_rule == "yes":
                 important_names[description.py_name()] = \
                     description.casual_name()
-    
+
     # Names of struct members don't conflict with much, but they can conflict
     # with Python keywords.
-    
+
     for struct in data.structs:
         if not struct.opaque:
-            for i,(name,type) in enumerate(struct.members):
+            for i, (name, type) in enumerate(struct.members):
                 if name in keyword.kwlist:
-                    struct.members[i] = ("_"+name,type)
-                    struct.warning("Member \"%s\" of %s has been renamed to " \
-                        "\"%s\" because it has the same name as a Python " \
-                        "keyword." % (name, struct.casual_name(), "_"+name),
-                        cls = 'rename')
-    
+                    struct.members[i] = ("_" + name, type)
+                    struct.warning("Member \"%s\" of %s has been renamed to "
+                                   "\"%s\" because it has the same name as a Python "
+                                   "keyword." % (name, struct.casual_name(), "_" + name),
+                                   cls='rename')
+
     # Macro arguments may be have names that conflict with Python keywords.
     # In a perfect world, this would simply rename the parameter instead
     # of throwing an error message.
-    
+
     for macro in data.macros:
         if macro.params:
             for param in macro.params:
                 if param in keyword.kwlist:
-                    macro.error("One of the parameters to %s, \"%s\" has the " \
-                        "same name as a Python keyword. %s will be skipped." % \
-                        (macro.casual_name(), param, macro.casual_name()),
-                        cls = 'name-conflict')
+                    macro.error("One of the parameters to %s, \"%s\" has the "
+                                "same name as a Python keyword. %s will be skipped." %
+                                (macro.casual_name(), param, macro.casual_name()),
+                                cls='name-conflict')
 
-def find_source_libraries(data,opts):
+
+def find_source_libraries(data, opts):
     """find_source_libraries() determines which library contains each function
     and variable."""
-    
-    all_symbols=data.functions+data.variables
-    
+
+    all_symbols = data.functions + data.variables
+
     for symbol in all_symbols:
-        symbol.source_library=None
-    
+        symbol.source_library = None
+
     ctypesgencore.libraryloader.add_library_search_dirs(opts.compile_libdirs)
-    
+
     for library_name in opts.libraries:
         try:
-            library=ctypesgencore.libraryloader.load_library(library_name)
+            library = ctypesgencore.libraryloader.load_library(library_name)
         except ImportError as e:
-            warning_message("Could not load library \"%s\". Okay, I'll " \
-                "try to load it at runtime instead. " % (library_name),
-                cls = 'missing-library')
+            warning_message("Could not load library \"%s\". Okay, I'll "
+                            "try to load it at runtime instead. " % (library_name),
+                            cls='missing-library')
             continue
         for symbol in all_symbols:
-            if symbol.source_library==None:
-                if hasattr(library,symbol.c_name()):
-                    symbol.source_library=library_name
+            if symbol.source_library is None:
+                if hasattr(library, symbol.c_name()):
+                    symbol.source_library = library_name

Modified: grass/trunk/lib/python/ctypes/ctypesgencore/processor/pipeline.py
===================================================================
--- grass/trunk/lib/python/ctypes/ctypesgencore/processor/pipeline.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/ctypesgencore/processor/pipeline.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -1,6 +1,8 @@
 #!/usr/bin/env python
 
-import ctypes, re, os
+import ctypes
+import re
+import os
 from ctypesgencore.processor.operations import *
 from ctypesgencore.processor.dependencies import find_dependencies
 from ctypesgencore.ctypedescs import *
@@ -38,25 +40,27 @@
 
 """
 
-def process(data,options):
+
+def process(data, options):
     status_message("Processing description list.")
-    
-    find_dependencies(data,options)
-    
-    automatically_typedef_structs(data,options)
+
+    find_dependencies(data, options)
+
+    automatically_typedef_structs(data, options)
     remove_NULL(data, options)
-    remove_descriptions_in_system_headers(data,options)
-    filter_by_regexes_exclude(data,options)
-    filter_by_regexes_include(data,options)
-    remove_macros(data,options)
-    fix_conflicting_names(data,options)
-    find_source_libraries(data,options)
-        
-    calculate_final_inclusion(data,options)
-    print_errors_encountered(data,options)
-    calculate_final_inclusion(data,options)
+    remove_descriptions_in_system_headers(data, options)
+    filter_by_regexes_exclude(data, options)
+    filter_by_regexes_include(data, options)
+    remove_macros(data, options)
+    fix_conflicting_names(data, options)
+    find_source_libraries(data, options)
 
-def calculate_final_inclusion(data,opts):
+    calculate_final_inclusion(data, options)
+    print_errors_encountered(data, options)
+    calculate_final_inclusion(data, options)
+
+
+def calculate_final_inclusion(data, opts):
     """calculate_final_inclusion() calculates which descriptions will be included in the
     output library.
 
@@ -66,69 +70,69 @@
     An object with include_rule="if_needed" is included if an object to be
         included requires it and if its requirements can be included.
     """
-    
+
     def can_include_desc(desc):
-        if desc.can_include==None:
-            if desc.include_rule=="no":
-                desc.can_include=False
-            elif desc.include_rule=="yes" or desc.include_rule=="if_needed":
-                desc.can_include=True
+        if desc.can_include is None:
+            if desc.include_rule == "no":
+                desc.can_include = False
+            elif desc.include_rule == "yes" or desc.include_rule == "if_needed":
+                desc.can_include = True
                 for req in desc.requirements:
                     if not can_include_desc(req):
-                        desc.can_include=False
+                        desc.can_include = False
         return desc.can_include
-        
+
     def do_include_desc(desc):
         if desc.included:
-            return # We've already been here
+            return  # We've already been here
         desc.included = True
         for req in desc.requirements:
             do_include_desc(req)
-    
+
     for desc in data.all:
-        desc.can_include=None # None means "Not Yet Decided"
-        desc.included=False
-        
+        desc.can_include = None  # None means "Not Yet Decided"
+        desc.included = False
+
     for desc in data.all:
-        if desc.include_rule=="yes":
+        if desc.include_rule == "yes":
             if can_include_desc(desc):
                 do_include_desc(desc)
 
-def print_errors_encountered(data,opts):
+
+def print_errors_encountered(data, opts):
     # See descriptions.py for an explanation of the error-handling mechanism
     for desc in data.all:
         # If description would not have been included, dont bother user by
         # printing warnings.
         if desc.included or opts.show_all_errors:
-            if opts.show_long_errors or len(desc.errors)+len(desc.warnings)<=2:
-                for (error,cls) in desc.errors:
+            if opts.show_long_errors or len(desc.errors) + len(desc.warnings) <= 2:
+                for (error, cls) in desc.errors:
                     # Macro errors will always be displayed as warnings.
                     if isinstance(desc, MacroDescription):
                         if opts.show_macro_warnings:
-                            warning_message(error,cls)
+                            warning_message(error, cls)
                     else:
-                        error_message(error,cls)
-                for (warning,cls) in desc.warnings:
-                    warning_message(warning,cls)
-            
+                        error_message(error, cls)
+                for (warning, cls) in desc.warnings:
+                    warning_message(warning, cls)
+
             else:
                 if desc.errors:
-                    error1,cls1 = desc.errors[0]
-                    error_message(error1,cls1)
-                    numerrs = len(desc.errors)-1
+                    error1, cls1 = desc.errors[0]
+                    error_message(error1, cls1)
+                    numerrs = len(desc.errors) - 1
                     numwarns = len(desc.warnings)
                     if numwarns:
-                        error_message("%d more errors and %d more warnings " \
-                            "for %s" % (numerrs,numwarns,desc.casual_name()))
+                        error_message("%d more errors and %d more warnings "
+                                      "for %s" % (numerrs, numwarns, desc.casual_name()))
                     else:
-                        error_message("%d more errors for %s " % \
-                            (numerrs,desc.casual_name()))
+                        error_message("%d more errors for %s " %
+                                      (numerrs, desc.casual_name()))
                 else:
-                    warning1,cls1 = desc.warnings[0]
-                    warning_message(warning1,cls1)
-                    warning_message("%d more errors for %s" % \
-                        (len(desc.warnings)-1, desc.casual_name()))
+                    warning1, cls1 = desc.warnings[0]
+                    warning_message(warning1, cls1)
+                    warning_message("%d more errors for %s" %
+                                    (len(desc.warnings) - 1, desc.casual_name()))
         if desc.errors:
             # process() will recalculate to take this into account
             desc.include_rule = "never"
-

Modified: grass/trunk/lib/python/ctypes/fix.sed
===================================================================
--- grass/trunk/lib/python/ctypes/fix.sed	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/fix.sed	2016-05-02 16:06:24 UTC (rev 68348)
@@ -1,7 +1,7 @@
 #!/usr/bin/sed -f
 /^# End loader$/a\
-from ctypes_preamble import *\
-from ctypes_preamble import _variadic_function\
-from ctypes_loader import *
+from .ctypes_preamble import *\
+from .ctypes_preamble import _variadic_function\
+from .ctypes_loader import *
 /^# Begin preamble$/,/^# End preamble$/d
 /^# Begin loader$/,/^# End loader$/d

Modified: grass/trunk/lib/python/ctypes/loader.py
===================================================================
--- grass/trunk/lib/python/ctypes/loader.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/loader.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -2,14 +2,14 @@
 # Copyright (c) 2008 David James
 # Copyright (c) 2006-2008 Alex Holkner
 # All rights reserved.
-# 
+#
 # Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions 
+# modification, are permitted provided that the following conditions
 # are met:
 #
 #  * Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
-#  * Redistributions in binary form must reproduce the above copyright 
+#  * Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in
 #    the documentation and/or other materials provided with the
 #    distribution.
@@ -32,31 +32,38 @@
 # POSSIBILITY OF SUCH DAMAGE.
 # ----------------------------------------------------------------------------
 
-import os.path, re, sys, glob
+import glob
+import os.path
+import re
+import sys
+
 import ctypes
 import ctypes.util
 
+
 def _environ_path(name):
     if name in os.environ:
         return os.environ[name].split(":")
     else:
         return []
 
+
 class LibraryLoader(object):
+
     def __init__(self):
-        self.other_dirs=[]
-    
-    def load_library(self,libname):
+        self.other_dirs = []
+
+    def load_library(self, libname):
         """Given the name of a library, load it."""
         paths = self.getpaths(libname)
-        
+
         for path in paths:
             if os.path.exists(path):
                 return self.load(path)
-        
-        raise ImportError,"%s not found." % libname
-    
-    def load(self,path):
+
+        raise ImportError("%s not found." % libname)
+
+    def load(self, path):
         """Given a path to a library, load it."""
         try:
             # Darwin requires dlopen to be called with mode RTLD_GLOBAL instead
@@ -68,42 +75,44 @@
             else:
                 return ctypes.cdll.LoadLibrary(path)
         except OSError as e:
-            raise ImportError,e
-    
-    def getpaths(self,libname):
+            raise ImportError(e)
+
+    def getpaths(self, libname):
         """Return a list of paths where the library might be found."""
         if os.path.isabs(libname):
             yield libname
-        
+
         else:
             for path in self.getplatformpaths(libname):
                 yield path
-            
+
             path = ctypes.util.find_library(libname)
-            if path: yield path
-    
+            if path:
+                yield path
+
     def getplatformpaths(self, libname):
         return []
 
 # Darwin (Mac OS X)
 
+
 class DarwinLibraryLoader(LibraryLoader):
     name_formats = ["lib%s.dylib", "lib%s.so", "lib%s.bundle", "%s.dylib",
-                "%s.so", "%s.bundle", "%s"]
-    
-    def getplatformpaths(self,libname):
+                    "%s.so", "%s.bundle", "%s"]
+
+    def getplatformpaths(self, libname):
         if os.path.pathsep in libname:
             names = [libname]
         else:
             names = [format % libname for format in self.name_formats]
-        
+
         for dir in self.getdirs(libname):
             for name in names:
-                yield os.path.join(dir,name)
-    
-    def getdirs(self,libname):
+                yield os.path.join(dir, name)
+
+    def getdirs(self, libname):
         '''Implements the dylib search as specified in Apple documentation:
-        
+
         http://developer.apple.com/documentation/DeveloperTools/Conceptual/
             DynamicLibraries/Articles/DynamicLibraryUsageGuidelines.html
 
@@ -116,9 +125,9 @@
         if not dyld_fallback_library_path:
             dyld_fallback_library_path = [os.path.expanduser('~/lib'),
                                           '/usr/local/lib', '/usr/lib']
-        
+
         dirs = []
-        
+
         if '/' in libname:
             dirs.extend(_environ_path("DYLD_LIBRARY_PATH"))
         else:
@@ -127,7 +136,7 @@
 
         dirs.extend(self.other_dirs)
         dirs.append(".")
-        
+
         if hasattr(sys, 'frozen') and sys.frozen == 'macosx_app':
             dirs.append(os.path.join(
                 os.environ['RESOURCEPATH'],
@@ -135,14 +144,15 @@
                 'Frameworks'))
 
         dirs.extend(dyld_fallback_library_path)
-        
+
         return dirs
 
 # Posix
 
+
 class PosixLibraryLoader(LibraryLoader):
     _ld_so_cache = None
-    
+
     def _create_ld_so_cache(self):
         # Recreate search path followed by ld.so.  This is going to be
         # slow to build, and incorrect (ld.so uses ld.so.cache, which may
@@ -153,17 +163,19 @@
 
         directories = []
         for name in ("LD_LIBRARY_PATH",
-                     "SHLIB_PATH", # HPUX
-                     "LIBPATH", # OS/2, AIX
-                     "LIBRARY_PATH", # BE/OS
-                    ):
+                     "SHLIB_PATH",  # HPUX
+                     "LIBPATH",  # OS/2, AIX
+                     "LIBRARY_PATH",  # BE/OS
+                     ):
             if name in os.environ:
                 directories.extend(os.environ[name].split(os.pathsep))
         directories.extend(self.other_dirs)
         directories.append(".")
 
-        try: directories.extend([dir.strip() for dir in open('/etc/ld.so.conf')])
-        except IOError: pass
+        try:
+            directories.extend([dir.strip() for dir in open('/etc/ld.so.conf')])
+        except IOError:
+            pass
 
         directories.extend(['/lib', '/usr/lib', '/lib64', '/usr/lib64'])
 
@@ -178,7 +190,7 @@
                     # Index by filename
                     if file not in cache:
                         cache[file] = path
-                    
+
                     # Index by library name
                     match = lib_re.match(file)
                     if match:
@@ -189,37 +201,44 @@
                 pass
 
         self._ld_so_cache = cache
-    
+
     def getplatformpaths(self, libname):
         if self._ld_so_cache is None:
             self._create_ld_so_cache()
 
         result = self._ld_so_cache.get(libname)
-        if result: yield result
+        if result:
+            yield result
 
         path = ctypes.util.find_library(libname)
-        if path: yield os.path.join("/lib",path)
+        if path:
+            yield os.path.join("/lib", path)
 
 # Windows
 
+
 class _WindowsLibrary(object):
+
     def __init__(self, path):
         self.cdll = ctypes.cdll.LoadLibrary(path)
         self.windll = ctypes.windll.LoadLibrary(path)
 
     def __getattr__(self, name):
-        try: return getattr(self.cdll,name)
+        try:
+            return getattr(self.cdll, name)
         except AttributeError:
-            try: return getattr(self.windll,name)
+            try:
+                return getattr(self.windll, name)
             except AttributeError:
                 raise
 
+
 class WindowsLibraryLoader(LibraryLoader):
     name_formats = ["%s.dll", "lib%s.dll"]
-    
+
     def load(self, path):
         return _WindowsLibrary(path)
-    
+
     def getplatformpaths(self, libname):
         if os.path.sep not in libname:
             for name in self.name_formats:
@@ -233,13 +252,14 @@
 # the Ctypesgen maintainers.
 
 loaderclass = {
-    "darwin":   DarwinLibraryLoader,
-    "cygwin":   WindowsLibraryLoader,
-    "win32":    WindowsLibraryLoader
+    "darwin": DarwinLibraryLoader,
+    "cygwin": WindowsLibraryLoader,
+    "win32": WindowsLibraryLoader
 }
 
 loader = loaderclass.get(sys.platform, PosixLibraryLoader)()
 
+
 def add_library_search_dirs(other_dirs):
     loader.other_dirs = other_dirs
 

Modified: grass/trunk/lib/python/ctypes/preamble.py
===================================================================
--- grass/trunk/lib/python/ctypes/preamble.py	2016-05-01 12:12:51 UTC (rev 68347)
+++ grass/trunk/lib/python/ctypes/preamble.py	2016-05-02 16:06:24 UTC (rev 68348)
@@ -1,4 +1,7 @@
-import ctypes, os, sys
+import os
+import sys
+
+import ctypes
 from ctypes import *
 
 _int_types = (c_int16, c_int32)
@@ -13,12 +16,14 @@
 del t
 del _int_types
 
+
 class c_void(Structure):
     # c_void_p is a buggy return type, converting to int, so
     # POINTER(None) == c_void_p is actually written as
     # POINTER(c_void), so it can be treated as a real pointer.
     _fields_ = [('dummy', c_int)]
 
+
 def POINTER(obj):
     p = ctypes.POINTER(obj)
 
@@ -44,29 +49,35 @@
 #
 # Non-primitive return values wrapped with UNCHECKED won't be
 # typechecked, and will be converted to c_void_p.
+
+
 def UNCHECKED(type):
     if (hasattr(type, "_type_") and isinstance(type._type_, str)
-        and type._type_ != "P"):
+            and type._type_ != "P"):
         return type
     else:
         return c_void_p
 
 # ctypes doesn't have direct support for variadic functions, so we have to write
 # our own wrapper class
+
+
 class _variadic_function(object):
-    def __init__(self,func,restype,argtypes):
-        self.func=func
-        self.func.restype=restype
-        self.argtypes=argtypes
+
+    def __init__(self, func, restype, argtypes):
+        self.func = func
+        self.func.restype = restype
+        self.argtypes = argtypes
+
     def _as_parameter_(self):
         # So we can pass this variadic function as a function pointer
         return self.func
-    def __call__(self,*args):
-        fixed_args=[]
-        i=0
+
+    def __call__(self, *args):
+        fixed_args = []
+        i = 0
         for argtype in self.argtypes:
             # Typecheck what we can
             fixed_args.append(argtype.from_param(args[i]))
-            i+=1
-        return self.func(*fixed_args+list(args[i:]))
-
+            i += 1
+        return self.func(*fixed_args + list(args[i:]))



More information about the grass-commit mailing list