<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: lex.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'># -----------------------------------------------------------------------------
# ply: lex.py
#
# Copyright (C) 2001-2018
# David M. Beazley (Dabeaz LLC)
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# 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 notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
# * Neither the name of the David Beazley or Dabeaz LLC may be used to
#   endorse or promote products derived from this software without
#  specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# &quot;AS IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# -----------------------------------------------------------------------------

__version__    = &#039;3.11&#039;
__tabversion__ = &#039;3.10&#039;

import re
import sys
import types
import copy
import os
import inspect

# This tuple contains known string types
try:
    # Python 2.6
    StringTypes = (types.StringType, types.UnicodeType)
except AttributeError:
    # Python 3.0
    StringTypes = (str, bytes)

# This regular expression is used to match valid token names
_is_identifier = re.compile(r&#039;^[a-zA-Z0-9_]+$&#039;)

# 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


# Token class.  This class is used to represent the tokens produced.
class LexToken(object):
    def __str__(self):
        return &#039;LexToken(%s,%r,%d,%d)&#039; % (self.type, self.value, self.lineno, self.lexpos)

    def __repr__(self):
        return str(self)


# This object is a stand-in for a logging object created by the
# logging module.

class PlyLogger(object):
    def __init__(self, f):
        self.f = f

    def critical(self, msg, *args, **kwargs):
        self.f.write((msg % args) + &#039;\n&#039;)

    def warning(self, msg, *args, **kwargs):
        self.f.write(&#039;WARNING: &#039; + (msg % args) + &#039;\n&#039;)

    def error(self, msg, *args, **kwargs):
        self.f.write(&#039;ERROR: &#039; + (msg % args) + &#039;\n&#039;)

    info = critical
    debug = critical


# Null logger is used when no output is generated. Does nothing.
class NullLogger(object):
    def __getattribute__(self, name):
        return self

    def __call__(self, *args, **kwargs):
        return self


# -----------------------------------------------------------------------------
#                        === Lexing Engine ===
#
# The following Lexer class implements the lexer runtime.   There are only
# a few public methods and attributes:
#
#    input()          -  Store a new string in the lexer
#    token()          -  Get the next token
#    clone()          -  Clone the lexer
#
#    lineno           -  Current line number
#    lexpos           -  Current position in the input string
# -----------------------------------------------------------------------------

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.lexretext = None         # Current regular expression strings
        self.lexstatere = {}          # Dictionary mapping lexer states to master regexs
        self.lexstateretext = {}      # Dictionary mapping lexer states to regex strings
        self.lexstaterenames = {}     # Dictionary mapping lexer states to symbol names
        self.lexstate = &#039;INITIAL&#039;     # Current lexer state
        self.lexstatestack = []       # Stack of lexer states
        self.lexstateinfo = None      # State information
        self.lexstateignore = {}      # Dictionary of ignored characters for each state
        self.lexstateerrorf = {}      # Dictionary of error functions for each state
        self.lexstateeoff = {}        # Dictionary of eof functions for each state
        self.lexreflags = 0           # Optional re compile flags
        self.lexdata = None           # Actual input data (as a string)
        self.lexpos = 0               # Current position in input text
        self.lexlen = 0               # Length of the input text
        self.lexerrorf = None         # Error rule (if any)
        self.lexeoff = None           # EOF rule (if any)
        self.lextokens = None         # List of valid tokens
        self.lexignore = &#039;&#039;           # Ignored characters
        self.lexliterals = &#039;&#039;         # Literal characters that can be passed through
        self.lexmodule = None         # Module
        self.lineno = 1               # Current line number
        self.lexoptimize = False      # Optimized mode

    def clone(self, object=None):
        c = copy.copy(self)

        # 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 = {}
            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))
                newtab[key] = newre
            c.lexstatere = newtab
            c.lexstateerrorf = {}
            for key, ef in self.lexstateerrorf.items():
                c.lexstateerrorf[key] = getattr(object, ef.__name__)
            c.lexmodule = object
        return c

    # ------------------------------------------------------------
    # writetab() - Write lexer information to a table file
    # ------------------------------------------------------------
    def writetab(self, lextab, outputdir=&#039;&#039;):
        if isinstance(lextab, types.ModuleType):
            raise IOError(&quot;Won&#039;t overwrite existing lextab module&quot;)
        basetabmodule = lextab.split(&#039;.&#039;)[-1]
        filename = os.path.join(outputdir, basetabmodule) + &#039;.py&#039;
        with open(filename, &#039;w&#039;) as tf:
            tf.write(&#039;# %s.py. This file automatically created by PLY (version %s). Don\&#039;t edit!\n&#039; % (basetabmodule, __version__))
            tf.write(&#039;_tabversion   = %s\n&#039; % repr(__tabversion__))
            tf.write(&#039;_lextokens    = set(%s)\n&#039; % repr(tuple(sorted(self.lextokens))))
            tf.write(&#039;_lexreflags   = %s\n&#039; % repr(int(self.lexreflags)))
            tf.write(&#039;_lexliterals  = %s\n&#039; % repr(self.lexliterals))
            tf.write(&#039;_lexstateinfo = %s\n&#039; % repr(self.lexstateinfo))

            # Rewrite the lexstatere table, replacing function objects with function names
            tabre = {}
            for statename, lre in self.lexstatere.items():
                titem = []
                for (pat, func), retext, renames in zip(lre, self.lexstateretext[statename], self.lexstaterenames[statename]):
                    titem.append((retext, _funcs_to_names(func, renames)))
                tabre[statename] = titem

            tf.write(&#039;_lexstatere   = %s\n&#039; % repr(tabre))
            tf.write(&#039;_lexstateignore = %s\n&#039; % repr(self.lexstateignore))

            taberr = {}
            for statename, ef in self.lexstateerrorf.items():
                taberr[statename] = ef.__name__ if ef else None
            tf.write(&#039;_lexstateerrorf = %s\n&#039; % repr(taberr))

            tabeof = {}
            for statename, ef in self.lexstateeoff.items():
                tabeof[statename] = ef.__name__ if ef else None
            tf.write(&#039;_lexstateeoff = %s\n&#039; % repr(tabeof))

    # ------------------------------------------------------------
    # readtab() - Read lexer information from a tab file
    # ------------------------------------------------------------
    def readtab(self, tabfile, fdict):
        if isinstance(tabfile, types.ModuleType):
            lextab = tabfile
        else:
            exec(&#039;import %s&#039; % tabfile)
            lextab = sys.modules[tabfile]

        if getattr(lextab, &#039;_tabversion&#039;, &#039;0.0&#039;) != __tabversion__:
            raise ImportError(&#039;Inconsistent PLY version&#039;)

        self.lextokens      = lextab._lextokens
        self.lexreflags     = lextab._lexreflags
        self.lexliterals    = lextab._lexliterals
        self.lextokens_all  = self.lextokens | set(self.lexliterals)
        self.lexstateinfo   = lextab._lexstateinfo
        self.lexstateignore = lextab._lexstateignore
        self.lexstatere     = {}
        self.lexstateretext = {}
        for statename, lre in lextab._lexstatere.items():
            titem = []
            txtitem = []
            for pat, func_name in lre:
                titem.append((re.compile(pat, lextab._lexreflags), _names_to_funcs(func_name, fdict)))

            self.lexstatere[statename] = titem
            self.lexstateretext[statename] = txtitem

        self.lexstateerrorf = {}
        for statename, ef in lextab._lexstateerrorf.items():
            self.lexstateerrorf[statename] = fdict[ef]

        self.lexstateeoff = {}
        for statename, ef in lextab._lexstateeoff.items():
            self.lexstateeoff[statename] = fdict[ef]

        self.begin(&#039;INITIAL&#039;)

    # ------------------------------------------------------------
    # input() - Push a new string into the lexer
    # ------------------------------------------------------------
    def input(self, s):
        # Pull off the first character to see if s looks like a string
        c = s[:1]
        if not isinstance(c, StringTypes):
            raise ValueError(&#039;Expected a string&#039;)
        self.lexdata = s
        self.lexpos = 0
        self.lexlen = len(s)

    # ------------------------------------------------------------
    # begin() - Changes the lexing state
    # ------------------------------------------------------------
    def begin(self, state):
        if state not in self.lexstatere:
            raise ValueError(&#039;Undefined state&#039;)
        self.lexre = self.lexstatere[state]
        self.lexretext = self.lexstateretext[state]
        self.lexignore = self.lexstateignore.get(state, &#039;&#039;)
        self.lexerrorf = self.lexstateerrorf.get(state, None)
        self.lexeoff = self.lexstateeoff.get(state, None)
        self.lexstate = state

    # ------------------------------------------------------------
    # push_state() - Changes the lexing state and saves old on stack
    # ------------------------------------------------------------
    def push_state(self, state):
        self.lexstatestack.append(self.lexstate)
        self.begin(state)

    # ------------------------------------------------------------
    # pop_state() - Restores the previous state
    # ------------------------------------------------------------
    def pop_state(self):
        self.begin(self.lexstatestack.pop())

    # ------------------------------------------------------------
    # current_state() - Returns the current lexing state
    # ------------------------------------------------------------
    def current_state(self):
        return self.lexstate

    # ------------------------------------------------------------
    # skip() - Skip ahead n characters
    # ------------------------------------------------------------
    def skip(self, n):
        self.lexpos += n

    # ------------------------------------------------------------
    # opttoken() - Return the next token from the Lexer
    #
    # Note: This function has been carefully implemented to be as fast
    # as possible.  Don&#039;t make changes unless you really know what
    # you are doing
    # ------------------------------------------------------------
    def token(self):
        # Make local copies of frequently referenced attributes
        lexpos    = self.lexpos
        lexlen    = self.lexlen
        lexignore = self.lexignore
        lexdata   = self.lexdata

        while lexpos &lt; lexlen:
            # 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

                # Create a token for return
                tok = LexToken()
                tok.value = m.group()
                tok.lineno = self.lineno
                tok.lexpos = lexpos

                i = m.lastindex
                func, tok.type = lexindexfunc[i]

                if not func:
                    # If no token type was set, it&#039;s an ignored token
                    if tok.type:
                        self.lexpos = m.end()
                        return tok
                    else:
                        lexpos = m.end()
                        break

                lexpos = m.end()

                # If token is processed by a function, call it

                tok.lexer = self      # Set additional attributes useful in token rules
                self.lexmatch = m
                self.lexpos = lexpos

                newtok = func(tok)

                # Every function must return a token, if nothing, we just move to next token
                if not newtok:
                    lexpos    = self.lexpos         # This is here in case user has updated lexpos.
                    lexignore = self.lexignore      # This is here in case there was a state change
                    break

                # Verify type of the token.  If not in the token map, raise an error
                if not self.lexoptimize:
                    if newtok.type not in self.lextokens_all:
                        raise LexError(&quot;%s:%d: Rule &#039;%s&#039; returned an unknown token type &#039;%s&#039;&quot; % (
                            func.__code__.co_filename, func.__code__.co_firstlineno,
                            func.__name__, newtok.type), lexdata[lexpos:])

                return newtok
            else:
                # No match, see if in literals
                if lexdata[lexpos] in self.lexliterals:
                    tok = LexToken()
                    tok.value = lexdata[lexpos]
                    tok.lineno = self.lineno
                    tok.type = tok.value
                    tok.lexpos = lexpos
                    self.lexpos = lexpos + 1
                    return tok

                # No match. Call t_error() if defined.
                if self.lexerrorf:
                    tok = LexToken()
                    tok.value = self.lexdata[lexpos:]
                    tok.lineno = self.lineno
                    tok.type = &#039;error&#039;
                    tok.lexer = self
                    tok.lexpos = lexpos
                    self.lexpos = lexpos
                    newtok = self.lexerrorf(tok)
                    if lexpos == self.lexpos:
                        # Error method didn&#039;t change text position at all. This is an error.
                        raise LexError(&quot;Scanning error. Illegal character &#039;%s&#039;&quot; % (lexdata[lexpos]), lexdata[lexpos:])
                    lexpos = self.lexpos
                    if not newtok:
                        continue
                    return newtok

                self.lexpos = lexpos
                raise LexError(&quot;Illegal character &#039;%s&#039; at index %d&quot; % (lexdata[lexpos], lexpos), lexdata[lexpos:])

        if self.lexeoff:
            tok = LexToken()
            tok.type = &#039;eof&#039;
            tok.value = &#039;&#039;
            tok.lineno = self.lineno
            tok.lexpos = lexpos
            tok.lexer = self
            self.lexpos = lexpos
            newtok = self.lexeoff(tok)
            return newtok

        self.lexpos = lexpos + 1
        if self.lexdata is None:
            raise RuntimeError(&#039;No input string given with input()&#039;)
        return None

    # Iterator interface
    def __iter__(self):
        return self

    def next(self):
        t = self.token()
        if t is None:
            raise StopIteration
        return t

    __next__ = next

# -----------------------------------------------------------------------------
#                           ==== Lex Builder ===
#
# The functions and classes below are used to collect lexing information
# and build a Lexer object from it.
# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------
# _get_regex(func)
#
# Returns the regular expression assigned to a function either as a doc string
# or as a .regex attribute attached by the @TOKEN decorator.
# -----------------------------------------------------------------------------
def _get_regex(func):
    return getattr(func, &#039;regex&#039;, func.__doc__)

# -----------------------------------------------------------------------------
# get_caller_module_dict()
#
# This function returns a dictionary containing all of the symbols defined within
# a caller further down the call stack.  This is used to get the environment
# associated with the yacc() call if none was provided.
# -----------------------------------------------------------------------------
def get_caller_module_dict(levels):
    f = sys._getframe(levels)
    ldict = f.f_globals.copy()
    if f.f_globals != f.f_locals:
        ldict.update(f.f_locals)
    return ldict

# -----------------------------------------------------------------------------
# _funcs_to_names()
#
# Given a list of regular expression functions, this converts it to a list
# suitable for output to a table file
# -----------------------------------------------------------------------------
def _funcs_to_names(funclist, namelist):
    result = []
    for f, name in zip(funclist, namelist):
        if f and f[0]:
            result.append((name, f[1]))
        else:
            result.append(f)
    return result

# -----------------------------------------------------------------------------
# _names_to_funcs()
#
# Given a list of regular expression function names, this converts it back to
# 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

# -----------------------------------------------------------------------------
# _form_master_re()
#
# This function takes a list of all of the regex components and attempts to
# form the master regular expression.  Given limitations in the Python re
# module, it may be necessary to break the master regex into separate expressions.
# -----------------------------------------------------------------------------
def _form_master_re(relist, reflags, ldict, toknames):
    if not relist:
        return []
    regex = &#039;|&#039;.join(relist)
    try:
        lexre = re.compile(regex, reflags)

        # Build the index to function map for the matching engine
        lexindexfunc = [None] * (max(lexre.groupindex.values()) + 1)
        lexindexnames = lexindexfunc[:]

        for f, i in lexre.groupindex.items():
            handle = ldict.get(f, None)
            if type(handle) in (types.FunctionType, types.MethodType):
                lexindexfunc[i] = (handle, toknames[f])
                lexindexnames[i] = f
            elif handle is not None:
                lexindexnames[i] = f
                if f.find(&#039;ignore_&#039;) &gt; 0:
                    lexindexfunc[i] = (None, None)
                else:
                    lexindexfunc[i] = (None, toknames[f])

        return [(lexre, lexindexfunc)], [regex], [lexindexnames]
    except Exception:
        m = int(len(relist)/2)
        if m == 0:
            m = 1
        llist, lre, lnames = _form_master_re(relist[:m], reflags, ldict, toknames)
        rlist, rre, rnames = _form_master_re(relist[m:], reflags, ldict, toknames)
        return (llist+rlist), (lre+rre), (lnames+rnames)

# -----------------------------------------------------------------------------
# def _statetoken(s,names)
#
# Given a declaration name s of the form &quot;t_&quot; and a dictionary whose keys are
# state names, this function returns a tuple (states,tokenname) where states
# is a tuple of state names and tokenname is the name of the token.  For example,
# calling this with s = &quot;t_foo_bar_SPAM&quot; might return ((&#039;foo&#039;,&#039;bar&#039;),&#039;SPAM&#039;)
# -----------------------------------------------------------------------------
def _statetoken(s, names):
    parts = s.split(&#039;_&#039;)
    for i, part in enumerate(parts[1:], 1):
        if part not in names and part != &#039;ANY&#039;:
            break

    if i &gt; 1:
        states = tuple(parts[1:i])
    else:
        states = (&#039;INITIAL&#039;,)

    if &#039;ANY&#039; in states:
        states = tuple(names)

    tokenname = &#039;_&#039;.join(parts[i:])
    return (states, tokenname)


# -----------------------------------------------------------------------------
# LexerReflect()
#
# This class represents information needed to build a lexer as extracted from a
# user&#039;s input file.
# -----------------------------------------------------------------------------
class LexerReflect(object):
    def __init__(self, ldict, log=None, reflags=0):
        self.ldict      = ldict
        self.error_func = None
        self.tokens     = []
        self.reflags    = reflags
        self.stateinfo  = {&#039;INITIAL&#039;: &#039;inclusive&#039;}
        self.modules    = set()
        self.error      = False
        self.log        = PlyLogger(sys.stderr) if log is None else log

    # Get all of the basic information
    def get_all(self):
        self.get_tokens()
        self.get_literals()
        self.get_states()
        self.get_rules()

    # Validate all of the information
    def validate_all(self):
        self.validate_tokens()
        self.validate_literals()
        self.validate_rules()
        return self.error

    # Get the tokens map
    def get_tokens(self):
        tokens = self.ldict.get(&#039;tokens&#039;, None)
        if not tokens:
            self.log.error(&#039;No token list is defined&#039;)
            self.error = True
            return

        if not isinstance(tokens, (list, tuple)):
            self.log.error(&#039;tokens must be a list or tuple&#039;)
            self.error = True
            return

        if not tokens:
            self.log.error(&#039;tokens is empty&#039;)
            self.error = True
            return

        self.tokens = tokens

    # Validate the tokens
    def validate_tokens(self):
        terminals = {}
        for n in self.tokens:
            if not _is_identifier.match(n):
                self.log.error(&quot;Bad token name &#039;%s&#039;&quot;, n)
                self.error = True
            if n in terminals:
                self.log.warning(&quot;Token &#039;%s&#039; multiply defined&quot;, n)
            terminals[n] = 1

    # Get the literals specifier
    def get_literals(self):
        self.literals = self.ldict.get(&#039;literals&#039;, &#039;&#039;)
        if not self.literals:
            self.literals = &#039;&#039;

    # Validate literals
    def validate_literals(self):
        try:
            for c in self.literals:
                if not isinstance(c, StringTypes) or len(c) &gt; 1:
                    self.log.error(&#039;Invalid literal %s. Must be a single character&#039;, repr(c))
                    self.error = True

        except TypeError:
            self.log.error(&#039;Invalid literals specification. literals must be a sequence of characters&#039;)
            self.error = True

    def get_states(self):
        self.states = self.ldict.get(&#039;states&#039;, None)
        # Build statemap
        if self.states:
            if not isinstance(self.states, (tuple, list)):
                self.log.error(&#039;states must be defined as a tuple or list&#039;)
                self.error = True
            else:
                for s in self.states:
                    if not isinstance(s, tuple) or len(s) != 2:
                        self.log.error(&quot;Invalid state specifier %s. Must be a tuple (statename,&#039;exclusive|inclusive&#039;)&quot;, repr(s))
                        self.error = True
                        continue
                    name, statetype = s
                    if not isinstance(name, StringTypes):
                        self.log.error(&#039;State name %s must be a string&#039;, repr(name))
                        self.error = True
                        continue
                    if not (statetype == &#039;inclusive&#039; or statetype == &#039;exclusive&#039;):
                        self.log.error(&quot;State type for state %s must be &#039;inclusive&#039; or &#039;exclusive&#039;&quot;, name)
                        self.error = True
                        continue
                    if name in self.stateinfo:
                        self.log.error(&quot;State &#039;%s&#039; already defined&quot;, name)
                        self.error = True
                        continue
                    self.stateinfo[name] = statetype

    # Get all of the symbols with a t_ prefix and sort them into various
    # categories (functions, strings, error functions, and ignore characters)

    def get_rules(self):
        tsymbols = [f for f in self.ldict if f[:2] == &#039;t_&#039;]

        # Now build up a list of functions and a list of strings
        self.toknames = {}        # Mapping of symbols to token names
        self.funcsym  = {}        # Symbols defined as functions
        self.strsym   = {}        # Symbols defined as strings
        self.ignore   = {}        # Ignore strings by state
        self.errorf   = {}        # Error functions by state
        self.eoff     = {}        # EOF functions by state

        for s in self.stateinfo:
            self.funcsym[s] = []
            self.strsym[s] = []

        if len(tsymbols) == 0:
            self.log.error(&#039;No rules of the form t_rulename are defined&#039;)
            self.error = True
            return

        for f in tsymbols:
            t = self.ldict[f]
            states, tokname = _statetoken(f, self.stateinfo)
            self.toknames[f] = tokname

            if hasattr(t, &#039;__call__&#039;):
                if tokname == &#039;error&#039;:
                    for s in states:
                        self.errorf[s] = t
                elif tokname == &#039;eof&#039;:
                    for s in states:
                        self.eoff[s] = t
                elif tokname == &#039;ignore&#039;:
                    line = t.__code__.co_firstlineno
                    file = t.__code__.co_filename
                    self.log.error(&quot;%s:%d: Rule &#039;%s&#039; must be defined as a string&quot;, file, line, t.__name__)
                    self.error = True
                else:
                    for s in states:
                        self.funcsym[s].append((f, t))
            elif isinstance(t, StringTypes):
                if tokname == &#039;ignore&#039;:
                    for s in states:
                        self.ignore[s] = t
                    if &#039;\\&#039; in t:
                        self.log.warning(&quot;%s contains a literal backslash &#039;\\&#039;&quot;, f)

                elif tokname == &#039;error&#039;:
                    self.log.error(&quot;Rule &#039;%s&#039; must be defined as a function&quot;, f)
                    self.error = True
                else:
                    for s in states:
                        self.strsym[s].append((f, t))
            else:
                self.log.error(&#039;%s not defined as a function or string&#039;, f)
                self.error = True

        # Sort the functions by line number
        for f in self.funcsym.values():
            f.sort(key=lambda x: x[1].__code__.co_firstlineno)

        # Sort the strings by regular expression length
        for s in self.strsym.values():
            s.sort(key=lambda x: len(x[1]), reverse=True)

    # Validate all of the t_rules collected
    def validate_rules(self):
        for state in self.stateinfo:
            # Validate all rules defined by functions

            for fname, f in self.funcsym[state]:
                line = f.__code__.co_firstlineno
                file = f.__code__.co_filename
                module = inspect.getmodule(f)
                self.modules.add(module)

                tokname = self.toknames[fname]
                if isinstance(f, types.MethodType):
                    reqargs = 2
                else:
                    reqargs = 1
                nargs = f.__code__.co_argcount
                if nargs &gt; reqargs:
                    self.log.error(&quot;%s:%d: Rule &#039;%s&#039; has too many arguments&quot;, file, line, f.__name__)
                    self.error = True
                    continue

                if nargs &lt; reqargs:
                    self.log.error(&quot;%s:%d: Rule &#039;%s&#039; requires an argument&quot;, file, line, f.__name__)
                    self.error = True
                    continue

                if not _get_regex(f):
                    self.log.error(&quot;%s:%d: No regular expression defined for rule &#039;%s&#039;&quot;, file, line, f.__name__)
                    self.error = True
                    continue

                try:
                    c = re.compile(&#039;(?P&lt;%s&gt;%s)&#039; % (fname, _get_regex(f)), self.reflags)
                    if c.match(&#039;&#039;):
                        self.log.error(&quot;%s:%d: Regular expression for rule &#039;%s&#039; matches empty string&quot;, file, line, f.__name__)
                        self.error = True
                except re.error as e:
                    self.log.error(&quot;%s:%d: Invalid regular expression for rule &#039;%s&#039;. %s&quot;, file, line, f.__name__, e)
                    if &#039;#&#039; in _get_regex(f):
                        self.log.error(&quot;%s:%d. Make sure &#039;#&#039; in rule &#039;%s&#039; is escaped with &#039;\\#&#039;&quot;, file, line, f.__name__)
                    self.error = True

            # Validate all rules defined by strings
            for name, r in self.strsym[state]:
                tokname = self.toknames[name]
                if tokname == &#039;error&#039;:
                    self.log.error(&quot;Rule &#039;%s&#039; must be defined as a function&quot;, name)
                    self.error = True
                    continue

                if tokname not in self.tokens and tokname.find(&#039;ignore_&#039;) &lt; 0:
                    self.log.error(&quot;Rule &#039;%s&#039; defined for an unspecified token %s&quot;, name, tokname)
                    self.error = True
                    continue

                try:
                    c = re.compile(&#039;(?P&lt;%s&gt;%s)&#039; % (name, r), self.reflags)
                    if (c.match(&#039;&#039;)):
                        self.log.error(&quot;Regular expression for rule &#039;%s&#039; matches empty string&quot;, name)
                        self.error = True
                except re.error as e:
                    self.log.error(&quot;Invalid regular expression for rule &#039;%s&#039;. %s&quot;, name, e)
                    if &#039;#&#039; in r:
                        self.log.error(&quot;Make sure &#039;#&#039; in rule &#039;%s&#039; is escaped with &#039;\\#&#039;&quot;, name)
                    self.error = True

            if not self.funcsym[state] and not self.strsym[state]:
                self.log.error(&quot;No rules defined for state &#039;%s&#039;&quot;, state)
                self.error = True

            # Validate the error function
            efunc = self.errorf.get(state, None)
            if efunc:
                f = efunc
                line = f.__code__.co_firstlineno
                file = f.__code__.co_filename
                module = inspect.getmodule(f)
                self.modules.add(module)

                if isinstance(f, types.MethodType):
                    reqargs = 2
                else:
                    reqargs = 1
                nargs = f.__code__.co_argcount
                if nargs &gt; reqargs:
                    self.log.error(&quot;%s:%d: Rule &#039;%s&#039; has too many arguments&quot;, file, line, f.__name__)
                    self.error = True

                if nargs &lt; reqargs:
                    self.log.error(&quot;%s:%d: Rule &#039;%s&#039; requires an argument&quot;, file, line, f.__name__)
                    self.error = True

        for module in self.modules:
            self.validate_module(module)

    # -----------------------------------------------------------------------------
    # validate_module()
    #
    # This checks to see if there are duplicated t_rulename() functions or strings
    # in the parser input file.  This is done using a simple regular expression
    # match on each line in the source code of the given module.
    # -----------------------------------------------------------------------------

    def validate_module(self, module):
        try:
            lines, linen = inspect.getsourcelines(module)
        except IOError:
            return

        fre = re.compile(r&#039;\s*def\s+(t_[a-zA-Z_0-9]*)\(&#039;)
        sre = re.compile(r&#039;\s*(t_[a-zA-Z_0-9]*)\s*=&#039;)

        counthash = {}
        linen += 1
        for line in lines:
            m = fre.match(line)
            if not m:
                m = sre.match(line)
            if m:
                name = m.group(1)
                prev = counthash.get(name)
                if not prev:
                    counthash[name] = linen
                else:
                    filename = inspect.getsourcefile(module)
                    self.log.error(&#039;%s:%d: Rule %s redefined. Previously defined on line %d&#039;, filename, linen, name, prev)
                    self.error = True
            linen += 1

# -----------------------------------------------------------------------------
# lex(module)
#
# Build all of the regular expression rules from definitions in the supplied module
# -----------------------------------------------------------------------------
def lex(module=None, object=None, debug=False, optimize=False, lextab=&#039;lextab&#039;,
        reflags=int(re.VERBOSE), nowarn=False, outputdir=None, debuglog=None, errorlog=None):

    if lextab is None:
        lextab = &#039;lextab&#039;

    global lexer

    ldict = None
    stateinfo  = {&#039;INITIAL&#039;: &#039;inclusive&#039;}
    lexobj = Lexer()
    lexobj.lexoptimize = optimize
    global token, input

    if errorlog is None:
        errorlog = PlyLogger(sys.stderr)

    if debug:
        if debuglog is None:
            debuglog = PlyLogger(sys.stderr)

    # Get the module dictionary used for the lexer
    if object:
        module = object

    # Get the module dictionary used for the parser
    if module:
        _items = [(k, getattr(module, k)) for k in dir(module)]
        ldict = dict(_items)
        # If no __file__ attribute is available, try to obtain it from the __module__ instead
        if &#039;__file__&#039; not in ldict:
            ldict[&#039;__file__&#039;] = sys.modules[ldict[&#039;__module__&#039;]].__file__
    else:
        ldict = get_caller_module_dict(2)

    # Determine if the module is package of a package or not.
    # If so, fix the tabmodule setting so that tables load correctly
    pkg = ldict.get(&#039;__package__&#039;)
    if pkg and isinstance(lextab, str):
        if &#039;.&#039; not in lextab:
            lextab = pkg + &#039;.&#039; + lextab

    # Collect parser information from the dictionary
    linfo = LexerReflect(ldict, log=errorlog, reflags=reflags)
    linfo.get_all()
    if not optimize:
        if linfo.validate_all():
            raise SyntaxError(&quot;Can&#039;t build lexer&quot;)

    if optimize and lextab:
        try:
            lexobj.readtab(lextab, ldict)
            token = lexobj.token
            input = lexobj.input
            lexer = lexobj
            return lexobj

        except ImportError:
            pass

    # Dump some basic debugging information
    if debug:
        debuglog.info(&#039;lex: tokens   = %r&#039;, linfo.tokens)
        debuglog.info(&#039;lex: literals = %r&#039;, linfo.literals)
        debuglog.info(&#039;lex: states   = %r&#039;, linfo.stateinfo)

    # Build a dictionary of valid token names
    lexobj.lextokens = set()
    for n in linfo.tokens:
        lexobj.lextokens.add(n)

    # Get literals specification
    if isinstance(linfo.literals, (list, tuple)):
        lexobj.lexliterals = type(linfo.literals[0])().join(linfo.literals)
    else:
        lexobj.lexliterals = linfo.literals

    lexobj.lextokens_all = lexobj.lextokens | set(lexobj.lexliterals)

    # Get the stateinfo dictionary
    stateinfo = linfo.stateinfo

    regexs = {}
    # Build the master regular expressions
    for state in stateinfo:
        regex_list = []

        # Add rules defined by functions first
        for fname, f in linfo.funcsym[state]:
            regex_list.append(&#039;(?P&lt;%s&gt;%s)&#039; % (fname, _get_regex(f)))
            if debug:
                debuglog.info(&quot;lex: Adding rule %s -&gt; &#039;%s&#039; (state &#039;%s&#039;)&quot;, fname, _get_regex(f), state)

        # Now add all of the simple rules
        for name, r in linfo.strsym[state]:
            regex_list.append(&#039;(?P&lt;%s&gt;%s)&#039; % (name, r))
            if debug:
                debuglog.info(&quot;lex: Adding rule %s -&gt; &#039;%s&#039; (state &#039;%s&#039;)&quot;, name, r, state)

        regexs[state] = regex_list

    # Build the master regular expressions

    if debug:
        debuglog.info(&#039;lex: ==== MASTER REGEXS FOLLOW ====&#039;)

    for state in regexs:
        lexre, re_text, re_names = _form_master_re(regexs[state], reflags, ldict, linfo.toknames)
        lexobj.lexstatere[state] = lexre
        lexobj.lexstateretext[state] = re_text
        lexobj.lexstaterenames[state] = re_names
        if debug:
            for i, text in enumerate(re_text):
                debuglog.info(&quot;lex: state &#039;%s&#039; : regex[%d] = &#039;%s&#039;&quot;, state, i, text)

    # For inclusive states, we need to add the regular expressions from the INITIAL state
    for state, stype in stateinfo.items():
        if state != &#039;INITIAL&#039; and stype == &#039;inclusive&#039;:
            lexobj.lexstatere[state].extend(lexobj.lexstatere[&#039;INITIAL&#039;])
            lexobj.lexstateretext[state].extend(lexobj.lexstateretext[&#039;INITIAL&#039;])
            lexobj.lexstaterenames[state].extend(lexobj.lexstaterenames[&#039;INITIAL&#039;])

    lexobj.lexstateinfo = stateinfo
    lexobj.lexre = lexobj.lexstatere[&#039;INITIAL&#039;]
    lexobj.lexretext = lexobj.lexstateretext[&#039;INITIAL&#039;]
    lexobj.lexreflags = reflags

    # Set up ignore variables
    lexobj.lexstateignore = linfo.ignore
    lexobj.lexignore = lexobj.lexstateignore.get(&#039;INITIAL&#039;, &#039;&#039;)

    # Set up error functions
    lexobj.lexstateerrorf = linfo.errorf
    lexobj.lexerrorf = linfo.errorf.get(&#039;INITIAL&#039;, None)
    if not lexobj.lexerrorf:
        errorlog.warning(&#039;No t_error rule is defined&#039;)

    # Set up eof functions
    lexobj.lexstateeoff = linfo.eoff
    lexobj.lexeoff = linfo.eoff.get(&#039;INITIAL&#039;, None)

    # Check state information for ignore and error rules
    for s, stype in stateinfo.items():
        if stype == &#039;exclusive&#039;:
            if s not in linfo.errorf:
                errorlog.warning(&quot;No error rule is defined for exclusive state &#039;%s&#039;&quot;, s)
            if s not in linfo.ignore and lexobj.lexignore:
                errorlog.warning(&quot;No ignore rule is defined for exclusive state &#039;%s&#039;&quot;, s)
        elif stype == &#039;inclusive&#039;:
            if s not in linfo.errorf:
                linfo.errorf[s] = linfo.errorf.get(&#039;INITIAL&#039;, None)
            if s not in linfo.ignore:
                linfo.ignore[s] = linfo.ignore.get(&#039;INITIAL&#039;, &#039;&#039;)

    # 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 lextab and optimize:
        if outputdir is None:
            # If no output directory is set, the location of the output files
            # is determined according to the following rules:
            #     - If lextab specifies a package, files go into that package directory
            #     - Otherwise, files go in the same directory as the specifying module
            if isinstance(lextab, types.ModuleType):
                srcfile = lextab.__file__
            else:
                if &#039;.&#039; not in lextab:
                    srcfile = ldict[&#039;__file__&#039;]
                else:
                    parts = lextab.split(&#039;.&#039;)
                    pkgname = &#039;.&#039;.join(parts[:-1])
                    exec(&#039;import %s&#039; % pkgname)
                    srcfile = getattr(sys.modules[pkgname], &#039;__file__&#039;, &#039;&#039;)
            outputdir = os.path.dirname(srcfile)
        try:
            lexobj.writetab(lextab, outputdir)
            if lextab in sys.modules:
                del sys.modules[lextab]
        except IOError as e:
            errorlog.warning(&quot;Couldn&#039;t write lextab module %r. %s&quot; % (lextab, e))

    return lexobj

# -----------------------------------------------------------------------------
# runmain()
#
# This runs the lexer as a main program
# -----------------------------------------------------------------------------

def runmain(lexer=None, data=None):
    if not data:
        try:
            filename = sys.argv[1]
            f = open(filename)
            data = f.read()
            f.close()
        except IndexError:
            sys.stdout.write(&#039;Reading from standard input (type EOF to end):\n&#039;)
            data = sys.stdin.read()

    if lexer:
        _input = lexer.input
    else:
        _input = input
    _input(data)
    if lexer:
        _token = lexer.token
    else:
        _token = token

    while True:
        tok = _token()
        if not tok:
            break
        sys.stdout.write(&#039;(%s,%r,%d,%d)\n&#039; % (tok.type, tok.value, tok.lineno, tok.lexpos))

# -----------------------------------------------------------------------------
# @TOKEN(regex)
#
# This decorator function can be used to set the regex expression on a function
# when its docstring might need to be set in an alternative way
# -----------------------------------------------------------------------------

def TOKEN(r):
    def set_regex(f):
        if hasattr(r, &#039;__call__&#039;):
            f.regex = _get_regex(r)
        else:
            f.regex = r
        return f
    return set_regex

# Alternative spelling of the TOKEN decorator
Token = TOKEN
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib/python3.9/site-packages/sepolgen/lex.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib%2Fpython3.9%2Fsite-packages%2Fsepolgen' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>