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