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')

parser.add_argument(
    '--lex',
    default=False,
)

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",
    "type": "TYPE_TYPE",

    "and": "AND",
    "or": "OR",

    "for": "LOOP",
}

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",
    "PIPE",


    "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 = r'='

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_PIPE = 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)

if args.lex:
    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'
    ARRAY = 'array'
    MAP = 'map'

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 AstNodeVariableTypes(AstNode):
    def __init__(self, operator, left, right):
        self.operator = operator
        self.left = left
        self.right = right

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

class AstNodeVariableTypeMap(AstNode):
    def __init__(self, key_type, value_type):
        self.key_type = key_type
        self.value_type = value_type

class AstNodeMapElement(AstNode):
    def __init__(self, key, value):
        self.key = key
        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

class AstNodeLoop(AstNode):
    def __init__(self, iteratee, key_id, value_id, body):
        self.iteratee = iteratee
        self.key_id = key_id
        self.value_id = value_id
        self.body = body

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



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



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
                 | function_call SEMICOLON
                 | loop
                 | pipe SEMICOLON
                 | 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 COMMA
                                       | function_declaration_parameter
                                       |'''

    parameters = [p[1]]
    if len(p) == 4:
        parameters.extend(p[3])

    p[0] = parameters


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

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




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

    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 COMMA
                                | function_call_parameter
                                |'''

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

    p[0] = parameters


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

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




def p_loop(p):
    '''loop : LOOP PARENTHESIS_LEFT expression PARENTHESIS_RIGHT PIPE identifier COMMA identifier PIPE BRACE_LEFT statements BRACE_RIGHT'''

    p[0] = AstNodeLoop(p[3], p[6], p[8], p[11])




def p_pipe(p):
    '''pipe : expression OPERATOR_PIPE pipe
            | expression OPERATOR_PIPE function_call'''

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




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_primitive(p):
    '''variable_type_primitive : TYPE_INTEGER
                               | TYPE_STRING'''
    p[0] = p[1]

def p_variable_types_primitive(p):
    '''variable_types_primitive : variable_type_primitive AND variable_types_primitive
                                | variable_type_primitive OR variable_types_primitive
                                | variable_type_primitive'''

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


def p_variable_type(p):
    '''variable_type : variable_type_array
                     | variable_type_map
                     | variable_type_primitive
                     | TYPE_TYPE
                     | FUNCTION'''
    p[0] = p[1]


def p_variable_types(p):
    '''variable_types : variable_type AND variable_types
                      | variable_type OR variable_types
                      | variable_type'''

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


def p_variable_type_array(p):
    '''variable_type_array : BRACKET_LEFT variable_types BRACKET_RIGHT'''

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


def p_variable_type_map(p):
    '''variable_type_map : BRACKET_LEFT variable_types BRACKET_RIGHT BRACKET_LEFT variable_types BRACKET_RIGHT'''

    p[0] = AstNodeVariableTypeMap(p[2], p[5])



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_array(p):
    '''array : BRACKET_LEFT array_elements BRACKET_RIGHT'''

    p[0] = AstNodeExpression(AstNodeExpressionType.ARRAY, p[2])


def p_array_elements(p):
    '''array_elements : array_element COMMA array_elements
                      | array_element COMMA
                      | array_element'''

    elements = [p[1]]
    if len(p) == 4:
        elements.extend(p[3])

    p[0] = elements


def p_array_element(p):
    '''array_element : expression'''

    p[0] = p[1]


def p_map(p):
    '''map : BRACKET_LEFT map_elements BRACKET_RIGHT'''

    p[0] = AstNodeExpression(AstNodeExpressionType.MAP, p[2])


def p_map_elements(p):
    '''map_elements : map_element COMMA map_elements
                    | map_element COMMA
                    | map_element'''

    elements = [p[1]]
    if len(p) == 4:
        elements.extend(p[3])

    p[0] = elements


def p_map_element(p):
    '''map_element : map_element_key ASSIGN expression'''

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

def p_map_element_key(p):
    '''map_element_key : identifier
                       | number
                       | string'''

    p[0] = p[1]


def p_expression(p):
    '''expression : identifier
                  | number
                  | string
                  | array
                  | map
                  | 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):
    line_start_column = input.rfind('\n', 0, p.lexpos) + 1
    column = (p.lexpos - line_start_column) + 1
    print("Syntax error in input! Line: {line}, Column: {column}".format(line=p.lineno, column=column), p)




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




if result:
    for ast_node in result:
        print(ast_node)




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