code.kerkeslager.com Git - fur/blob - transformation.py

   1 import collections
   2
   3 import normalization
   4 import parsing
   5
   6 CIntegerLiteral = collections.namedtuple(
   7     'CIntegerLiteral',
   8     [
   9         'value',
  10     ],
  11 )
  12
  13 CStringLiteral = collections.namedtuple(
  14     'CStringLiteral',
  15     [
  16         'index',
  17         'value',
  18     ],
  19 )
  20
  21 CConstantExpression = collections.namedtuple(
  22     'CConstantExpression',
  23     [
  24         'value'
  25     ],
  26 )
  27
  28 CVariableExpression = collections.namedtuple(
  29     'CVariableExpression',
  30     [
  31         'variable',
  32     ],
  33 )
  34
  35 CSymbolExpression = collections.namedtuple(
  36     'CSymbolExpression',
  37     [
  38         'symbol',
  39         'symbol_list_index',
  40     ],
  41 )
  42
  43 CNegationExpression = collections.namedtuple(
  44     'CNegationExpression',
  45     [
  46         'value',
  47     ],
  48 )
  49
  50 CFunctionCallForFurInfixOperator = collections.namedtuple(
  51     'CFunctionCallForFurInfixOperator',
  52     [
  53         'name',
  54         'left',
  55         'right',
  56     ],
  57 )
  58
  59 CFunctionCallExpression = collections.namedtuple(
  60     'CFunctionCallExpression',
  61     [
  62         'name',
  63         'argument_count',
  64         'argument_items',
  65     ],
  66 )
  67
  68 CSymbolAssignmentStatement = collections.namedtuple(
  69     'CSymbolAssignmentStatement',
  70     [
  71         'target',
  72         'target_symbol_list_index',
  73         'expression',
  74     ],
  75 )
  76
  77 CArrayVariableInitializationStatement = collections.namedtuple(
  78     'CArrayVariableInitializationStatement',
  79     [
  80         'variable',
  81         'items',
  82     ],
  83 )
  84
  85 CVariableInitializationStatement = collections.namedtuple(
  86     'CVariableInitializationStatement',
  87     [
  88         'variable',
  89         'expression',
  90     ],
  91 )
  92
  93 CVariableReassignmentStatement = collections.namedtuple(
  94     'CVariableReassignmentStatement',
  95     [
  96         'variable',
  97         'expression',
  98     ],
  99 )
 100
 101 CExpressionStatement = collections.namedtuple(
 102     'CExpressionStatement',
 103     [
 104         'expression',
 105     ],
 106 )
 107
 108 CIfElseStatement = collections.namedtuple(
 109     'CIfElseStatement',
 110     [
 111         'condition_expression',
 112         'if_statements',
 113         'else_statements',
 114     ],
 115 )
 116
 117 CFunctionDeclaration = collections.namedtuple(
 118     'CFunctionDeclaration',
 119     [
 120         'name',
 121     ],
 122 )
 123
 124 CFunctionDefinition = collections.namedtuple(
 125     'CFunctionDefinition',
 126     [
 127         'name',
 128         'argument_name_list',
 129         'statement_list',
 130     ],
 131 )
 132
 133 CProgram = collections.namedtuple(
 134     'CProgram',
 135     [
 136         'builtin_set',
 137         'function_definition_list',
 138         'operator_declarations',
 139         'statements',
 140         'standard_libraries',
 141         'string_literal_list',
 142         'symbol_list',
 143     ],
 144 )
 145
 146 BUILTINS = {
 147     'false':    [],
 148     'pow':      ['math.h'],
 149     'print':    ['stdio.h'],
 150     'true':     [],
 151 }
 152
 153 def transform_variable_expression(accumulators, expression):
 154     return CVariableExpression(variable=expression.variable)
 155
 156 def transform_string_literal_expression(accumulators, expression):
 157     value = expression.string
 158
 159     try:
 160         index = accumulators.string_literal_list.index(value)
 161     except ValueError:
 162         index = len(accumulators.string_literal_list)
 163         accumulators.string_literal_list.append(value)
 164
 165     return CStringLiteral(index=index, value=value)
 166
 167 def transform_symbol_expression(accumulators, expression):
 168     if expression.value in ['true', 'false']:
 169         return CConstantExpression(value=expression.value)
 170
 171     try:
 172         symbol_list_index = accumulators.symbol_list.index(expression.value)
 173     except ValueError:
 174         symbol_list_index = len(accumulators.symbol_list)
 175         accumulators.symbol_list.append(expression.value)
 176
 177     return CSymbolExpression(
 178         symbol=expression.value,
 179         symbol_list_index=symbol_list_index,
 180     )
 181
 182 CInfixDeclaration = collections.namedtuple(
 183     'CInfixDeclaration',
 184     [
 185         'name',
 186         'in_type',
 187         'out_type',
 188         'operator',
 189     ],
 190 )
 191
 192 INFIX_OPERATOR_TO_DECLARATION = {
 193     '+':    CInfixDeclaration(name='add', in_type='integer', out_type='integer', operator='+'),
 194     '-':    CInfixDeclaration(name='subtract', in_type='integer', out_type='integer', operator='-'),
 195     '*':    CInfixDeclaration(name='multiply', in_type='integer', out_type='integer', operator='*'),
 196     '//':   CInfixDeclaration(name='integerDivide', in_type='integer', out_type='integer', operator='/'),
 197     '%':    CInfixDeclaration(name='modularDivide', in_type='integer', out_type='integer', operator='%'),
 198     'and':  CInfixDeclaration(name='and', in_type='boolean', out_type='boolean', operator='&&'),
 199     'or':   CInfixDeclaration(name='or', in_type='boolean', out_type='boolean', operator='||'),
 200     '==':   CInfixDeclaration(name='equals', in_type='integer', out_type='boolean', operator='=='),
 201     '!=':   CInfixDeclaration(name='notEquals', in_type='integer', out_type='boolean', operator='!='),
 202     '<=':   CInfixDeclaration(name='lessThanOrEqual', in_type='integer', out_type='boolean', operator='<='),
 203     '>=':   CInfixDeclaration(name='greaterThanOrEqual', in_type='integer', out_type='boolean', operator='>='),
 204     '<':    CInfixDeclaration(name='lessThan', in_type='integer', out_type='boolean', operator='<'),
 205     '>':    CInfixDeclaration(name='greaterThan', in_type='integer', out_type='boolean', operator='>'),
 206 }
 207
 208 def transform_comparison_level_expression(accumulators, expression):
 209     accumulators.operator_set.add(INFIX_OPERATOR_TO_DECLARATION[expression.operator])
 210
 211     # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
 212     if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'comparison_level':
 213         left = transform_comparison_level_expression(
 214             accumulators,
 215             expression.left
 216         )
 217
 218         middle = left.right
 219
 220         right = transform_expression(
 221             accumulators,
 222             expression.right,
 223         )
 224
 225         # TODO Don't evaluate the middle expression twice
 226         return CFunctionCallForFurInfixOperator(
 227             name='and',
 228             left=left,
 229             right=CFunctionCallForFurInfixOperator(
 230                 name=INFIX_OPERATOR_TO_DECLARATION[expression.operator].name,
 231                 left=middle,
 232                 right=right,
 233             ),
 234         )
 235
 236     return CFunctionCallForFurInfixOperator(
 237         name=INFIX_OPERATOR_TO_DECLARATION[expression.operator].name,
 238         left=transform_expression(accumulators, expression.left),
 239         right=transform_expression(accumulators, expression.right),
 240     )
 241
 242 def transform_infix_expression(accumulators, expression):
 243     if expression.order == 'comparison_level':
 244         return transform_comparison_level_expression(accumulators, expression)
 245
 246     accumulators.operator_set.add(INFIX_OPERATOR_TO_DECLARATION[expression.operator])
 247
 248     return CFunctionCallForFurInfixOperator(
 249         name=INFIX_OPERATOR_TO_DECLARATION[expression.operator].name,
 250         left=transform_expression(accumulators, expression.left),
 251         right=transform_expression(accumulators, expression.right),
 252     )
 253
 254 def transform_integer_literal_expression(accumulators, expression):
 255     return CIntegerLiteral(value=expression.integer)
 256
 257 def transform_negation_expression(accumulators, expression):
 258     return CNegationExpression(
 259         value=transform_expression(accumulators, expression.internal_expression),
 260     )
 261
 262 def transform_expression(accumulators, expression):
 263     # TODO Clean up handlers for parsing expressions
 264     return {
 265         parsing.FurFunctionCallExpression: transform_function_call_expression,
 266         parsing.FurInfixExpression: transform_infix_expression,
 267         parsing.FurIntegerLiteralExpression: transform_integer_literal_expression,
 268         parsing.FurNegationExpression: transform_negation_expression,
 269         parsing.FurStringLiteralExpression: transform_string_literal_expression,
 270         parsing.FurSymbolExpression: transform_symbol_expression,
 271         normalization.NormalFunctionCallExpression: transform_function_call_expression,
 272         normalization.NormalInfixExpression: transform_infix_expression,
 273         normalization.NormalIntegerLiteralExpression: transform_integer_literal_expression,
 274         normalization.NormalNegationExpression: transform_negation_expression,
 275         normalization.NormalStringLiteralExpression: transform_string_literal_expression,
 276         normalization.NormalVariableExpression: transform_variable_expression,
 277     }[type(expression)](accumulators, expression)
 278
 279 def transform_symbol_assignment_statement(accumulators, assignment_statement):
 280     # TODO Check that target is not a builtin
 281     try:
 282         symbol_list_index = accumulators.symbol_list.index(assignment_statement.target)
 283     except ValueError:
 284         symbol_list_index = len(accumulators.symbol_list)
 285         accumulators.symbol_list.append(assignment_statement.target)
 286
 287     return CSymbolAssignmentStatement(
 288         target=assignment_statement.target,
 289         target_symbol_list_index=symbol_list_index,
 290         expression=transform_expression(
 291             accumulators,
 292             assignment_statement.expression,
 293         ),
 294     )
 295
 296 def transform_function_call_expression(accumulators, function_call):
 297     if isinstance(function_call.function, parsing.FurSymbolExpression):
 298         # TODO Move this check to transformation of symbol expressions so we can have builtins that aren't functions
 299         if function_call.function.value in BUILTINS.keys():
 300             # TODO Check that the builtin is actually callable
 301             accumulators.builtin_set.add(function_call.function.value)
 302
 303     # TODO Use the symbol from SYMBOL LIST
 304     return CFunctionCallExpression(
 305         name=transform_expression(accumulators, function_call.function),
 306         argument_count=function_call.argument_count,
 307         argument_items=transform_expression(accumulators, function_call.argument_items),
 308     )
 309
 310 def transform_expression_statement(accumulators, statement):
 311     return CExpressionStatement(
 312         expression=transform_expression(accumulators, statement.expression),
 313     )
 314
 315 def transform_if_else_statement(accumulators, statement):
 316     return CIfElseStatement(
 317         condition_expression=transform_expression(accumulators, statement.condition_expression),
 318         if_statements=tuple(transform_statement(accumulators, s) for s in statement.if_statements),
 319         else_statements=tuple(transform_statement(accumulators, s) for s in statement.else_statements),
 320     )
 321
 322 def transform_array_variable_initialization_statement(accumulators, statement):
 323     return CArrayVariableInitializationStatement(
 324         variable=statement.variable,
 325         items=tuple(transform_expression(accumulators, i) for i in statement.items),
 326     )
 327
 328 def transform_variable_initialization_statement(accumulators, statement):
 329     return CVariableInitializationStatement(
 330         variable=statement.variable,
 331         expression=transform_expression(accumulators, statement.expression),
 332     )
 333
 334 def transform_variable_reassignment_statement(accumulators, statement):
 335     return CVariableReassignmentStatement(
 336         variable=statement.variable,
 337         expression=transform_expression(accumulators, statement.expression),
 338     )
 339
 340 def transform_function_definition_statement(accumulators, statement):
 341     # TODO Allow defining the same function in different contexts
 342     if any(fd.name == statement.name for fd in accumulators.function_definition_list):
 343         raise Exception('A function with name "{}" already exists'.format(statement.name))
 344
 345     # TODO Add argument names to the symbol table
 346     accumulators.function_definition_list.append(CFunctionDefinition(
 347         name=statement.name,
 348         argument_name_list=statement.argument_name_list,
 349         statement_list=tuple(transform_statement(accumulators, s) for s in statement.statement_list)
 350     ))
 351
 352     return CFunctionDeclaration(name=statement.name)
 353
 354 def transform_statement(accumulators, statement):
 355     return {
 356         parsing.FurExpressionStatement: transform_expression_statement,
 357         normalization.NormalArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
 358         normalization.NormalAssignmentStatement: transform_symbol_assignment_statement,
 359         normalization.NormalExpressionStatement: transform_expression_statement,
 360         normalization.NormalFunctionDefinitionStatement: transform_function_definition_statement,
 361         normalization.NormalIfElseStatement: transform_if_else_statement,
 362         normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
 363         normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
 364     }[type(statement)](accumulators, statement)
 365
 366
 367 Accumulators = collections.namedtuple(
 368     'Accumulators',
 369     [
 370         'builtin_set',
 371         'function_definition_list',
 372         'operator_set',
 373         'symbol_list',
 374         'string_literal_list',
 375     ],
 376 )
 377
 378 def transform(program):
 379     accumulators = Accumulators(
 380         builtin_set=set(),
 381         function_definition_list=[],
 382         operator_set=set(),
 383         symbol_list=[],
 384         string_literal_list=[],
 385     )
 386
 387     statement_list = [
 388         transform_statement(accumulators, statement) for statement in program.statement_list
 389     ]
 390
 391     standard_library_set = set()
 392     for builtin in accumulators.builtin_set:
 393         for standard_library in BUILTINS[builtin]:
 394             standard_library_set.add(standard_library)
 395
 396     return CProgram(
 397         builtin_set=accumulators.builtin_set,
 398         function_definition_list=accumulators.function_definition_list,
 399         operator_declarations=tuple(sorted(accumulators.operator_set)),
 400         statements=statement_list,
 401         standard_libraries=standard_library_set,
 402         string_literal_list=accumulators.string_literal_list,
 403         symbol_list=accumulators.symbol_list,
 404     )
 405
 406
 407 if __name__ == '__main__':
 408     import unittest
 409
 410     unittest.main()