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 CPSPushStatement = collections.namedtuple(
 105     'CPSPushStatement',
 106     (
 107         'expression',
 108     ),
 109 )
 110
 111 CPSVariableInitializationStatement = collections.namedtuple(
 112     'CPSVariableInitializationStatement',
 113     (
 114         'variable',
 115         'expression',
 116     ),
 117 )
 118
 119 CPSSymbolArrayVariableInitializationStatement = collections.namedtuple(
 120     'CPSSymbolArrayVariableInitializationStatement',
 121     (
 122         'variable',
 123         'symbol_list',
 124     ),
 125 )
 126
 127 CPSProgram = collections.namedtuple(
 128     'CPSProgram',
 129     (
 130         'statement_list',
 131     ),
 132 )
 133
 134 def convert_function_call_expression(expression):
 135     return CPSFunctionCallExpression(
 136         metadata=expression.metadata,
 137         function_expression=convert_expression(expression.function_expression),
 138         argument_count=expression.argument_count,
 139     )
 140
 141 def convert_integer_literal_expression(expression):
 142     return CPSIntegerLiteralExpression(integer=expression.integer)
 143
 144 def convert_lambda_expression(expression):
 145     return CPSLambdaExpression(
 146         name=expression.name,
 147         argument_name_list=expression.argument_name_list,
 148         statement_list=tuple(convert_statement(s) for s in expression.statement_list),
 149     )
 150
 151 def convert_list_construct_expression(expression):
 152     return CPSListConstructExpression(allocate=expression.allocate)
 153
 154 def convert_string_literal_expression(expression):
 155     return CPSStringLiteralExpression(string=expression.string)
 156
 157 def convert_structure_literal_expression(expression):
 158     return CPSStructureLiteralExpression(
 159         field_count=expression.field_count,
 160     )
 161
 162 def convert_symbol_expression(expression):
 163     return CPSSymbolExpression(symbol=expression.symbol)
 164
 165 def convert_symbol_literal_expression(expression):
 166     return CPSSymbolLiteralExpression(symbol=expression.symbol)
 167
 168 def convert_variable_expression(expression):
 169     return CPSVariableExpression(variable=expression.variable)
 170
 171 def convert_expression(expression):
 172     return {
 173         normalization.NormalFunctionCallExpression: convert_function_call_expression,
 174         normalization.NormalIfElseExpression: convert_if_else_expression,
 175         normalization.NormalIntegerLiteralExpression: convert_integer_literal_expression,
 176         normalization.NormalLambdaExpression: convert_lambda_expression,
 177         normalization.NormalListConstructExpression: convert_list_construct_expression,
 178         normalization.NormalStringLiteralExpression: convert_string_literal_expression,
 179         normalization.NormalStructureLiteralExpression: convert_structure_literal_expression,
 180         normalization.NormalSymbolExpression: convert_symbol_expression,
 181         normalization.NormalSymbolLiteralExpression: convert_symbol_literal_expression,
 182         normalization.NormalVariableExpression: convert_variable_expression,
 183     }[type(expression)](expression)
 184
 185 def convert_assignment_statement(statement):
 186     return CPSAssignmentStatement(
 187         target=statement.target,
 188         expression=convert_expression(statement.expression),
 189     )
 190
 191 def convert_expression_statement(statement):
 192     return CPSExpressionStatement(
 193         expression=convert_expression(statement.expression),
 194     )
 195
 196 def convert_if_else_expression(statement):
 197     if_statement_list=tuple(convert_statement(s) for s in statement.if_statement_list)
 198     else_statement_list=tuple(convert_statement(s) for s in statement.else_statement_list)
 199
 200     return CPSIfElseExpression(
 201         condition_expression=convert_expression(statement.condition_expression),
 202         if_statement_list=if_statement_list,
 203         else_statement_list=else_statement_list,
 204     )
 205
 206 def convert_push_statement(statement):
 207     return CPSPushStatement(
 208         expression=convert_expression(statement.expression),
 209     )
 210
 211 def convert_variable_initialization_statement(statement):
 212     return CPSVariableInitializationStatement(
 213         variable=statement.variable,
 214         expression=convert_expression(statement.expression),
 215     )
 216
 217 def convert_statement(statement):
 218     return {
 219         normalization.NormalAssignmentStatement: convert_assignment_statement,
 220         normalization.NormalExpressionStatement: convert_expression_statement,
 221         normalization.NormalPushStatement: convert_push_statement,
 222         normalization.NormalVariableInitializationStatement: convert_variable_initialization_statement,
 223     }[type(statement)](statement)
 224
 225 def convert_statement_list(statement_list):
 226     return tuple(convert_statement(s) for s in statement_list)
 227
 228
 229 def convert(program):
 230     return CPSProgram(
 231         statement_list=convert_statement_list(program.statement_list),
 232     )