dionyziz/llama

A llama implementation in Python

llama

A llama implementation in Python.

Resources

• Llama spec in greek
• PLY: lex/yacc framework in Python.
• pylint: Static analysis of Python code.
• nose: Easy test discovery.
• sure: DSL for human-readable assertions in Python.
• flake8: Python style checker.

License

llama is released under the MIT License.

llama's Issues

Array of int ref parses in incorrect order

The type of array of int ref parses as an (array of int) ref instead of array of (int ref).

The following test fails:

_assert_equivalent("array of int ref", "array of (int ref)")

Here's the actual VS expected AST result:

X = ASTNode:Ref with attributes:
    * copy_pos = '(non-scalar of type method)'
    * lexpos = '1'
    * lineno = '1'
    * type = 'ASTNode:Array with attributes:
        * copy_pos = '(non-scalar of type method)'
        * dimensions = '1'
        * lexpos = '1'
        * lineno = '1'
        * type = 'ASTNode:Int with attributes:
            * copy_pos = '(non-scalar of type method)'
            * lexpos = '10'
            * lineno = '1'
            * name = 'int'''
    and
Y = ASTNode:Array with attributes:
    * copy_pos = '(non-scalar of type method)'
    * dimensions = '1'
    * lexpos = '1'
    * lineno = '1'
    * type = 'ASTNode:Ref with attributes:
        * copy_pos = '(non-scalar of type method)'
        * lexpos = '10'
        * lineno = '1'
        * type = 'ASTNode:Int with attributes:
            * copy_pos = '(non-scalar of type method)'
            * lexpos = '11'
            * lineno = '1'
            * name = 'int'''
X is a Ref and Y is a Array instead

Unit test line tracking for lexer and parser

OCaml-ise errors/warnings.

Make the errors/warnings emmitted by the compiler follow the format of the standard OCaml compiler, ocamlc.

Function type must involve all input parameters

Currently, function type has a fromType and toType. However, this does not allow semantic validation that the return type is not of function type, as required by the spec (section 1.2, pg. 7, line 19).

Change function type to include a tuple of fromType parameters.

After changing the data structure, change the type semantic check to check that functions never return functions.

Get rid of parser_db

Rework the optimizations and other features of parser_db into the regular parser library, as they are useful beyond testing.

Even simpler API

Make the following work:

from compiler import parse
parse.parse("int ref ref", "type")

Use logging

Investigate PLY parser caching

There seems to be an interaction between cached parsers and the parsing tables made by make prepare, resulting in reuse of a non-complete parser during functional tests.

Investigate.

Unit test operator precedence

Add `code` attribute to ast.Node

This attribute will contain the source code that was used to construct the particular ast.Node and can be used for debugging purposes.

For example, an ast.BinaryExpression + node could have code value "(f 2) + 3".

Line tracking in every ast node

Use error module for parser syntax error

`!new int` does not parse

!new int does not parse from the expr parser state. This is because the bang operator is defined as taking a simple expr as an argument, but new does not return a simple expression.

Consider converting new to be a simple expression.

Refactor parse/lex/eval to use a very simple API

parse() should take a string and do parsing, with no explicit lexer, mocks, and with optimize=1

Test for conflicts in parser.out when running `make prepare`

Transform TypeDefList into a python list

Clean-up code related to boolean values when literal bools are used

Starting from non-program state has caching issues

dionyziz@erdos ~/llama (validtypes) % python3
Python 3.4.1 (default, May 19 2014, 13:10:29)
[GCC 4.2.1 Compatible Apple LLVM 5.1 (clang-503.0.40)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from compiler import parse
>>> p = parse.Parser(start="type")
>>> p.parse("int ref ref")
<stdin>: 1:1: error: Syntax error on token INT  int
ASTNode:Program with attributes:
    * copy_pos = '(non-scalar of type method)'
    * lexpos = 'None'
    * lineno = 'None'
    * list = '[]'
>>> p = parse.Parser(start="type", optimize=False)
>>> p = parse.Parser(start="type", optimize=False, debug=False)
>>> p.parse("int ref ref")
ASTNode:Ref with attributes:
    * copy_pos = '(non-scalar of type method)'
    * lexpos = '1'
    * lineno = '1'
    * type = 'ASTNode:Ref with attributes:
        * copy_pos = '(non-scalar of type method)'
        * lexpos = '1'
        * lineno = '1'
        * type = 'ASTNode:Int with attributes:
            * copy_pos = '(non-scalar of type method)'
            * lexpos = '1'
            * lineno = '1'
            * name = 'int'''
>>>

Parser appends on the wrong side of lists.

When reducing rules that result to lists or sequences, the parser currently appends elements at the start and not the end of lists. This is a possible performance issue.

Proposed fix: Make the parser append at the end of lists, but reverse the said lists just before embedding them inside the AST Nodes. This will maintain program order.

Accompany with appropriate unit tests demonstrating correctness of patch.

Introduce the library into the symbol table.

Populate the symbol table with the library namespace.
See the TODO left at the SymbolTable initializer.

`int -> int ref` must parse as int -> (int ref)

The following test case fails:

self._assert_equivalent("int -> int ref", "int -> (int ref)", "type")

It may help to introduce a precedence for ref.

A pattern should allow nested constructor calls without parenthesization

The following pattern is currently not allowed at the parser level:

TreeNode EmptyNode

However, the following parses fine:

TreeNode (EmptyNode)

Fix the parser so that both of them pass and are parsed to equivalent expressions.

Tests for symbol table.

Use a separate logger for each module using Python's logging API

Refactor errors/warnings DRY

Redefining built-in types should be a semantic error, not a syntax error

Current implementation of parser rejects the following definition of built-in bool type as a syntax error.

test bool = Bool

The parser should be refactored to accept the above definition and delegate semantic checking to the type module. The relevant features of type.Table and the respective tests are already in place (branch renelvon/test).

`foo 42koko` should fail at the lexing level

Combine lexer build/__init__ and parser build/__init__

Refactor `string` into `array of char`.

According to the spec, a string literal has type array of char and is stored as a null-terminated string.

Refactor lexer, parser and type module to match the spec.