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     ),
  49 )
  50
  51 CPSSymbolExpression = collections.namedtuple(
  52     'CPSSymbolExpression',
  53     (
  54         'symbol',
  55     ),
  56 )
  57
  58 CPSSymbolLiteralExpression = collections.namedtuple(
  59     'CPSSymbolLiteralExpression',
  60     (
  61         'symbol',
  62     ),
  63 )
  64
  65 CPSVariableExpression = collections.namedtuple(
  66     'CPSVariableExpression',
  67     (
  68         'variable',
  69     ),
  70 )
  71
  72 CPSArrayVariableInitializationStatement = collections.namedtuple(
  73     'CPSArrayVariableInitializationStatement',
  74     (
  75         'variable',
  76         'items',
  77     ),
  78 )
  79
  80 CPSAssignmentStatement = collections.namedtuple(
  81     'CPSAssignmentStatement',
  82     (
  83         'target',
  84         'expression',
  85     ),
  86 )
  87
  88 CPSExpressionStatement = collections.namedtuple(
  89     'CPSExpressionStatement',
  90     (
  91         'expression',
  92     ),
  93 )
  94
  95 CPSIfElseExpression = collections.namedtuple(
  96     'CPSIfElseExpression',
  97     (
  98         'condition_expression',
  99         'if_statement_list',
 100         'else_statement_list',
 101     ),
 102 )
 103
 104 CPSListAppendStatement = collections.namedtuple(
 105     'CPSListAppendStatement',
 106     (
 107         'list_expression',
 108         'item_expression',
 109     ),
 110 )
 111
 112 CPSPushStatement = collections.namedtuple(
 113     'CPSPushStatement',
 114     (
 115         'expression',
 116     ),
 117 )
 118
 119 CPSVariableInitializationStatement = collections.namedtuple(
 120     'CPSVariableInitializationStatement',
 121     (
 122         'variable',
 123         'expression',
 124     ),
 125 )
 126
 127 CPSSymbolArrayVariableInitializationStatement = collections.namedtuple(
 128     'CPSSymbolArrayVariableInitializationStatement',
 129     (
 130         'variable',
 131         'symbol_list',
 132     ),
 133 )
 134
 135 CPSProgram = collections.namedtuple(
 136     'CPSProgram',
 137     (
 138         'statement_list',
 139     ),
 140 )
 141
 142 def convert_function_call_expression(expression):
 143     return CPSFunctionCallExpression(
 144         metadata=expression.metadata,
 145         function_expression=convert_expression(expression.function_expression),
 146         argument_count=expression.argument_count,
 147     )
 148
 149 def convert_integer_literal_expression(expression):
 150     return CPSIntegerLiteralExpression(integer=expression.integer)
 151
 152 def convert_lambda_expression(expression):
 153     return CPSLambdaExpression(
 154         name=expression.name,
 155         argument_name_list=expression.argument_name_list,
 156         statement_list=tuple(convert_statement(s) for s in expression.statement_list),
 157     )
 158
 159 def convert_list_construct_expression(expression):
 160     return CPSListConstructExpression(allocate=expression.allocate)
 161
 162 def convert_string_literal_expression(expression):
 163     return CPSStringLiteralExpression(string=expression.string)
 164
 165 def convert_structure_literal_expression(expression):
 166     return CPSStructureLiteralExpression(
 167         field_count=expression.field_count,
 168     )
 169
 170 def convert_symbol_expression(expression):
 171     return CPSSymbolExpression(symbol=expression.symbol)
 172
 173 def convert_symbol_literal_expression(expression):
 174     return CPSSymbolLiteralExpression(symbol=expression.symbol)
 175
 176 def convert_variable_expression(expression):
 177     return CPSVariableExpression(variable=expression.variable)
 178
 179 def convert_expression(expression):
 180     return {
 181         normalization.NormalFunctionCallExpression: convert_function_call_expression,
 182         normalization.NormalIfElseExpression: convert_if_else_expression,
 183         normalization.NormalIntegerLiteralExpression: convert_integer_literal_expression,
 184         normalization.NormalLambdaExpression: convert_lambda_expression,
 185         normalization.NormalListConstructExpression: convert_list_construct_expression,
 186         normalization.NormalStringLiteralExpression: convert_string_literal_expression,
 187         normalization.NormalStructureLiteralExpression: convert_structure_literal_expression,
 188         normalization.NormalSymbolExpression: convert_symbol_expression,
 189         normalization.NormalSymbolLiteralExpression: convert_symbol_literal_expression,
 190         normalization.NormalVariableExpression: convert_variable_expression,
 191     }[type(expression)](expression)
 192
 193 def convert_assignment_statement(statement):
 194     return CPSAssignmentStatement(
 195         target=statement.target,
 196         expression=convert_expression(statement.expression),
 197     )
 198
 199 def convert_expression_statement(statement):
 200     return CPSExpressionStatement(
 201         expression=convert_expression(statement.expression),
 202     )
 203
 204 def convert_if_else_expression(statement):
 205     if_statement_list=tuple(convert_statement(s) for s in statement.if_statement_list)
 206     else_statement_list=tuple(convert_statement(s) for s in statement.else_statement_list)
 207
 208     return CPSIfElseExpression(
 209         condition_expression=convert_expression(statement.condition_expression),
 210         if_statement_list=if_statement_list,
 211         else_statement_list=else_statement_list,
 212     )
 213
 214 def convert_list_append_statement(statement):
 215     return CPSListAppendStatement(
 216         list_expression=convert_expression(statement.list_expression),
 217         item_expression=convert_expression(statement.item_expression),
 218     )
 219
 220
 221 def convert_push_statement(statement):
 222     return CPSPushStatement(
 223         expression=convert_expression(statement.expression),
 224     )
 225
 226 def convert_variable_initialization_statement(statement):
 227     return CPSVariableInitializationStatement(
 228         variable=statement.variable,
 229         expression=convert_expression(statement.expression),
 230     )
 231
 232 def convert_statement(statement):
 233     return {
 234         normalization.NormalAssignmentStatement: convert_assignment_statement,
 235         normalization.NormalExpressionStatement: convert_expression_statement,
 236         normalization.NormalListAppendStatement: convert_list_append_statement,
 237         normalization.NormalPushStatement: convert_push_statement,
 238         normalization.NormalVariableInitializationStatement: convert_variable_initialization_statement,
 239     }[type(statement)](statement)
 240
 241 def convert_statement_list(statement_list):
 242     return tuple(convert_statement(s) for s in statement_list)
 243
 244
 245 def convert(program):
 246     return CPSProgram(
 247         statement_list=convert_statement_list(program.statement_list),
 248     )