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 CPSLambdaExpression = collections.namedtuple(
  22     'CPSLambdaExpression',
  23     (
  24         'name',
  25         'argument_name_list',
  26         'statement_list',
  27     ),
  28 )
  29
  30 CPSListConstructExpression = collections.namedtuple(
  31     'CPSListConstructExpression',
  32     (
  33         'allocate',
  34     ),
  35 )
  36
  37 CPSStringLiteralExpression = collections.namedtuple(
  38     'CPSStringLiteralExpression',
  39     (
  40         'string',
  41     ),
  42 )
  43
  44 CPSStructureLiteralExpression = collections.namedtuple(
  45     'CPSStructureLiteralExpression',
  46     (
  47         'field_count',
  48         'symbol_list_variable',
  49         'value_list_variable',
  50     ),
  51 )
  52
  53 CPSSymbolExpression = collections.namedtuple(
  54     'CPSSymbolExpression',
  55     (
  56         'symbol',
  57     ),
  58 )
  59
  60 CPSVariableExpression = collections.namedtuple(
  61     'CPSVariableExpression',
  62     (
  63         'variable',
  64     ),
  65 )
  66
  67 CPSArrayVariableInitializationStatement = collections.namedtuple(
  68     'CPSArrayVariableInitializationStatement',
  69     (
  70         'variable',
  71         'items',
  72     ),
  73 )
  74
  75 CPSAssignmentStatement = collections.namedtuple(
  76     'CPSAssignmentStatement',
  77     (
  78         'target',
  79         'expression',
  80     ),
  81 )
  82
  83 CPSExpressionStatement = collections.namedtuple(
  84     'CPSExpressionStatement',
  85     (
  86         'expression',
  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_lambda_expression(expression):
 156     return CPSLambdaExpression(
 157         name=expression.name,
 158         argument_name_list=expression.argument_name_list,
 159         statement_list=tuple(convert_statement(s) for s in expression.statement_list),
 160     )
 161
 162 def convert_list_construct_expression(expression):
 163     return CPSListConstructExpression(allocate=expression.allocate)
 164
 165 def convert_string_literal_expression(expression):
 166     return CPSStringLiteralExpression(string=expression.string)
 167
 168 def convert_structure_literal_expression(expression):
 169     return CPSStructureLiteralExpression(
 170         field_count=expression.field_count,
 171         symbol_list_variable=expression.symbol_list_variable,
 172         value_list_variable=expression.value_list_variable,
 173     )
 174
 175 def convert_symbol_expression(expression):
 176     return CPSSymbolExpression(symbol=expression.symbol)
 177
 178 def convert_variable_expression(expression):
 179     return CPSVariableExpression(variable=expression.variable)
 180
 181 def convert_expression(expression):
 182     return {
 183         normalization.NormalFunctionCallExpression: convert_function_call_expression,
 184         normalization.NormalIntegerLiteralExpression: convert_integer_literal_expression,
 185         normalization.NormalLambdaExpression: convert_lambda_expression,
 186         normalization.NormalListConstructExpression: convert_list_construct_expression,
 187         normalization.NormalStringLiteralExpression: convert_string_literal_expression,
 188         normalization.NormalStructureLiteralExpression: convert_structure_literal_expression,
 189         normalization.NormalSymbolExpression: convert_symbol_expression,
 190         normalization.NormalVariableExpression: convert_variable_expression,
 191     }[type(expression)](expression)
 192
 193 def convert_array_variable_initialization_statement(statement):
 194     return CPSArrayVariableInitializationStatement(
 195         variable=statement.variable,
 196         items=tuple(convert_expression(e) for e in statement.items),
 197     )
 198
 199 def convert_assignment_statement(statement):
 200     return CPSAssignmentStatement(
 201         target=statement.target,
 202         expression=convert_expression(statement.expression),
 203     )
 204
 205 def convert_expression_statement(statement):
 206     return CPSExpressionStatement(
 207         expression=convert_expression(statement.expression),
 208     )
 209
 210 def convert_if_else_statement(statement):
 211     return CPSIfElseStatement(
 212         condition_expression=convert_expression(statement.condition_expression),
 213         if_statement_list=tuple(convert_statement(s) for s in statement.if_statement_list),
 214         else_statement_list=tuple(convert_statement(s) for s in statement.else_statement_list),
 215     )
 216
 217 def convert_list_append_statement(statement):
 218     return CPSListAppendStatement(
 219         list_expression=convert_expression(statement.list_expression),
 220         item_expression=convert_expression(statement.item_expression),
 221     )
 222
 223
 224 def convert_push_statement(statement):
 225     return CPSPushStatement(
 226         expression=convert_expression(statement.expression),
 227     )
 228
 229 def convert_variable_initialization_statement(statement):
 230     return CPSVariableInitializationStatement(
 231         variable=statement.variable,
 232         expression=convert_expression(statement.expression),
 233     )
 234
 235 def convert_variable_reassignment_statement(statement):
 236     return CPSVariableReassignmentStatement(
 237         variable=statement.variable,
 238         expression=convert_expression(statement.expression),
 239     )
 240
 241 def convert_symbol_array_variable_initialization_statement(statement):
 242     return CPSSymbolArrayVariableInitializationStatement(
 243         variable=statement.variable,
 244         symbol_list=statement.symbol_list,
 245     )
 246
 247 def convert_statement(statement):
 248     return {
 249         normalization.NormalArrayVariableInitializationStatement: convert_array_variable_initialization_statement,
 250         normalization.NormalAssignmentStatement: convert_assignment_statement,
 251         normalization.NormalExpressionStatement: convert_expression_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     )