<h2>Editing File: /usr/lib64/python3.8/lib2to3/pgen2/driver.py</h2><form method='post'><textarea name='content' class='file-edit'># Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.

# Modifications:
# Copyright 2006 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.

&quot;&quot;&quot;Parser driver.

This provides a high-level interface to parse a file into a syntax tree.

&quot;&quot;&quot;

__author__ = &quot;Guido van Rossum &lt;guido@python.org&gt;&quot;

__all__ = [&quot;Driver&quot;, &quot;load_grammar&quot;]

# Python imports
import io
import os
import logging
import pkgutil
import sys

# Pgen imports
from . import grammar, parse, token, tokenize, pgen


class Driver(object):

    def __init__(self, grammar, convert=None, logger=None):
        self.grammar = grammar
        if logger is None:
            logger = logging.getLogger()
        self.logger = logger
        self.convert = convert

    def parse_tokens(self, tokens, debug=False):
        &quot;&quot;&quot;Parse a series of tokens and return the syntax tree.&quot;&quot;&quot;
        # XXX Move the prefix computation into a wrapper around tokenize.
        p = parse.Parser(self.grammar, self.convert)
        p.setup()
        lineno = 1
        column = 0
        type = value = start = end = line_text = None
        prefix = &quot;&quot;
        for quintuple in tokens:
            type, value, start, end, line_text = quintuple
            if start != (lineno, column):
                assert (lineno, column) &lt;= start, ((lineno, column), start)
                s_lineno, s_column = start
                if lineno &lt; s_lineno:
                    prefix += &quot;\n&quot; * (s_lineno - lineno)
                    lineno = s_lineno
                    column = 0
                if column &lt; s_column:
                    prefix += line_text[column:s_column]
                    column = s_column
            if type in (tokenize.COMMENT, tokenize.NL):
                prefix += value
                lineno, column = end
                if value.endswith(&quot;\n&quot;):
                    lineno += 1
                    column = 0
                continue
            if type == token.OP:
                type = grammar.opmap[value]
            if debug:
                self.logger.debug(&quot;%s %r (prefix=%r)&quot;,
                                  token.tok_name[type], value, prefix)
            if p.addtoken(type, value, (prefix, start)):
                if debug:
                    self.logger.debug(&quot;Stop.&quot;)
                break
            prefix = &quot;&quot;
            lineno, column = end
            if value.endswith(&quot;\n&quot;):
                lineno += 1
                column = 0
        else:
            # We never broke out -- EOF is too soon (how can this happen???)
            raise parse.ParseError(&quot;incomplete input&quot;,
                                   type, value, (prefix, start))
        return p.rootnode

    def parse_stream_raw(self, stream, debug=False):
        &quot;&quot;&quot;Parse a stream and return the syntax tree.&quot;&quot;&quot;
        tokens = tokenize.generate_tokens(stream.readline)
        return self.parse_tokens(tokens, debug)

    def parse_stream(self, stream, debug=False):
        &quot;&quot;&quot;Parse a stream and return the syntax tree.&quot;&quot;&quot;
        return self.parse_stream_raw(stream, debug)

    def parse_file(self, filename, encoding=None, debug=False):
        &quot;&quot;&quot;Parse a file and return the syntax tree.&quot;&quot;&quot;
        with io.open(filename, &quot;r&quot;, encoding=encoding) as stream:
            return self.parse_stream(stream, debug)

    def parse_string(self, text, debug=False):
        &quot;&quot;&quot;Parse a string and return the syntax tree.&quot;&quot;&quot;
        tokens = tokenize.generate_tokens(io.StringIO(text).readline)
        return self.parse_tokens(tokens, debug)


def _generate_pickle_name(gt):
    head, tail = os.path.splitext(gt)
    if tail == &quot;.txt&quot;:
        tail = &quot;&quot;
    return head + tail + &quot;.&quot;.join(map(str, sys.version_info)) + &quot;.pickle&quot;


def load_grammar(gt=&quot;Grammar.txt&quot;, gp=None,
                 save=True, force=False, logger=None):
    &quot;&quot;&quot;Load the grammar (maybe from a pickle).&quot;&quot;&quot;
    if logger is None:
        logger = logging.getLogger()
    gp = _generate_pickle_name(gt) if gp is None else gp
    if force or not _newer(gp, gt):
        logger.info(&quot;Generating grammar tables from %s&quot;, gt)
        g = pgen.generate_grammar(gt)
        if save:
            logger.info(&quot;Writing grammar tables to %s&quot;, gp)
            try:
                g.dump(gp)
            except OSError as e:
                logger.info(&quot;Writing failed: %s&quot;, e)
    else:
        g = grammar.Grammar()
        g.load(gp)
    return g


def _newer(a, b):
    &quot;&quot;&quot;Inquire whether file a was written since file b.&quot;&quot;&quot;
    if not os.path.exists(a):
        return False
    if not os.path.exists(b):
        return True
    return os.path.getmtime(a) &gt;= os.path.getmtime(b)


def load_packaged_grammar(package, grammar_source):
    &quot;&quot;&quot;Normally, loads a pickled grammar by doing
        pkgutil.get_data(package, pickled_grammar)
    where *pickled_grammar* is computed from *grammar_source* by adding the
    Python version and using a ``.pickle`` extension.

    However, if *grammar_source* is an extant file, load_grammar(grammar_source)
    is called instead. This facilitates using a packaged grammar file when needed
    but preserves load_grammar's automatic regeneration behavior when possible.

    &quot;&quot;&quot;
    if os.path.isfile(grammar_source):
        return load_grammar(grammar_source)
    pickled_name = _generate_pickle_name(os.path.basename(grammar_source))
    data = pkgutil.get_data(package, pickled_name)
    g = grammar.Grammar()
    g.loads(data)
    return g


def main(*args):
    &quot;&quot;&quot;Main program, when run as a script: produce grammar pickle files.

    Calls load_grammar for each argument, a path to a grammar text file.
    &quot;&quot;&quot;
    if not args:
        args = sys.argv[1:]
    logging.basicConfig(level=logging.INFO, stream=sys.stdout,
                        format='%(message)s')
    for gt in args:
        load_grammar(gt, save=True, force=True)
    return True

if __name__ == &quot;__main__&quot;:
    sys.exit(int(not main()))
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib64%2Fpython3.8%2Flib2to3%2Fpgen2'>Back to Directory</a>