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 CProgram = collections.namedtuple(
 118     'CProgram',
 119     [
 120         'builtin_set',
 121         'statements',
 122         'standard_libraries',
 123         'string_literal_list',
 124         'symbol_list',
 125     ],
 126 )
 127
 128 EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING = {
 129     '==':   'equals',
 130     '!=':   'notEquals',
 131     '<=':   'lessThanOrEqual',
 132     '>=':   'greaterThanOrEqual',
 133     '<':    'lessThan',
 134     '>':    'greaterThan',
 135 }
 136
 137 def transform_comparison_level_expression(accumulators, expression):
 138     # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
 139     if isinstance(expression.left, parsing.FurInfixExpression) and expression.left.order == 'comparison_level':
 140         left = transform_comparison_level_expression(
 141             accumulators,
 142             expression.left
 143         )
 144
 145         middle = left.right
 146
 147         right = transform_expression(
 148             accumulators,
 149             expression.right,
 150         )
 151
 152         # TODO Don't evaluate the middle expression twice
 153         return CFunctionCallForFurInfixOperator(
 154             name='and',
 155             left=left,
 156             right=CFunctionCallForFurInfixOperator(
 157                 name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
 158                 left=middle,
 159                 right=right,
 160             ),
 161         )
 162
 163     return CFunctionCallForFurInfixOperator(
 164         name=EQUALITY_LEVEL_OPERATOR_TO_FUNCTION_NAME_MAPPING[expression.operator],
 165         left=transform_expression(accumulators, expression.left),
 166         right=transform_expression(accumulators, expression.right),
 167     )
 168
 169 BUILTINS = {
 170     'false':    [],
 171     'pow':      ['math.h'],
 172     'print':    ['stdio.h'],
 173     'true':     [],
 174 }
 175
 176 def transform_variable_expression(accumulators, expression):
 177     return CVariableExpression(variable=expression.variable)
 178
 179 def transform_infix_expression(accumulators, expression):
 180     if expression.order == 'comparison_level':
 181         return transform_comparison_level_expression(accumulators, expression)
 182
 183     INFIX_OPERATOR_TO_FUNCTION_NAME = {
 184         '+':    'add',
 185         '-':    'subtract',
 186         '*':    'multiply',
 187         '//':   'integerDivide',
 188         '%':    'modularDivide',
 189         'and':  'and',
 190         'or':   'or',
 191     }
 192
 193     return CFunctionCallForFurInfixOperator(
 194         name=INFIX_OPERATOR_TO_FUNCTION_NAME[expression.operator],
 195         left=transform_expression(accumulators, expression.left),
 196         right=transform_expression(accumulators, expression.right),
 197     )
 198
 199 def transform_expression(accumulators, expression):
 200     if isinstance(expression, parsing.FurParenthesizedExpression):
 201         # Parentheses can be removed because everything in the C output is explicitly parenthesized
 202         return transform_expression(accumulators, expression.internal)
 203
 204     if isinstance(expression, parsing.FurNegationExpression):
 205         return transform_negation_expression(accumulators, expression)
 206
 207     if isinstance(expression, parsing.FurFunctionCallExpression):
 208         return transform_function_call_expression(accumulators, expression)
 209
 210     if isinstance(expression, parsing.FurSymbolExpression):
 211         if expression.value in ['true', 'false']:
 212             return CConstantExpression(value=expression.value)
 213
 214         if expression.value not in accumulators.symbol_list:
 215             symbol_list.append(expression.value)
 216
 217         return CSymbolExpression(
 218             symbol=expression.value,
 219             symbol_list_index=accumulators.symbol_list.index(expression.value),
 220         )
 221
 222     if isinstance(expression, parsing.FurStringLiteralExpression):
 223         value = expression.value
 224
 225         try:
 226             index = accumulators.string_literal_list.index(value)
 227         except ValueError:
 228             index = len(accumulators.string_literal_list)
 229             accumulators.string_literal_list.append(value)
 230
 231         return CStringLiteral(index=index, value=value)
 232
 233     LITERAL_TYPE_MAPPING = {
 234         parsing.FurIntegerLiteralExpression: CIntegerLiteral,
 235     }
 236
 237     if type(expression) in LITERAL_TYPE_MAPPING:
 238         return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
 239
 240     # TODO Handle all possible types in this form
 241     return {
 242         parsing.FurInfixExpression: transform_infix_expression, # TODO Shouldn't need this
 243         normalization.NormalFunctionCallExpression: transform_function_call_expression,
 244         normalization.NormalInfixExpression: transform_infix_expression,
 245         normalization.NormalNegationExpression: transform_negation_expression,
 246         normalization.NormalVariableExpression: transform_variable_expression,
 247     }[type(expression)](accumulators, expression)
 248
 249 def transform_symbol_assignment_statement(accumulators, assignment_statement):
 250     # TODO Check that target is not a builtin
 251     if assignment_statement.target not in accumulators.symbol_list:
 252         accumulators.symbol_list.append(assignment_statement.target)
 253
 254     return CSymbolAssignmentStatement(
 255         target=assignment_statement.target,
 256         target_symbol_list_index=accumulators.symbol_list.index(assignment_statement.target),
 257         expression=transform_expression(
 258             accumulators,
 259             assignment_statement.expression,
 260         ),
 261     )
 262
 263 def transform_negation_expression(accumulators, expression):
 264     return CNegationExpression(
 265         value=transform_expression(accumulators, expression.internal_expression),
 266     )
 267
 268 def transform_function_call_expression(accumulators, function_call):
 269     if function_call.function.value in BUILTINS.keys():
 270         # TODO Check that the builtin is actually callable
 271         accumulators.builtin_set.add(function_call.function.value)
 272
 273         return CFunctionCallExpression(
 274             name='builtin$' + function_call.function.value,
 275             argument_count=function_call.argument_count,
 276             argument_items=transform_expression(accumulators, function_call.argument_items),
 277         )
 278
 279     raise Exception()
 280
 281 def transform_expression_statement(accumulators, statement):
 282     expression = {
 283         parsing.FurFunctionCallExpression: transform_function_call_expression,
 284         normalization.NormalFunctionCallExpression: transform_function_call_expression,
 285     }[type(statement.expression)](accumulators, statement.expression)
 286
 287     return CExpressionStatement(
 288         expression=expression,
 289     )
 290
 291 def transform_if_else_statement(accumulators, statement):
 292     return CIfElseStatement(
 293         condition_expression=transform_expression(accumulators, statement.condition_expression),
 294         if_statements=tuple(transform_statement(accumulators, s) for s in statement.if_statements),
 295         else_statements=tuple(transform_statement(accumulators, s) for s in statement.else_statements),
 296     )
 297
 298 def transform_array_variable_initialization_statement(accumulators, statement):
 299     return CArrayVariableInitializationStatement(
 300         variable=statement.variable,
 301         items=tuple(transform_expression(accumulators, i) for i in statement.items),
 302     )
 303
 304 def transform_variable_initialization_statement(accumulators, statement):
 305     return CVariableInitializationStatement(
 306         variable=statement.variable,
 307         expression=transform_expression(accumulators, statement.expression),
 308     )
 309
 310 def transform_variable_reassignment_statement(accumulators, statement):
 311     return CVariableReassignmentStatement(
 312         variable=statement.variable,
 313         expression=transform_expression(accumulators, statement.expression),
 314     )
 315
 316 def transform_statement(accumulators, statement):
 317     return {
 318         parsing.FurAssignmentStatement: transform_symbol_assignment_statement,
 319         parsing.FurExpressionStatement: transform_expression_statement,
 320         normalization.NormalExpressionStatement: transform_expression_statement,
 321         normalization.NormalIfElseStatement: transform_if_else_statement,
 322         normalization.NormalArrayVariableInitializationStatement: transform_array_variable_initialization_statement,
 323         normalization.NormalVariableInitializationStatement: transform_variable_initialization_statement,
 324         normalization.NormalVariableReassignmentStatement: transform_variable_reassignment_statement,
 325     }[type(statement)](accumulators, statement)
 326
 327
 328 Accumulators = collections.namedtuple(
 329     'Accumulators',
 330     [
 331         'builtin_set',
 332         'symbol_list',
 333         'string_literal_list',
 334     ],
 335 )
 336
 337 def transform(program):
 338     accumulators = Accumulators(
 339         builtin_set=set(),
 340         symbol_list=[],
 341         string_literal_list=[],
 342     )
 343
 344     statement_list = [
 345         transform_statement(accumulators, statement) for statement in program.statement_list
 346     ]
 347
 348     standard_library_set = set()
 349     for builtin in accumulators.builtin_set:
 350         for standard_library in BUILTINS[builtin]:
 351             standard_library_set.add(standard_library)
 352
 353     return CProgram(
 354         builtin_set=accumulators.builtin_set,
 355         statements=statement_list,
 356         standard_libraries=standard_library_set,
 357         string_literal_list=accumulators.string_literal_list,
 358         symbol_list=accumulators.symbol_list,
 359     )
 360
 361
 362 if __name__ == '__main__':
 363     import unittest
 364
 365     unittest.main()