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
import collections.abc



# args

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

parser.add_argument('filename')

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

parser.add_argument(
    '--debug',
    default=False,
    action=argparse.BooleanOptionalAction,
)

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'(".*?")'

    t.value = t.value.replace('"', '')

    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.debug and 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, variable_type, value):
        self.type = type
        self.name = name
        self.variable_type = variable_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 AstNodeVariableTypeType(AstNode):
    def __init__(self, base_type):
        self.base_type = base_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, parameters, return_type, body):
        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 AstNodePipe(AstNode):
    def __init__(self, left, right):
        self.left = left
        self.right = right

class AstNodeTypeDeclaration(AstNode):
    def __init__(self, body):
        self.body = body

class AstNodeNamespaceAccess(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_program(p):
    '''program : program_statement
               | program_statement program'''

    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) + ']:')

                if list_length == 0:
                    print('> '*(level+1), 'None')
                else:
                    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 args.debug and p[1]:
        print(p[1].__class__.__name__)
        resolve_nodes(p[1], 0)

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

def p_program_statement(p):
    '''program_statement : variable_declaration_statement
                         | variable_reassignment_statement
                         | function_call
                         | pipe'''

    p[0] = p[1]


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

    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
                 | type_declaration
                 | pipe
                 | return_statement'''

    p[0] = p[1]




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

    p[0] = AstNodeFunctionDeclaration(p[2], p[5], p[7])


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

    parameters = []
    if len(p) == 2:
        parameters.append(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
                     | namespace_access 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_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'''

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


def p_variable_reassignment_statement(p): # TODO: adjust for object parameter assignment
    '''variable_reassignment_statement : IDENTIFIER ASSIGN expression
                                       | namespace_access ASSIGN expression'''

    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_type
                     | variable_type_primitive
                     | identifier
                     | 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_variable_type_type(p):
    '''variable_type_type : TYPE_TYPE BRACKET_LEFT variable_type BRACKET_RIGHT'''

    p[0] = AstNodeVariableTypeType(p[3])



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

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


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



def p_type_declaration(p):
    '''type_declaration : BRACE_LEFT type_body BRACE_RIGHT'''

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

def p_type_body(p):
    '''type_body : variable_declaration_statement
                 | variable_declaration_statement type_body'''

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



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_namespace_access(p):
    '''namespace_access : identifier NAMESPACE_ACCESSOR identifier
                        | namespace_access NAMESPACE_ACCESSOR identifier'''

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


def p_expression(p):
    '''expression : identifier
                  | number
                  | string
                  | array
                  | map
                  | function_declaration
                  | function_call
                  | type_declaration
                  | variable_type
                  | namespace_access
                  | 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):
    if 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)
    else:
        print("Unknown Error :(")




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



variables = {
    "print": print,
}
types = {}


def is_statement(statement):
    return (
        type(statement) is AstNodeVariableDeclarationStatement or
        type(statement) is AstNodeVariableReassignmentStatement or
        type(statement) is AstNodeFunctionCall or
        type(statement) is AstNodePipe
    )


def to_parameters_dict(parameters, context):
    dictionary = {}

    for idx, parameter in enumerate(parameters):
        if type(parameter) is AstNodeFunctionDeclarationParameter:
            dictionary[parameter.name] = None
        elif type(parameter) is AstNodeFunctionCallParameter:
            value = parameter.value

            if value == "$":
                value = context["$"]

            if parameter.name == "":
                dictionary[idx] = value
            else:
                dictionary[parameter.name] = value

    return dictionary


def merge_dict(dict1, dict2):
    for key, val in dict1.items():
        if type(val) == dict:
            if key in dict2 and type(dict2[key] == dict):
                merge_dict(dict1[key], dict2[key])
        else:
            if key in dict2:
                dict1[key] = dict2[key]

    for key, val in dict2.items():
        if not key in dict1:
            dict1[key] = val

    return dict1

def nested_set(dic, keys, value):
    for key in keys[:-1]:
        dic = dic.setdefault(key, {})
    dic[keys[-1]] = value

def update(d, u):
    for k, v in u.items():
        if isinstance(v, collections.abc.Mapping):
            d[k] = update(d.get(k, {}), v)
        else:
            d[k] = v
    return d


def get_namespace_path(namespace, context):
    path = []

    left = evaluate_expression(namespace.left, context | {"NAMESPACE_ACCESS": True})
    right = evaluate_expression(namespace.right, context | {"NAMESPACE_ACCESS": True})

    if type(left) is list:
        path.extend(left)
    else:
        path.append(left)

    path.append(right)

    return path


def evaluate_statement(statement, context):
    scoped_variables = {}

    # variable declaration
    if type(statement) is AstNodeVariableDeclarationStatement:
        value = evaluate_expression(statement.value, context)
        scoped_variables[statement.name] = value
        types[statement.name] = statement.variable_type

    # variable reassignment
    elif type(statement) is AstNodeVariableReassignmentStatement:
        value = evaluate_expression(statement.value, context)
        name = statement.name

        if type(name) is AstNodeNamespaceAccess:
            namespace_path = get_namespace_path(name, context)

            nested_update = {}
            nested_set(nested_update, namespace_path, value)
            scoped_variables = update(context, nested_update)
        else:
            if not name in context:
                print("ERROR: Reassignment on non-existent variable: {variable}".format(variable=statement.name))
            else:
                scoped_variables[name] = value

    # function call
    elif type(statement) is AstNodeFunctionCall:
        if type(statement.name) is AstNodeNamespaceAccess:
            namespace = evaluate_expression(statement.name, context)
            function = namespace["function"]
            context["self"] = namespace["self"]
        else:
            function = context[statement.name]

        # in-built
        if callable(function):
            function(*[evaluate_expression(parameter, context) for parameter in statement.parameters])

        # else
        else:
            call_parameters = to_parameters_dict(statement.parameters, context)
            declaration_parameters = to_parameters_dict(function.parameters, context)

            parameters = {}
            for idx, key in enumerate(declaration_parameters.keys()):
                if key in call_parameters:
                    parameters[key] = evaluate_expression(call_parameters[key], context)
                else:
                    parameters[key] = evaluate_expression(call_parameters[idx], context)

            statements = {}
            for body_statement in function.body:
                call_context_parameters = context | parameters | statements
                if type(body_statement) is AstNodeReturnStatement:
                    scoped_variables = evaluate_expression(
                        body_statement.expression,
                        call_context_parameters
                    )
                else:
                    statements |= evaluate_statement(body_statement, call_context_parameters)

    # pipe
    elif type(statement) is AstNodePipe:
        left = evaluate_statement(statement.left, context)
        right = evaluate_statement(statement.right, context | {"$": left})

        scoped_variables = right

    # namespace access
    elif type(statement) is AstNodeNamespaceAccess:
        left = evaluate_expression(statement.left, context)
        right = evaluate_expression(statement.right, left)

        self = list(context.keys())[list(context.values()).index(left)]

        if type(right) is AstNodeFunctionDeclaration:
            scoped_variables = {"self": self, "function": right}
        else:
            scoped_variables = right


    return scoped_variables


def evaluate_expression(expression, scoped_variables):
    result = expression

    # operator expression
    if type(expression) is AstNodeOperatorExpression:
        left = evaluate_expression(expression.left, scoped_variables)
        right = evaluate_expression(expression.right, scoped_variables)

        if type(left) != type(right):
            print("ERROR: Can't do math with non-matching types. Left: {left} - Right: {right}".format(left=type(left), right=type(right)))
        else:
            if expression.type == "+":
                result = left + right
            elif expression.type == "-":
                result = left - right
            elif expression.type == "*":
                result = left * right
            elif expression.type == "/":
                result = left / right

    # general expression
    elif type(expression) is AstNodeExpression:
        if expression.type is AstNodeExpressionType.IDENTIFIER:
            if expression.value == "self":
                result = scoped_variables[scoped_variables["self"]]
            elif "NAMESPACE_ACCESS" in scoped_variables:
                result = expression.value
            else:
                result = scoped_variables[expression.value]
        elif expression.type is AstNodeExpressionType.ARRAY:
            result = [evaluate_expression(element.value, scoped_variables) for element in expression.value]
        elif expression.type is AstNodeExpressionType.MAP:
            result = {}
            for element in expression.value:
                result[evaluate_expression(element.key, scoped_variables)] = evaluate_expression(element.value, scoped_variables)
        else:
            result = evaluate_expression(expression.value, scoped_variables)

    # function call / type instantiation
    elif type(expression) is AstNodeFunctionCall:
        if type(expression.name) is AstNodeNamespaceAccess:
            namespace = evaluate_expression(expression.name, scoped_variables)
            function = namespace["function"]
            scoped_variables["self"] = namespace["self"]
        else:
            function = scoped_variables[expression.name]

        # function call
        if type(function) is AstNodeFunctionDeclaration:
            result = evaluate_statement(expression, scoped_variables)

        # type instantiation
        elif type(function) is dict:
            instance_variables = evaluate_expression(function, scoped_variables)
            result = instance_variables

            variable_type = types[expression.name]
            if type(variable_type) is AstNodeVariableTypeType:
                type_type = evaluate_expression(variable_type.base_type, scoped_variables)
                result |= type_type

    # function call parameter
    elif type(expression) is AstNodeFunctionCallParameter:
        result = evaluate_expression(expression.value, scoped_variables)
        if result == "$":
            result = scoped_variables["$"]

    elif type(expression) is AstNodeNamespaceAccess:
        if "NAMESPACE_ACCESS" in scoped_variables:
            result = get_namespace_path(expression, scoped_variables)
        else:
            result = evaluate_statement(expression, scoped_variables)

    elif type(expression) is AstNodeTypeDeclaration:
        instance_variables = {}
        for node in expression.body:
            instance_variables |= evaluate_statement(node, scoped_variables)

        result = instance_variables


    return result


if result:
    for node in result:
        if args.debug:
            print(node)

        variables |= evaluate_statement(node, variables)




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