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

   1 import collections
   2
   3 import normalization
   4
   5 CPSFunctionCallExpression = collections.namedtuple(
   6     'CPSFunctionCallExpression',
   7     (
   8         'metadata',
   9         'function_expression',
  10         'argument_count',
  11     ),
  12 )
  13
  14 CPSIntegerLiteralExpression = collections.namedtuple(
  15     'CPSIntegerLiteralExpression',
  16     (
  17         'integer',
  18     ),
  19 )
  20
  21 CPSListConstructExpression = collections.namedtuple(
  22     'CPSListConstructExpression',
  23     (
  24         'allocate',
  25     ),
  26 )
  27
  28 CPSStringLiteralExpression = collections.namedtuple(
  29     'CPSStringLiteralExpression',
  30     (
  31         'string',
  32     ),
  33 )
  34
  35 CPSStructureLiteralExpression = collections.namedtuple(
  36     'CPSStructureLiteralExpression',
  37     (
  38         'field_count',
  39         'symbol_list_variable',
  40         'value_list_variable',
  41     ),
  42 )
  43
  44 CPSSymbolExpression = collections.namedtuple(
  45     'CPSSymbolExpression',
  46     (
  47         'symbol',
  48     ),
  49 )
  50
  51 CPSVariableExpression = collections.namedtuple(
  52     'CPSVariableExpression',
  53     (
  54         'variable',
  55     ),
  56 )
  57
  58 CPSArrayVariableInitializationStatement = collections.namedtuple(
  59     'CPSArrayVariableInitializationStatement',
  60     (
  61         'variable',
  62         'items',
  63     ),
  64 )
  65
  66 CPSAssignmentStatement = collections.namedtuple(
  67     'CPSAssignmentStatement',
  68     (
  69         'target',
  70         'expression',
  71     ),
  72 )
  73
  74 CPSExpressionStatement = collections.namedtuple(
  75     'CPSExpressionStatement',
  76     (
  77         'expression',
  78     ),
  79 )
  80
  81 CPSFunctionDefinitionStatement = collections.namedtuple(
  82     'CPSFunctionDefinitionStatement',
  83     (
  84         'name',
  85         'argument_name_list',
  86         'statement_list',
  87     )
  88 )
  89
  90 CPSIfElseStatement = collections.namedtuple(
  91     'CPSIfElseStatement',
  92     (
  93         'condition_expression',
  94         'if_statement_list',
  95         'else_statement_list',
  96     ),
  97 )
  98
  99 CPSListAppendStatement = collections.namedtuple(
 100     'CPSListAppendStatement',
 101     (
 102         'list_expression',
 103         'item_expression',
 104     ),
 105 )
 106
 107 CPSPushStatement = collections.namedtuple(
 108     'CPSPushStatement',
 109     (
 110         'expression',
 111     ),
 112 )
 113
 114 CPSVariableInitializationStatement = collections.namedtuple(
 115     'CPSVariableInitializationStatement',
 116     (
 117         'variable',
 118         'expression',
 119     ),
 120 )
 121
 122 CPSSymbolArrayVariableInitializationStatement = collections.namedtuple(
 123     'CPSSymbolArrayVariableInitializationStatement',
 124     (
 125         'variable',
 126         'symbol_list',
 127     ),
 128 )
 129
 130 CPSVariableReassignmentStatement = collections.namedtuple(
 131     'CPSVariableReassignmentStatement',
 132     (
 133         'variable',
 134         'expression',
 135     ),
 136 )
 137
 138 CPSProgram = collections.namedtuple(
 139     'CPSProgram',
 140     (
 141         'statement_list',
 142     ),
 143 )
 144
 145 def convert_function_call_expression(expression):
 146     return CPSFunctionCallExpression(
 147         metadata=expression.metadata,
 148         function_expression=convert_expression(expression.function_expression),
 149         argument_count=expression.argument_count,
 150     )
 151
 152 def convert_integer_literal_expression(expression):
 153     return CPSIntegerLiteralExpression(integer=expression.integer)
 154
 155 def convert_list_construct_expression(expression):
 156     return CPSListConstructExpression(allocate=expression.allocate)
 157
 158 def convert_string_literal_expression(expression):
 159     return CPSStringLiteralExpression(string=expression.string)
 160
 161 def convert_structure_literal_expression(expression):
 162     return CPSStructureLiteralExpression(
 163         field_count=expression.field_count,
 164         symbol_list_variable=expression.symbol_list_variable,
 165         value_list_variable=expression.value_list_variable,
 166     )
 167
 168 def convert_symbol_expression(expression):
 169     return CPSSymbolExpression(symbol=expression.symbol)
 170
 171 def convert_variable_expression(expression):
 172     return CPSVariableExpression(variable=expression.variable)
 173
 174 def convert_expression(expression):
 175     return {
 176         normalization.NormalFunctionCallExpression: convert_function_call_expression,
 177         normalization.NormalIntegerLiteralExpression: convert_integer_literal_expression,
 178         normalization.NormalListConstructExpression: convert_list_construct_expression,
 179         normalization.NormalStringLiteralExpression: convert_string_literal_expression,
 180         normalization.NormalStructureLiteralExpression: convert_structure_literal_expression,
 181         normalization.NormalSymbolExpression: convert_symbol_expression,
 182         normalization.NormalVariableExpression: convert_variable_expression,
 183     }[type(expression)](expression)
 184
 185 def convert_array_variable_initialization_statement(statement):
 186     return CPSArrayVariableInitializationStatement(
 187         variable=statement.variable,
 188         items=tuple(convert_expression(e) for e in statement.items),
 189     )
 190
 191 def convert_assignment_statement(statement):
 192     return CPSAssignmentStatement(
 193         target=statement.target,
 194         expression=convert_expression(statement.expression),
 195     )
 196
 197 def convert_expression_statement(statement):
 198     return CPSExpressionStatement(
 199         expression=convert_expression(statement.expression),
 200     )
 201
 202 def convert_function_definition_statement(statement):
 203     return CPSFunctionDefinitionStatement(
 204         name=statement.name,
 205         argument_name_list=statement.argument_name_list,
 206         statement_list=tuple(convert_statement(s) for s in statement.statement_list),
 207     )
 208
 209 def convert_if_else_statement(statement):
 210     return CPSIfElseStatement(
 211         condition_expression=convert_expression(statement.condition_expression),
 212         if_statement_list=tuple(convert_statement(s) for s in statement.if_statement_list),
 213         else_statement_list=tuple(convert_statement(s) for s in statement.else_statement_list),
 214     )
 215
 216 def convert_list_append_statement(statement):
 217     return CPSListAppendStatement(
 218         list_expression=convert_expression(statement.list_expression),
 219         item_expression=convert_expression(statement.item_expression),
 220     )
 221
 222
 223 def convert_push_statement(statement):
 224     return CPSPushStatement(
 225         expression=convert_expression(statement.expression),
 226     )
 227
 228 def convert_variable_initialization_statement(statement):
 229     return CPSVariableInitializationStatement(
 230         variable=statement.variable,
 231         expression=convert_expression(statement.expression),
 232     )
 233
 234 def convert_variable_reassignment_statement(statement):
 235     return CPSVariableReassignmentStatement(
 236         variable=statement.variable,
 237         expression=convert_expression(statement.expression),
 238     )
 239
 240 def convert_symbol_array_variable_initialization_statement(statement):
 241     return CPSSymbolArrayVariableInitializationStatement(
 242         variable=statement.variable,
 243         symbol_list=statement.symbol_list,
 244     )
 245
 246 def convert_statement(statement):
 247     return {
 248         normalization.NormalArrayVariableInitializationStatement: convert_array_variable_initialization_statement,
 249         normalization.NormalAssignmentStatement: convert_assignment_statement,
 250         normalization.NormalExpressionStatement: convert_expression_statement,
 251         normalization.NormalFunctionDefinitionStatement: convert_function_definition_statement,
 252         normalization.NormalIfElseStatement: convert_if_else_statement,
 253         normalization.NormalListAppendStatement: convert_list_append_statement,
 254         normalization.NormalPushStatement: convert_push_statement,
 255         normalization.NormalVariableInitializationStatement: convert_variable_initialization_statement,
 256         normalization.NormalVariableReassignmentStatement: convert_variable_reassignment_statement,
 257         normalization.NormalSymbolArrayVariableInitializationStatement: convert_symbol_array_variable_initialization_statement,
 258     }[type(statement)](statement)
 259
 260 def convert(program):
 261     return CPSProgram(
 262         statement_list=tuple(convert_statement(s) for s in program.statement_list),
 263     )