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