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 CSymbolExpression = collections.namedtuple(
  20     'CSymbolExpression',
  21     [
  22         'value',
  23     ],
  24 )
  25
  26 CNegationExpression = collections.namedtuple(
  27     'CNegationExpression',
  28     [
  29         'value',
  30     ],
  31 )
  32
  33 CAdditionExpression = collections.namedtuple(
  34     'CAdditionExpression',
  35     [
  36         'left',
  37         'right',
  38     ],
  39 )
  40
  41 CSubtractionExpression = collections.namedtuple(
  42     'CSubtractionExpression',
  43     [
  44         'left',
  45         'right',
  46     ],
  47 )
  48
  49 CMultiplicationExpression = collections.namedtuple(
  50     'CMultiplicationExpression',
  51     [
  52         'left',
  53         'right',
  54     ],
  55 )
  56
  57 CIntegerDivisionExpression = collections.namedtuple(
  58     'CIntegerDivisionExpression',
  59     [
  60         'left',
  61         'right',
  62     ],
  63 )
  64
  65 CModularDivisionExpression = collections.namedtuple(
  66     'CModularDivisionExpression',
  67     [
  68         'left',
  69         'right',
  70     ],
  71 )
  72
  73 CFunctionCallExpression = collections.namedtuple(
  74     'CFunctionCallExpression',
  75     [
  76         'name',
  77         'arguments',
  78     ],
  79 )
  80
  81 CAssignmentStatement = collections.namedtuple(
  82     'CAssignmentStatement',
  83     [
  84         'target',
  85         'expression',
  86     ],
  87 )
  88
  89 CProgram = collections.namedtuple(
  90     'CProgram',
  91     [
  92         'builtins',
  93         'statements',
  94         'standard_libraries',
  95     ],
  96 )
  97
  98 BUILTINS = {
  99     'pow':      ['math.h'],
 100     'print':    ['stdio.h'],
 101 }
 102
 103 def transform_expression(builtin_dependencies, expression):
 104     if isinstance(expression, parsing.FurNegationExpression):
 105         return transform_negation_expression(builtin_dependencies, expression)
 106
 107     if isinstance(expression, parsing.FurFunctionCallExpression):
 108         return transform_function_call_expression(builtin_dependencies, expression)
 109
 110     LITERAL_TYPE_MAPPING = {
 111         parsing.FurIntegerLiteralExpression: CIntegerLiteral,
 112         parsing.FurStringLiteralExpression: CStringLiteral,
 113         parsing.FurSymbolExpression: CSymbolExpression,
 114     }
 115
 116     if type(expression) in LITERAL_TYPE_MAPPING:
 117         return LITERAL_TYPE_MAPPING[type(expression)](value=expression.value)
 118
 119     INFIX_TYPE_MAPPING = {
 120         parsing.FurAdditionExpression: CAdditionExpression,
 121         parsing.FurSubtractionExpression: CSubtractionExpression,
 122         parsing.FurMultiplicationExpression: CMultiplicationExpression,
 123         parsing.FurIntegerDivisionExpression: CIntegerDivisionExpression,
 124         parsing.FurModularDivisionExpression: CModularDivisionExpression,
 125     }
 126
 127     return INFIX_TYPE_MAPPING[type(expression)](
 128         left=transform_expression(builtin_dependencies, expression.left),
 129         right=transform_expression(builtin_dependencies, expression.right),
 130     )
 131
 132 def transform_assignment_statement(builtin_dependencies, assignment_statement):
 133     # TODO Check that target is not a builtin
 134     return CAssignmentStatement(
 135         target=assignment_statement.target,
 136         expression=transform_expression(builtin_dependencies, assignment_statement.expression),
 137     )
 138
 139 def transform_negation_expression(builtin_dependencies, negation_expression):
 140     return CNegationExpression(value=transform_expression(builtin_dependencies, negation_expression.value))
 141
 142 def transform_function_call_expression(builtin_dependencies, function_call):
 143     if function_call.function.value in BUILTINS.keys():
 144         builtin_dependencies.add(function_call.function.value)
 145
 146         return CFunctionCallExpression(
 147             name='builtin$' + function_call.function.value,
 148             arguments=tuple(transform_expression(builtin_dependencies, arg) for arg in function_call.arguments),
 149         )
 150
 151     raise Exception()
 152
 153 def transform_statement(builtin_dependencies, statement):
 154     return {
 155         parsing.FurAssignmentStatement: transform_assignment_statement,
 156         parsing.FurFunctionCallExpression: transform_function_call_expression,
 157     }[type(statement)](builtin_dependencies, statement)
 158
 159 def transform(program):
 160     builtins = set()
 161
 162     c_statements = [
 163         transform_statement(builtins, statement) for statement in program.statement_list
 164     ]
 165
 166     standard_libraries = set()
 167     for builtin in builtins:
 168         for standard_library in BUILTINS[builtin]:
 169             standard_libraries.add(standard_library)
 170
 171     return CProgram(
 172         builtins=builtins,
 173         statements=c_statements,
 174         standard_libraries=standard_libraries,
 175     )
 176
 177
 178 if __name__ == '__main__':
 179     import unittest
 180
 181     unittest.main()