@scrypted/arlo 0.11.26 → 0.11.27

package/venv/lib/python3.10/site-packages/pycparser/_ast_gen.py

@@ -1,336 +0,0 @@
-#-----------------------------------------------------------------
-# _ast_gen.py
-#
-# Generates the AST Node classes from a specification given in
-# a configuration file
-#
-# The design of this module was inspired by astgen.py from the
-# Python 2.5 code-base.
-#
-# Eli Bendersky [https://eli.thegreenplace.net/]
-# License: BSD
-#-----------------------------------------------------------------
-from string import Template
-
-
-class ASTCodeGenerator(object):
-    def __init__(self, cfg_filename='_c_ast.cfg'):
-        """ Initialize the code generator from a configuration
-            file.
-        """
-        self.cfg_filename = cfg_filename
-        self.node_cfg = [NodeCfg(name, contents)
-            for (name, contents) in self.parse_cfgfile(cfg_filename)]
-
-    def generate(self, file=None):
-        """ Generates the code into file, an open file buffer.
-        """
-        src = Template(_PROLOGUE_COMMENT).substitute(
-            cfg_filename=self.cfg_filename)
-
-        src += _PROLOGUE_CODE
-        for node_cfg in self.node_cfg:
-            src += node_cfg.generate_source() + '\n\n'
-
-        file.write(src)
-
-    def parse_cfgfile(self, filename):
-        """ Parse the configuration file and yield pairs of
-            (name, contents) for each node.
-        """
-        with open(filename, "r") as f:
-            for line in f:
-                line = line.strip()
-                if not line or line.startswith('#'):
-                    continue
-                colon_i = line.find(':')
-                lbracket_i = line.find('[')
-                rbracket_i = line.find(']')
-                if colon_i < 1 or lbracket_i <= colon_i or rbracket_i <= lbracket_i:
-                    raise RuntimeError("Invalid line in %s:\n%s\n" % (filename, line))
-
-                name = line[:colon_i]
-                val = line[lbracket_i + 1:rbracket_i]
-                vallist = [v.strip() for v in val.split(',')] if val else []
-                yield name, vallist
-
-
-class NodeCfg(object):
-    """ Node configuration.
-
-        name: node name
-        contents: a list of contents - attributes and child nodes
-        See comment at the top of the configuration file for details.
-    """
-
-    def __init__(self, name, contents):
-        self.name = name
-        self.all_entries = []
-        self.attr = []
-        self.child = []
-        self.seq_child = []
-
-        for entry in contents:
-            clean_entry = entry.rstrip('*')
-            self.all_entries.append(clean_entry)
-
-            if entry.endswith('**'):
-                self.seq_child.append(clean_entry)
-            elif entry.endswith('*'):
-                self.child.append(clean_entry)
-            else:
-                self.attr.append(entry)
-
-    def generate_source(self):
-        src = self._gen_init()
-        src += '\n' + self._gen_children()
-        src += '\n' + self._gen_iter()
-        src += '\n' + self._gen_attr_names()
-        return src
-
-    def _gen_init(self):
-        src = "class %s(Node):\n" % self.name
-
-        if self.all_entries:
-            args = ', '.join(self.all_entries)
-            slots = ', '.join("'{0}'".format(e) for e in self.all_entries)
-            slots += ", 'coord', '__weakref__'"
-            arglist = '(self, %s, coord=None)' % args
-        else:
-            slots = "'coord', '__weakref__'"
-            arglist = '(self, coord=None)'
-
-        src += "    __slots__ = (%s)\n" % slots
-        src += "    def __init__%s:\n" % arglist
-
-        for name in self.all_entries + ['coord']:
-            src += "        self.%s = %s\n" % (name, name)
-
-        return src
-
-    def _gen_children(self):
-        src = '    def children(self):\n'
-
-        if self.all_entries:
-            src += '        nodelist = []\n'
-
-            for child in self.child:
-                src += (
-                    '        if self.%(child)s is not None:' +
-                    ' nodelist.append(("%(child)s", self.%(child)s))\n') % (
-                        dict(child=child))
-
-            for seq_child in self.seq_child:
-                src += (
-                    '        for i, child in enumerate(self.%(child)s or []):\n'
-                    '            nodelist.append(("%(child)s[%%d]" %% i, child))\n') % (
-                        dict(child=seq_child))
-
-            src += '        return tuple(nodelist)\n'
-        else:
-            src += '        return ()\n'
-
-        return src
-
-    def _gen_iter(self):
-        src = '    def __iter__(self):\n'
-
-        if self.all_entries:
-            for child in self.child:
-                src += (
-                    '        if self.%(child)s is not None:\n' +
-                    '            yield self.%(child)s\n') % (dict(child=child))
-
-            for seq_child in self.seq_child:
-                src += (
-                    '        for child in (self.%(child)s or []):\n'
-                    '            yield child\n') % (dict(child=seq_child))
-
-            if not (self.child or self.seq_child):
-                # Empty generator
-                src += (
-                    '        return\n' +
-                    '        yield\n')
-        else:
-            # Empty generator
-            src += (
-                '        return\n' +
-                '        yield\n')
-
-        return src
-
-    def _gen_attr_names(self):
-        src = "    attr_names = (" + ''.join("%r, " % nm for nm in self.attr) + ')'
-        return src
-
-
-_PROLOGUE_COMMENT = \
-r'''#-----------------------------------------------------------------
-# ** ATTENTION **
-# This code was automatically generated from the file:
-# $cfg_filename
-#
-# Do not modify it directly. Modify the configuration file and
-# run the generator again.
-# ** ** *** ** **
-#
-# pycparser: c_ast.py
-#
-# AST Node classes.
-#
-# Eli Bendersky [https://eli.thegreenplace.net/]
-# License: BSD
-#-----------------------------------------------------------------
-
-'''
-
-_PROLOGUE_CODE = r'''
-import sys
-
-def _repr(obj):
-    """
-    Get the representation of an object, with dedicated pprint-like format for lists.
-    """
-    if isinstance(obj, list):
-        return '[' + (',\n '.join((_repr(e).replace('\n', '\n ') for e in obj))) + '\n]'
-    else:
-        return repr(obj)
-
-class Node(object):
-    __slots__ = ()
-    """ Abstract base class for AST nodes.
-    """
-    def __repr__(self):
-        """ Generates a python representation of the current node
-        """
-        result = self.__class__.__name__ + '('
-
-        indent = ''
-        separator = ''
-        for name in self.__slots__[:-2]:
-            result += separator
-            result += indent
-            result += name + '=' + (_repr(getattr(self, name)).replace('\n', '\n  ' + (' ' * (len(name) + len(self.__class__.__name__)))))
-
-            separator = ','
-            indent = '\n ' + (' ' * len(self.__class__.__name__))
-
-        result += indent + ')'
-
-        return result
-
-    def children(self):
-        """ A sequence of all children that are Nodes
-        """
-        pass
-
-    def show(self, buf=sys.stdout, offset=0, attrnames=False, nodenames=False, showcoord=False, _my_node_name=None):
-        """ Pretty print the Node and all its attributes and
-            children (recursively) to a buffer.
-
-            buf:
-                Open IO buffer into which the Node is printed.
-
-            offset:
-                Initial offset (amount of leading spaces)
-
-            attrnames:
-                True if you want to see the attribute names in
-                name=value pairs. False to only see the values.
-
-            nodenames:
-                True if you want to see the actual node names
-                within their parents.
-
-            showcoord:
-                Do you want the coordinates of each Node to be
-                displayed.
-        """
-        lead = ' ' * offset
-        if nodenames and _my_node_name is not None:
-            buf.write(lead + self.__class__.__name__+ ' <' + _my_node_name + '>: ')
-        else:
-            buf.write(lead + self.__class__.__name__+ ': ')
-
-        if self.attr_names:
-            if attrnames:
-                nvlist = [(n, getattr(self,n)) for n in self.attr_names]
-                attrstr = ', '.join('%s=%s' % nv for nv in nvlist)
-            else:
-                vlist = [getattr(self, n) for n in self.attr_names]
-                attrstr = ', '.join('%s' % v for v in vlist)
-            buf.write(attrstr)
-
-        if showcoord:
-            buf.write(' (at %s)' % self.coord)
-        buf.write('\n')
-
-        for (child_name, child) in self.children():
-            child.show(
-                buf,
-                offset=offset + 2,
-                attrnames=attrnames,
-                nodenames=nodenames,
-                showcoord=showcoord,
-                _my_node_name=child_name)
-
-
-class NodeVisitor(object):
-    """ A base NodeVisitor class for visiting c_ast nodes.
-        Subclass it and define your own visit_XXX methods, where
-        XXX is the class name you want to visit with these
-        methods.
-
-        For example:
-
-        class ConstantVisitor(NodeVisitor):
-            def __init__(self):
-                self.values = []
-
-            def visit_Constant(self, node):
-                self.values.append(node.value)
-
-        Creates a list of values of all the constant nodes
-        encountered below the given node. To use it:
-
-        cv = ConstantVisitor()
-        cv.visit(node)
-
-        Notes:
-
-        *   generic_visit() will be called for AST nodes for which
-            no visit_XXX method was defined.
-        *   The children of nodes for which a visit_XXX was
-            defined will not be visited - if you need this, call
-            generic_visit() on the node.
-            You can use:
-                NodeVisitor.generic_visit(self, node)
-        *   Modeled after Python's own AST visiting facilities
-            (the ast module of Python 3.0)
-    """
-
-    _method_cache = None
-
-    def visit(self, node):
-        """ Visit a node.
-        """
-
-        if self._method_cache is None:
-            self._method_cache = {}
-
-        visitor = self._method_cache.get(node.__class__.__name__, None)
-        if visitor is None:
-            method = 'visit_' + node.__class__.__name__
-            visitor = getattr(self, method, self.generic_visit)
-            self._method_cache[node.__class__.__name__] = visitor
-
-        return visitor(node)
-
-    def generic_visit(self, node):
-        """ Called if no explicit visitor function exists for a
-            node. Implements preorder visiting of the node.
-        """
-        for c in node:
-            self.visit(c)
-
-'''

package/venv/lib/python3.10/site-packages/pycparser/_build_tables.py

@@ -1,40 +0,0 @@
-#-----------------------------------------------------------------
-# pycparser: _build_tables.py
-#
-# A dummy for generating the lexing/parsing tables and and
-# compiling them into .pyc for faster execution in optimized mode.
-# Also generates AST code from the configuration file.
-# Should be called from the pycparser directory.
-#
-# Eli Bendersky [https://eli.thegreenplace.net/]
-# License: BSD
-#-----------------------------------------------------------------
-
-# Insert '.' and '..' as first entries to the search path for modules.
-# Restricted environments like embeddable python do not include the
-# current working directory on startup.
-import importlib
-import sys
-sys.path[0:0] = ['.', '..']
-
-# Generate c_ast.py
-from _ast_gen import ASTCodeGenerator
-ast_gen = ASTCodeGenerator('_c_ast.cfg')
-ast_gen.generate(open('c_ast.py', 'w'))
-
-from pycparser import c_parser
-
-# Generates the tables
-#
-c_parser.CParser(
-    lex_optimize=True,
-    yacc_debug=False,
-    yacc_optimize=True)
-
-# Load to compile into .pyc
-#
-importlib.invalidate_caches()
-
-import lextab
-import yacctab
-import c_ast

package/venv/lib/python3.10/site-packages/pycparser/_c_ast.cfg

@@ -1,195 +0,0 @@
-#-----------------------------------------------------------------
-# pycparser: _c_ast.cfg
-#
-# Defines the AST Node classes used in pycparser.
-#
-# Each entry is a Node sub-class name, listing the attributes
-# and child nodes of the class:
-#   <name>*     - a child node
-#   <name>**    - a sequence of child nodes
-#   <name>      - an attribute
-#
-# Eli Bendersky [https://eli.thegreenplace.net/]
-# License: BSD
-#-----------------------------------------------------------------
-
-# ArrayDecl is a nested declaration of an array with the given type.
-# dim: the dimension (for example, constant 42)
-# dim_quals: list of dimension qualifiers, to support C99's allowing 'const'
-#            and 'static' within the array dimension in function declarations.
-ArrayDecl: [type*, dim*, dim_quals]
-
-ArrayRef: [name*, subscript*]
-
-# op: =, +=, /= etc.
-#
-Assignment: [op, lvalue*, rvalue*]
-
-Alignas: [alignment*]
-
-BinaryOp: [op, left*, right*]
-
-Break: []
-
-Case: [expr*, stmts**]
-
-Cast: [to_type*, expr*]
-
-# Compound statement in C99 is a list of block items (declarations or
-# statements).
-#
-Compound: [block_items**]
-
-# Compound literal (anonymous aggregate) for C99.
-# (type-name) {initializer_list}
-# type: the typename
-# init: InitList for the initializer list
-#
-CompoundLiteral: [type*, init*]
-
-# type: int, char, float, string, etc.
-#
-Constant: [type, value]
-
-Continue: []
-
-# name: the variable being declared
-# quals: list of qualifiers (const, volatile)
-# funcspec: list function specifiers (i.e. inline in C99)
-# storage: list of storage specifiers (extern, register, etc.)
-# type: declaration type (probably nested with all the modifiers)
-# init: initialization value, or None
-# bitsize: bit field size, or None
-#
-Decl: [name, quals, align, storage, funcspec, type*, init*, bitsize*]
-
-DeclList: [decls**]
-
-Default: [stmts**]
-
-DoWhile: [cond*, stmt*]
-
-# Represents the ellipsis (...) parameter in a function
-# declaration
-#
-EllipsisParam: []
-
-# An empty statement (a semicolon ';' on its own)
-#
-EmptyStatement: []
-
-# Enumeration type specifier
-# name: an optional ID
-# values: an EnumeratorList
-#
-Enum: [name, values*]
-
-# A name/value pair for enumeration values
-#
-Enumerator: [name, value*]
-
-# A list of enumerators
-#
-EnumeratorList: [enumerators**]
-
-# A list of expressions separated by the comma operator.
-#
-ExprList: [exprs**]
-
-# This is the top of the AST, representing a single C file (a
-# translation unit in K&R jargon). It contains a list of
-# "external-declaration"s, which is either declarations (Decl),
-# Typedef or function definitions (FuncDef).
-#
-FileAST: [ext**]
-
-# for (init; cond; next) stmt
-#
-For: [init*, cond*, next*, stmt*]
-
-# name: Id
-# args: ExprList
-#
-FuncCall: [name*, args*]
-
-# type <decl>(args)
-#
-FuncDecl: [args*, type*]
-
-# Function definition: a declarator for the function name and
-# a body, which is a compound statement.
-# There's an optional list of parameter declarations for old
-# K&R-style definitions
-#
-FuncDef: [decl*, param_decls**, body*]
-
-Goto: [name]
-
-ID: [name]
-
-# Holder for types that are a simple identifier (e.g. the built
-# ins void, char etc. and typedef-defined types)
-#
-IdentifierType: [names]
-
-If: [cond*, iftrue*, iffalse*]
-
-# An initialization list used for compound literals.
-#
-InitList: [exprs**]
-
-Label: [name, stmt*]
-
-# A named initializer for C99.
-# The name of a NamedInitializer is a sequence of Nodes, because
-# names can be hierarchical and contain constant expressions.
-#
-NamedInitializer: [name**, expr*]
-
-# a list of comma separated function parameter declarations
-#
-ParamList: [params**]
-
-PtrDecl: [quals, type*]
-
-Return: [expr*]
-
-StaticAssert: [cond*, message*]
-
-# name: struct tag name
-# decls: declaration of members
-#
-Struct: [name, decls**]
-
-# type: . or ->
-# name.field or name->field
-#
-StructRef: [name*, type, field*]
-
-Switch: [cond*, stmt*]
-
-# cond ? iftrue : iffalse
-#
-TernaryOp: [cond*, iftrue*, iffalse*]
-
-# A base type declaration
-#
-TypeDecl: [declname, quals, align, type*]
-
-# A typedef declaration.
-# Very similar to Decl, but without some attributes
-#
-Typedef: [name, quals, storage, type*]
-
-Typename: [name, quals, align, type*]
-
-UnaryOp: [op, expr*]
-
-# name: union tag name
-# decls: declaration of members
-#
-Union: [name, decls**]
-
-While: [cond*, stmt*]
-
-Pragma: [string]