Metadata-Version: 2.1
Name: yalr
Version: 0.0.5
Summary: Yet Another LR(1) implementation
Home-page: https://github.com/jan-grant/python-yalr
Author: jan grant
Author-email: jang@ioctl.org
License: Copyright 2016 Jan Grant (jang@ioctl.org)        
           Licensed under the Apache License, Version 2.0 (the "License");
           you may not use this file except in compliance with the License.
           You may obtain a copy of the License at        
               http://www.apache.org/licenses/LICENSE-2.0        
           Unless required by applicable law or agreed to in writing, software
           distributed under the License is distributed on an "AS IS" BASIS,
           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
           See the License for the specific language governing permissions and
           limitations under the License.                
Platform: any
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: YACC
Classifier: Topic :: Software Development :: Code Generators
Classifier: Topic :: Software Development :: Compilers
Classifier: Topic :: Software Development :: Interpreters
License-File: LICENCE.md
Requires-Dist: six

Yet Another LR Implementation
=============================

This is another implementation of the classic LR(1) parsing
algorithm, along with Knuth's LR(1) table generation algorithm.

Rather than follow the model of tools like yacc and require
external code generation, this library is driven dynamically
from Python code.

An obvious question is, "why?"

Two reasons:

- firstly, to experiment with surface syntax for expressing
  grammars in Python code in as uninvasive a way as possible.

  The package "ptk" takes a similar approach here.

- secondly, to provide a playground to look at other
  "cutting-edge" parsing algorithms, as a basis for improving
  my own understanding of them.

By "cutting-edge" I'm largely referring to the late 1970s.

The current implementation is largely inspired by yacc,
including yacc's various deficiencies:

- there's a linearisation used for reduce/reduce conflict
  resolution;

- there's a linearisation used for token precedence.

In practice, it's easy to get bitten by both of these - as
it is for the default shift/reduce resolution to mask
errors. A more flexible partial ordering is certainly feasible.

Credits
=======

Some of the example grammars included in the tests are derived
from the (Red) Dragon Book, which I've had since I was about 16;
it's a book which definitely shaped my life.

I've no idea how the reference numbers line up with later
additions.

    Compilers: Principles, Techniques, and Tools (1986)
    by Alfred V. Aho, Ravi Sethi and Jeffrey D. Ullman



