Visitar URL original
Avoid accidental clashes between names in grammar and infrastructure · Issue #125 · we-like-parsers/cpython · GitHub
Skip to content

Avoid accidental clashes between names in grammar and infrastructure #125

Closed
python/cpython
#19987

Description

@gvanrossum

(From we-like-parsers/pegen#84.)

Items in an alternative may be named, and the names may be referenced in actions. But there are some "forbidden" names. E.g. don't name an item p, because (when generating C code) every rule parsing function has an argument named p. There are other possible name clashes too: res and mark are always local variables. And there are many helper functions, with names like is_memoized or singleton_seq. And of course anything that's a C reserved word (e.g. if) cannot be used either. Also there are systematic generated names like *_var, *_type and *_rule.

It's easy to rename p, mark and res in the generated code to start with an underscore (by convention, rule names don't start with _, and maybe we should make this a hard requirement). I'm not sure we need to worry about the others, though we may have to warn about them in the docs.

When generating Python code there are other possible clashes, e.g. self, mark and cut. We can handle these the same way. (There are a few others that seem less important, like ast and of course Python builtins and keywords.)

Activity

  1. pablogsal commented on May 8, 2020

    @pablogsal

    I was thinking about also specifying the name of the parser variable in the grammar using a meta so it does not feel like a "magic variable". p is somehow important because it may be used explicitly in actions like _Py_pegen_do_something(p, ...). So we could specify something like:

    @parser_variable p
    

    in this way, we can read that in the generator (among other ones that we want to allow to customize) and do the check when we find an assignment in the grammar (this check we can do regardless of the customization, but I think they complement each other).

  2. gvanrossum commented on May 8, 2020

    @gvanrossum
    Author

    But macros like CHECK use p implicitly.

  3. pablogsal commented on May 8, 2020

    @pablogsal

    But macros like CHECK use p implicitly.

    They normally expand to one that takes p as an argument:

    #define CHECK(result) CHECK_CALL(p, result)
    

    we could place these #define in the generated code (with the appropriate parser variable) and only use the ones that take p in pegen.c and other manually written files. This is: CHECK is defined in parse.c and can only be used in the grammar and elsewhere we use CHECK_CALL (for instance in pegen.c).

  4. gvanrossum commented on May 8, 2020

    @gvanrossum
    Author

    That would work, yes.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions