[PYTHON] Let's make a simple language with PLY 1

Introduction

background

• Interest in creating a language
• I was interested in LLVM now and was interested in lexical analysis and parsing.
• I couldn't write C or C ++, but I had touched python

What is PLY

• Python lexical / parsing library
• The following is implemented in python and summarized
• Lexical analyzer lex
• Parser yacc

Preparation

Install PLY

$ pip install ply

• It seems that it supports both python3 and python2
• Is there a problem with python3.6? Something like that on a github issue ...

Decide what to implement this time

• Variable
• Function to exit the console
• For the time being, the name is exit
• A function that displays characters on the console
• Put for the time being
• Comments from #
• Ignore tab spaces

Implementation

Lexical analysis

• The code created this time is shown below.

lex.py

import ply.lex as lex

tokens = (
  # Literals
  'ID',

  # Function
  'PUT', 'EXIT',
)

# Identifiers at var
t_ID = r'(?!put|exit)[A-Za-z_][A-Za-z0-9_]*'

# Function
t_PUT = r'put'
t_EXIT = r'exit'
# space is ignore

# space and tab is ignore
t_ignore = ' \t'

# comment  
t_ignore_COMMENT = r'\#.*'

# error handling
def t_error(t):
    print("Illegal characters'%s'" % t.value[0])
    t.lexer.skip(1)

#
lex.lex(debug=0)

• token = ( )
• The element you want to analyze in parentheses
• Lexical analysis rules
• Expressed as a regular expression
• Naming convention is t_ token name
• t_ignore skips strings
• t_ignore_COMMENT can define comments
• t_error is called when there is no match
• Build with lex.lex ()
• I don't understand regular expressions well, so it's a lot of work.
• I want to be able to write beautifully in regular expressions (scam to study)

Parsing

The code created below is shown

yacc.py

import ply.yacc as yacc
from lex import tokens
import sys

names = {}

# var (id)
def p_expr_id(p):
    'expr : ID'
    try:
        p[0] = names[p[1]]
    except LookupError:
        print('Undefine var name %s' %p)
        p[0] = 0

# exit function
def p_exit(p):
    'expr : EXIT'   
    print('See You!')
    sys.exit()

# empty
def p_empty(p):
    'empty :'
    pass

# syntax error
def p_error(p):
    print ('Syntax error in input %s' %p)

parser = yacc.yacc()

# Debug
def parse(data, debug=0):  
    return yacc.parse(data, debug=debug)
    
if __name__ == '__main__':  
    while True:
        try:
            s = input('>>> ')
        except EOFError:
            break
        if not s:
            continue
        result = parser.parse(s)
        print (result)

• names = {}
• Dictionary for storing variable names and values
• p_expr_id
• Set ID (p [1]) to expr (p [0]) as variable name *'expr: ID is passed by p [0]: p [1]
• p_exit
• Display See You! And exit the console
• You can use python's sys.exit () function
• Debug
• Omitted

Try to move

Actually, I defined a variable, but I can't do anything at the moment All you can do is try the exit function

Execution

$ python yacc.py
>>> exit
See You!
$

in conclusion

Somehow it became a screen like that and I got out with exit The explanation has become rough towards the end

Referenced

I made an original language "PPAPScript" that imaged PPAP (Penpainappoappopen) with Python, [ryo-ma](http: / /qiita.com/ryo-ma).