SLY - Sly Lex Yacc

Warnings

• breaking The SLY project was officially retired by its author on December 21, 2025. No further maintenance or development is expected. Users are advised to consider other parsing libraries or fork the project for continued use.
  Fix: Migrate to an actively maintained parsing library (e.g., PLY, Lark) or fork SLY's source code if continued use is necessary.
• gotcha SLY is a modernization of the PLY project, but code written for PLY is generally not compatible with SLY. Direct migration of PLY code to SLY without modifications will likely fail.
  Fix: Rewrite PLY-based lexers and parsers to conform to SLY's API and conventions. Consult SLY's documentation for correct usage.
• gotcha SLY requires Python 3.6 or newer. It is not compatible with older Python versions.
  Fix: Ensure your project uses Python 3.6 or a more recent version.
• gotcha Lexer classes *must* define a `tokens` set specifying all possible token type names. Token names should generally be in all-caps. Incorrectly defined tokens or regex patterns are a common source of parsing issues.
  Fix: Always define `tokens` as a set of all-capitalized token names. Carefully review regular expressions and ensure they match the intended input. Utilize the `error` method in the Lexer for debugging unmatched characters.
• gotcha When defining parser rules, the `_()` decorator is crucial. Accessing parts of a rule (e.g., `expr PLUS expr`) requires careful indexing (e.g., `p.expr0`, `p.expr1`) if a symbol appears multiple times in a rule's right-hand side, or by name (e.g., `p.NUMBER`) otherwise.
  Fix: Refer to rule components using `p.symbolname` for unique symbols or `p.symbolnameN` (where N is a 0-indexed number) for repeated symbols. Consult the documentation for examples of `_()` decorator usage.

Install

• pip install sly Install stable version

Imports

• Lexer

  from sly import Lexer

  Lexer is used to break input text into tokens.
• Parser

  from sly import Parser

  Parser is used to recognize language syntax from a stream of tokens.

Quickstart

This quickstart demonstrates a simple calculator using SLY. It defines a lexer to tokenize input (numbers, IDs, operators) and a parser to build an abstract syntax tree and evaluate expressions, including variable assignments.

from sly import Lexer, Parser

class CalcLexer(Lexer):
    tokens = { NUMBER, ID, PLUS, MINUS, TIMES, DIVIDE, ASSIGN, LPAREN, RPAREN }
    literals = { '=', '+', '-', '*', '/', '(', ')' }

    # String containing ignored characters
    ignore = ' \t'

    # Regular expression rules for tokens
    NUMBER = r'\d+'
    ID = r'[a-zA-Z_][a-zA-Z0-9_]*'

    # Special rules for tokens
    def NUMBER(self, t):
        t.value = int(t.value)
        return t

    def ID(self, t):
        t.value = str(t.value)
        return t

    def error(self, t):
        print(f"Illegal character '{t.value[0]}' at line {t.lineno}")
        self.index += 1

class CalcParser(Parser):
    tokens = CalcLexer.tokens

    precedence = (
        ('left', PLUS, MINUS),
        ('left', TIMES, DIVIDE)
    )

    def __init__(self):
        self.names = { }

    @_('ID ASSIGN expr')
    def statement(self, p):
        self.names[p.ID] = p.expr
        return p.expr

    @_('expr')
    def statement(self, p):
        return p.expr

    @_('expr PLUS expr')
    def expr(self, p):
        return p.expr0 + p.expr1

    @_('expr MINUS expr')
    def expr(self, p):
        return p.expr0 - p.expr1

    @_('expr TIMES expr')
    def expr(self, p):
        return p.expr0 * p.expr1

    @_('expr DIVIDE expr')
    def expr(self, p):
        return p.expr0 / p.expr1

    @_('LPAREN expr RPAREN')
    def expr(self, p):
        return p.expr

    @_('NUMBER')
    def expr(self, p):
        return p.NUMBER

    @_('ID')
    def expr(self, p):
        try:
            return self.names[p.ID]
        except LookupError:
            print(f"Undefined name '{p.ID}'")
            return 0

    def error(self, p):
        if p:
            print(f"Syntax error at token {p.type}, value '{p.value}'")
        else:
            print("Syntax error at EOF")

if __name__ == '__main__':
    lexer = CalcLexer()
    parser = CalcParser()
    while True:
        try:
            text = input('calc > ')
            if text.lower() == 'quit':
                break
            result = parser.parse(lexer.tokenize(text))
            if result is not None: # Only print if there was a calculable result
                print(result)
        except EOFError:
            break
        except Exception as e:
            print(f"Error: {e}")