path: root/henshin

#!/bin/env python3


import sys
import argparse
import logging
import ply.lex as lex
import ply.yacc as yacc
from enum import Enum



# args

parser = argparse.ArgumentParser(
    prog='henshin'
)

parser.add_argument('filename')

args = parser.parse_args()


input = open(args.filename).read()



# log

logging.basicConfig(
    level = logging.DEBUG,
    filename = "parselog.txt",
    filemode = "w",
)

log = logging.getLogger()



# Lexer

reserved = {
    "function": "FUNCTION",
    "if": "IF",
    "else": "ELSE",
    "return": "RETURN",
    "const": "CONST",
    "var": "VAR",


    "integer": "TYPE_INTEGER",
    "string": "TYPE_STRING",
    "void": "TYPE_VOID",
}

tokens = [
    "OPERATOR_PLUS",
    "OPERATOR_MINUS",
    "OPERATOR_MULTIPLY",
    "OPERATOR_DIVIDE",
    "ASSIGN",

    "OPERATOR_PIPE",
    "OPERATOR_PIPE_REPLACEMENT",


    "PARENTHESIS_LEFT",
    "PARENTHESIS_RIGHT",
    "BRACE_LEFT",
    "BRACE_RIGHT",
    "BRACKET_LEFT",
    "BRACKET_RIGHT",


    "AND",
    "OR",
    "BIT_AND",
    "BIT_OR",


    "NAMESPACE_ACCESSOR",


    "COMMA",
    "COLON",
    "SEMICOLON",


    "IDENTIFIER",
    "NUMBER",
    "STRING",
    "COMMENT",
] + list(reserved.values())


t_OPERATOR_PLUS = r'\+'
t_OPERATOR_MINUS = r'-'
t_OPERATOR_MULTIPLY = r'\*'
t_OPERATOR_DIVIDE = r'/'
t_ASSIGN = '='

t_OPERATOR_PIPE = r'\|>'
t_OPERATOR_PIPE_REPLACEMENT = r'\$'


t_PARENTHESIS_LEFT = r'\('
t_PARENTHESIS_RIGHT = r'\)'
t_BRACKET_LEFT = r'\['
t_BRACKET_RIGHT = r'\]'
t_BRACE_LEFT = r'{'
t_BRACE_RIGHT = r'}'


t_AND = r'\&\&'
t_OR = r'\|\|'
t_BIT_AND = r'\&'
t_BIT_OR = r'\|'


t_NAMESPACE_ACCESSOR = r'\.'


t_COMMA = r','
t_COLON = r':'
t_SEMICOLON = r';'


def t_IDENTIFIER(t):
    r'[a-zA-Z][a-zA-Z0-9_]*'

    t.type = reserved.get(t.value, 'IDENTIFIER')

    return t

def t_NUMBER(t):
    r'[0-9]+'

    t.value = int(t.value)

    return t

def t_STRING(t):
    r'(".+"|\'.*\')'

    return t

def t_COMMENT(t):
    r'//.*'

    pass


def t_newline(t):
    r'\n+'

    t.lexer.lineno += len(t.value)

t_ignore = ' \t'

def t_error(t):
    print("undefined: '%s'" % t.value[0])
    t.lexer.skip(1)


lexer = lex.lex(debug=True, debuglog=log)
lexer.input(input)

lineno = 0
for token in lexer:
    if token.lineno != lineno:
        lineno = token.lineno
        print("\nLine %s:" % token.lineno)

    # print('%s: "%s" --' % (token.type, token.value), end=' ')
    print(token.value, end=' ')
print("\n")



# Parser

class AstNodeExpressionType(Enum):
    IDENTIFIER = 'identifier'
    NUMBER = 'number'
    STRING = 'string'

class AstNode: pass

class AstNodeVariableDeclarationStatement(AstNode):
    def __init__(self, type, name, value_type, value):
        self.type = type
        self.name = name
        self.value_type = value_type
        self.value = value

class AstNodeVariableReassignmentStatement(AstNode):
    def __init__(self, name, value):
        self.name = name
        self.value = value

class AstNodeExpression(AstNode):
    def __init__(self, type, value):
        self.type = type
        self.value = value

class AstNodeOperatorExpression(AstNode):
    def __init__(self, type, left, right):
        self.type = type
        self.left = left
        self.right = right

class AstNodeFunctionDeclaration(AstNode):
    def __init__(self, name, parameters, return_type, body):
        self.name = name
        self.parameters = parameters
        self.return_type = return_type
        self.body = body

class AstNodeFunctionDeclarationParameter(AstNode):
    def __init__(self, name, type):
        self.name = name
        self.type = type

class AstNodeReturnStatement(AstNode):
    def __init__(self, expression):
        self.expression = expression

class AstNodeFunctionCall(AstNode):
    def __init__(self, name, parameters):
        self.name = name
        self.parameters = parameters

class AstNodeFunctionCallParameter(AstNode):
    def __init__(self, name, value):
        self.name = name
        self.value = value


precedence = (
    ('left', 'OPERATOR_PLUS', 'OPERATOR_MINUS'),
    ('left', 'OPERATOR_MULTIPLY', 'OPERATOR_DIVIDE'),
)


def p_statements(p):
    '''statements : statement
                  | statement statements'''

    def resolve_nodes(node, level):
        node_dict = node.__dict__
        for property in node_dict:
            node_value = node_dict[property]

            if isinstance(node_value, AstNode):
                print('> '*level, property, node_value.__class__.__name__)
                resolve_nodes(node_value, level+1)
            elif isinstance(node_value, list):
                list_length = len(node_value)
                print('> '*level, property + '[' + str(list_length) + ']:')

                for idx in range(list_length):
                    item = node_value[idx]

                    print('> '*(level+1), str(idx+1)+'.', item.__class__.__name__)
                    resolve_nodes(item, level+2)
            else:
                print('> '*level, property, node_dict[property])

    if p[1]:
        print(p[1].__class__.__name__)
        resolve_nodes(p[1], 0)

    statements = [p[1]]
    if len(p) > 2:
        statements.extend(p[2])
    p[0] = statements

def p_statement(p):
    '''statement : variable_declaration_statement
                 | variable_reassignment_statement
                 | function_declaration
                 | return_statement'''

    p[0] = p[1]


def p_function_declaration(p):
    '''function_declaration : FUNCTION IDENTIFIER PARENTHESIS_LEFT function_declaration_parameters PARENTHESIS_RIGHT COLON return_type BRACE_LEFT statements BRACE_RIGHT'''

    p[0] = AstNodeFunctionDeclaration(p[2], p[4], p[7], p[9])

def p_function_declaration_parameters(p):
    '''function_declaration_parameters : function_declaration_parameter COMMA function_declaration_parameters
                                       | function_declaration_parameter
                                       |'''

    parameters = [p[1]]
    if len(p) > 2:
        parameters.append(p[3])

    p[0] = parameters

def p_function_declaration_parameter(p):
    '''function_declaration_parameter : IDENTIFIER COLON variable_type'''

    p[0] = AstNodeFunctionDeclarationParameter(p[1], p[3])


def p_function_call(p):
    '''function_call : IDENTIFIER PARENTHESIS_LEFT function_call_parameters PARENTHESIS_RIGHT SEMICOLON'''

    p[0] = AstNodeFunctionCall(p[1], p[3])

def p_function_call_parameters(p):
    '''function_call_parameters : function_call_parameter COMMA function_call_parameters
                                | function_call_parameter
                                |'''

    parameters = [p[1]]
    if len(p) > 2:
        parameters.append(p[3])

    p[0] = parameters

def p_function_call_parameter(p):
    '''function_call_parameter : IDENTIFIER ASSIGN expression
                               | expression'''

    if len(p) > 2:
        p[0] = AstNodeFunctionCallParameter(p[1], p[3])
    else:
        p[0] = AstNodeFunctionCallParameter("", p[1])


def p_variable_declaration_statement(p):
    '''variable_declaration_statement : variable_declarator IDENTIFIER COLON variable_type ASSIGN expression SEMICOLON'''

    p[0] = AstNodeVariableDeclarationStatement(p[1], p[2], p[4], p[6])

def p_variable_reassignment_statement(p):
    '''variable_reassignment_statement : IDENTIFIER ASSIGN expression SEMICOLON'''

    p[0] = AstNodeVariableReassignmentStatement(p[1], p[3])

def p_variable_declarator(p):
    '''variable_declarator : CONST
                           | VAR'''
    p[0] = p[1]

def p_variable_type(p):
    '''variable_type : TYPE_INTEGER
                     | TYPE_STRING'''
    p[0] = p[1]


def p_return_statement(p):
    '''return_statement : RETURN expression SEMICOLON'''

    p[0] = AstNodeReturnStatement(p[2])

def p_return_type(p):
    '''return_type : variable_type
                     | TYPE_VOID'''
    p[0] = p[1]


def p_identifier(p):
    '''identifier : IDENTIFIER'''

    p[0] = AstNodeExpression(AstNodeExpressionType.IDENTIFIER, p[1])

def p_number(p):
    '''number : NUMBER'''

    p[0] = AstNodeExpression(AstNodeExpressionType.NUMBER, p[1])

def p_string(p):
    '''string : STRING'''

    p[0] = AstNodeExpression(AstNodeExpressionType.STRING, p[1])

def p_expression(p):
    '''expression : identifier
                  | number
                  | string
                  | function_call
                  | expression OPERATOR_PLUS expression
                  | expression OPERATOR_MINUS expression
                  | expression OPERATOR_MULTIPLY expression
                  | expression OPERATOR_DIVIDE expression'''

    if len(p) == 4:
        p[0] = AstNodeOperatorExpression(p[2], p[1], p[3])
    else:
        p[0] = p[1]


def p_error(p):
    print("Syntax error in input!", p)


parser = yacc.yacc(debug=True, debuglog=log)
result = parser.parse(input)
# print(result)

# if __name__ == "__main__":
#     lex.runmain()