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

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