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

   1 import collections
   2
   3 import parsing
   4
   5 CIntegerLiteral = collections.namedtuple(
   6     'CIntegerLiteral',
   7     [
   8         'value',
   9     ],
  10 )
  11
  12 CStringLiteral = collections.namedtuple(
  13     'CStringLiteral',
  14     [
  15         'value',
  16     ],
  17 )
  18
  19 CConstantExpression = collections.namedtuple(
  20     'CConstantExpression',
  21     [
  22         'value'
  23     ],
  24 )
  25
  26 CSymbolExpression = collections.namedtuple(
  27     'CSymbolExpression',
  28     [
  29         'symbol',
  30         'symbol_list_index',
  31     ],
  32 )
  33
  34 CNegationExpression = collections.namedtuple(
  35     'CNegationExpression',
  36     [
  37         'value',
  38     ],
  39 )
  40
  41 CAdditionExpression = collections.namedtuple(
  42     'CAdditionExpression',
  43     [
  44         'left',
  45         'right',
  46     ],
  47 )
  48
  49 CSubtractionExpression = collections.namedtuple(
  50     'CSubtractionExpression',
  51     [
  52         'left',
  53         'right',
  54     ],
  55 )
  56
  57 CMultiplicationExpression = collections.namedtuple(
  58     'CMultiplicationExpression',
  59     [
  60         'left',
  61         'right',
  62     ],
  63 )
  64
  65 CIntegerDivisionExpression = collections.namedtuple(
  66     'CIntegerDivisionExpression',
  67     [
  68         'left',
  69         'right',
  70     ],
  71 )
  72
  73 CEqualityExpression = collections.namedtuple(
  74     'CEqualityExpression',
  75     [
  76         'left',
  77         'right',
  78     ],
  79 )
  80
  81 CInequalityExpression = collections.namedtuple(
  82     'CInequalityExpression',
  83     [
  84         'left',
  85         'right',
  86     ],
  87 )
  88
  89 CGreaterThanOrEqualExpression = collections.namedtuple(
  90     'CGreaterThanOrEqualExpression',
  91     [
  92         'left',
  93         'right',
  94     ],
  95 )
  96
  97 CLessThanOrEqualExpression = collections.namedtuple(
  98     'CLessThanOrEqualExpression',
  99     [
 100         'left',
 101         'right',
 102     ],
 103 )
 104
 105 CGreaterThanExpression = collections.namedtuple(
 106     'CGreaterThanExpression',
 107     [
 108         'left',
 109         'right',
 110     ],
 111 )
 112
 113 CLessThanExpression = collections.namedtuple(
 114     'CLessThanExpression',
 115     [
 116         'left',
 117         'right',
 118     ],
 119 )
 120
 121 CAndExpression = collections.namedtuple(
 122     'CAndExpression',
 123     [
 124         'left',
 125         'right',
 126     ],
 127 )
 128
 129
 130 CModularDivisionExpression = collections.namedtuple(
 131     'CModularDivisionExpression',
 132     [
 133         'left',
 134         'right',
 135     ],
 136 )
 137
 138 CFunctionCallExpression = collections.namedtuple(
 139     'CFunctionCallExpression',
 140     [
 141         'name',
 142         'arguments',
 143     ],
 144 )
 145
 146 CAssignmentStatement = collections.namedtuple(
 147     'CAssignmentStatement',
 148     [
 149         'target',
 150         'target_symbol_list_index',
 151         'expression',
 152     ],
 153 )
 154
 155 CProgram = collections.namedtuple(
 156     'CProgram',
 157     [
 158         'builtins',
 159         'statements',
 160         'standard_libraries',
 161         'symbol_list',
 162     ],
 163 )
 164
 165 EQUALITY_LEVEL_TYPE_MAPPING = {
 166     parsing.FurEqualityExpression: CEqualityExpression,
 167     parsing.FurInequalityExpression: CInequalityExpression,
 168     parsing.FurLessThanOrEqualExpression: CLessThanOrEqualExpression,
 169     parsing.FurGreaterThanOrEqualExpression: CGreaterThanOrEqualExpression,
 170     parsing.FurLessThanExpression: CLessThanExpression,
 171     parsing.FurGreaterThanExpression: CGreaterThanExpression,
 172 }
 173
 174 def transform_equality_level_expression(builtin_dependencies, symbol_list, expression):
 175     # Transform expressions like 1 < 2 < 3 into expressions like 1 < 2 && 2 < 3
 176     if type(expression.left) in EQUALITY_LEVEL_TYPE_MAPPING:
 177         left = transform_equality_level_expression(
 178             builtin_dependencies,
 179             symbol_list,
 180             expression.left
 181         )
 182
 183         middle = left.right
 184
 185         right = transform_expression(
 186             builtin_dependencies,
 187             symbol_list,
 188             expression.right,
 189         )
 190
 191         # TODO Don't evaluate the middle expression twice
 192         return CAndExpression(
 193             left=left,
 194             right=EQUALITY_LEVEL_TYPE_MAPPING[type(expression)](
 195                 left=middle,
 196                 right=right,
 197             ),
 198         )
 199
 200     return EQUALITY_LEVEL_TYPE_MAPPING[type(expression)](
 201         left=transform_expression(builtin_dependencies, symbol_list, expression.left),
 202         right=transform_expression(builtin_dependencies, symbol_list, expression.right),
 203     )
 204
 205 BUILTINS = {
 206     'false':    [],
 207     'pow':      ['math.h'],
 208     'print':    ['stdio.h'],
 209     'true':     [],
 210 }
 211
 212 def transform_expression(builtin_dependencies, symbol_list, expression):
 213     if isinstance(expression, parsing.FurParenthesizedExpression):
 214         # Parentheses can be removed because everything in the C output is explicitly parenthesized
 215         return transform_expression(builtin_dependencies, symbol_list, expression.internal)
 216
 217     if isinstance(expression, parsing.FurNegationExpression):
 218         return transform_negation_expression(builtin_dependencies, symbol_list, expression)
 219
 220     if isinstance(expression, parsing.FurFunctionCallExpression):
 221         return transform_function_call_expression(builtin_dependencies, symbol_list, expression)
 222
 223     if isinstance(expression, parsing.FurSymbolExpression):
 224         if expression.value in ['true', 'false']:
 225             return CConstantExpression(value=expression.value)
 226
 227         if expression.value not in symbol_list:
 228             symbol_list.append(expression.value)
 229
 230         return CSymbolExpression(
 231             symbol=expression.value,
 232             symbol_list_index=symbol_list.index(expression.value),
 233         )
 234
 235     LITERAL_TYPE_MAPPING = {
 236         parsing.FurIntegerLiteralExpression: CIntegerLiteral,
 237         parsing.FurStringLiteralExpression: CStringLiteral,
 238     }
 239
 240     if type(expression) in LITERAL_TYPE_MAPPING:
 241         return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
 242
 243     if type(expression) in EQUALITY_LEVEL_TYPE_MAPPING:
 244         return transform_equality_level_expression(builtin_dependencies, symbol_list, expression)
 245
 246     INFIX_TYPE_MAPPING = {
 247         parsing.FurAdditionExpression: CAdditionExpression,
 248         parsing.FurSubtractionExpression: CSubtractionExpression,
 249         parsing.FurMultiplicationExpression: CMultiplicationExpression,
 250         parsing.FurIntegerDivisionExpression: CIntegerDivisionExpression,
 251         parsing.FurModularDivisionExpression: CModularDivisionExpression,
 252     }
 253
 254     return INFIX_TYPE_MAPPING[type(expression)](
 255         left=transform_expression(builtin_dependencies, symbol_list, expression.left),
 256         right=transform_expression(builtin_dependencies, symbol_list, expression.right),
 257     )
 258
 259 def transform_assignment_statement(builtin_dependencies, symbol_list, assignment_statement):
 260     # TODO Check that target is not a builtin
 261     if assignment_statement.target not in symbol_list:
 262         symbol_list.append(assignment_statement.target)
 263
 264     return CAssignmentStatement(
 265         target=assignment_statement.target,
 266         target_symbol_list_index=symbol_list.index(assignment_statement.target),
 267         expression=transform_expression(
 268             builtin_dependencies,
 269             symbol_list,
 270             assignment_statement.expression,
 271         ),
 272     )
 273
 274 def transform_negation_expression(builtin_dependencies, symbol_list, negation_expression):
 275     return CNegationExpression(
 276         value=transform_expression(builtin_dependencies, symbol_list, negation_expression.value),
 277     )
 278
 279 def transform_function_call_expression(builtin_dependencies, symbol_list, function_call):
 280     if function_call.function.value in BUILTINS.keys():
 281         # TODO Check that the builtin is actually callable
 282         builtin_dependencies.add(function_call.function.value)
 283
 284         return CFunctionCallExpression(
 285             name='builtin$' + function_call.function.value,
 286             arguments=tuple(
 287                 transform_expression(builtin_dependencies, symbol_list, arg)
 288                 for arg in function_call.arguments
 289             ),
 290         )
 291
 292     raise Exception()
 293
 294 def transform_statement(builtin_dependencies, symbol_list, statement):
 295     return {
 296         parsing.FurAssignmentStatement: transform_assignment_statement,
 297         parsing.FurFunctionCallExpression: transform_function_call_expression,
 298     }[type(statement)](builtin_dependencies, symbol_list, statement)
 299
 300 def transform(program):
 301     builtins = set()
 302     symbol_list = []
 303
 304     c_statements = [
 305         transform_statement(builtins, symbol_list, statement) for statement in program.statement_list
 306     ]
 307
 308     standard_libraries = set()
 309     for builtin in builtins:
 310         for standard_library in BUILTINS[builtin]:
 311             standard_libraries.add(standard_library)
 312
 313     return CProgram(
 314         builtins=builtins,
 315         statements=c_statements,
 316         standard_libraries=standard_libraries,
 317         symbol_list=symbol_list,
 318     )
 319
 320
 321 if __name__ == '__main__':
 322     import unittest
 323
 324     unittest.main()