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