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

   1 import collections
   2
   3 import parsing
   4
   5 NormalVariableExpression = collections.namedtuple(
   6     'NormalVariableExpression',
   7     [
   8         'variable',
   9     ],
  10 )
  11
  12 NormalNegationExpression = collections.namedtuple(
  13     'NormalNegationExpression',
  14     [
  15         'internal_expression',
  16     ],
  17 )
  18
  19 NormalInfixExpression = collections.namedtuple(
  20     'NormalInfixExpression',
  21     [
  22         'order',
  23         'operator',
  24         'left',
  25         'right',
  26     ],
  27 )
  28
  29 NormalFunctionCallExpression = collections.namedtuple(
  30     'NormalFunctionCallExpression',
  31     [
  32         'function',
  33         'arguments',
  34     ],
  35 )
  36
  37 NormalVariableInitializationStatement = collections.namedtuple(
  38     'NormalVariableInitializationStatement',
  39     [
  40         'variable',
  41         'expression',
  42     ],
  43 )
  44
  45 NormalVariableReassignmentStatement = collections.namedtuple(
  46     'NormalVariableReassignmentStatement',
  47     [
  48         'variable',
  49         'expression',
  50     ],
  51 )
  52
  53 NormalExpressionStatement = collections.namedtuple(
  54     'NormalExpressionStatement',
  55     [
  56         'expression',
  57     ],
  58 )
  59
  60 NormalIfElseStatement = collections.namedtuple(
  61     'NormalIfElseStatement',
  62     [
  63         'condition_expression',
  64         'if_statements',
  65         'else_statements',
  66     ],
  67 )
  68
  69 NormalProgram = collections.namedtuple(
  70     'NormalProgram',
  71     [
  72         'statement_list',
  73     ],
  74 )
  75
  76 def fake_normalization(counter, thing):
  77     return (counter, (), thing)
  78
  79 def normalize_function_call_expression(counter, expression):
  80     assert isinstance(expression, parsing.FurFunctionCallExpression)
  81
  82     prestatements = []
  83     arguments = []
  84
  85     for argument in expression.arguments:
  86         counter, argument_prestatements, normalized_argument = normalize_expression(counter, argument)
  87
  88         for s in argument_prestatements:
  89             prestatements.append(s)
  90
  91         variable = '${}'.format(counter)
  92         prestatements.append(NormalVariableInitializationStatement(
  93             variable=variable,
  94             expression=normalized_argument,
  95         ))
  96         arguments.append(NormalVariableExpression(
  97             variable=variable,
  98         ))
  99         counter += 1
 100
 101     return (
 102         counter,
 103         tuple(prestatements),
 104         NormalFunctionCallExpression(
 105             expression.function, # TODO Normalize the function
 106             arguments=tuple(arguments),
 107         ),
 108     )
 109
 110 def normalize_basic_infix_operation(counter, expression):
 111     counter, left_prestatements, left_expression = normalize_expression(counter, expression.left)
 112     counter, right_prestatements, right_expression = normalize_expression(counter, expression.right)
 113
 114     left_variable = '${}'.format(counter)
 115     counter += 1
 116     right_variable = '${}'.format(counter)
 117     counter += 1
 118
 119     root_prestatements = (
 120         NormalVariableInitializationStatement(
 121             variable=left_variable,
 122             expression=left_expression,
 123         ),
 124         NormalVariableInitializationStatement(
 125             variable=right_variable,
 126             expression=right_expression,
 127         ),
 128     )
 129
 130     return (
 131         counter,
 132         left_prestatements + right_prestatements + root_prestatements,
 133         NormalInfixExpression(
 134             order=expression.order, # TODO Do we need this?
 135             operator=expression.operator,
 136             left=NormalVariableExpression(variable=left_variable),
 137             right=NormalVariableExpression(variable=right_variable),
 138         ),
 139     )
 140
 141 def normalize_comparison_expression(counter, expression):
 142     stack = []
 143
 144     while isinstance(expression.left, parsing.FurInfixExpression) and expression.order == 'comparison_level':
 145         stack.append((expression.operator, expression.order, expression.right))
 146         expression = expression.left
 147
 148     counter, left_prestatements, left_expression = normalize_expression(counter, expression.left)
 149     counter, right_prestatements, right_expression = normalize_expression(counter, expression.right)
 150
 151     left_variable = '${}'.format(counter)
 152     counter += 1
 153     right_variable = '${}'.format(counter)
 154     counter += 1
 155
 156     root_prestatements = (
 157         NormalVariableInitializationStatement(
 158             variable=left_variable,
 159             expression=left_expression,
 160         ),
 161         NormalVariableInitializationStatement(
 162             variable=right_variable,
 163             expression=right_expression,
 164         ),
 165     )
 166
 167     counter, result_prestatements, result_expression = (
 168         counter,
 169         left_prestatements + right_prestatements + root_prestatements,
 170         # TODO Implement short-circuiting
 171         NormalInfixExpression(
 172             order=expression.order, # TODO Do we need this?
 173             operator=expression.operator,
 174             left=NormalVariableExpression(variable=left_variable),
 175             right=NormalVariableExpression(variable=right_variable),
 176         ),
 177     )
 178
 179     while len(stack) > 0:
 180         right_operator, right_order, right_expression = stack.pop()
 181         and_right_expression = parsing.FurInfixExpression(
 182             operator=right_operator,
 183             order=right_order,
 184             left=NormalVariableExpression(variable=right_variable),
 185             right=right_expression,
 186         )
 187
 188         and_expression = parsing.FurInfixExpression(
 189             operator='and',
 190             order='and_level',
 191             left=result_expression,
 192             right=and_right_expression,
 193         )
 194
 195         counter, and_prestatements, result_expression = normalize_boolean_expression(
 196             counter,
 197             and_expression,
 198         )
 199
 200         result_prestatements = result_prestatements + and_prestatements
 201
 202     return (counter, result_prestatements, result_expression)
 203
 204 def normalize_boolean_expression(counter, expression):
 205     counter, left_prestatements, left_expression = normalize_expression(counter, expression.left)
 206     counter, right_prestatements, right_expression = normalize_expression(counter, expression.right)
 207
 208     result_variable = '${}'.format(counter)
 209     if_else_prestatment = NormalVariableInitializationStatement(variable=result_variable, expression=left_expression)
 210     counter += 1
 211
 212     condition_expression=NormalVariableExpression(variable=result_variable)
 213     short_circuited_statements = right_prestatements + (NormalVariableReassignmentStatement(variable=result_variable, expression=right_expression),)
 214
 215     if expression.operator == 'and':
 216         if_else_statement = NormalIfElseStatement(
 217             condition_expression=condition_expression,
 218             if_statements=short_circuited_statements,
 219             else_statements=(),
 220         )
 221
 222     elif expression.operator == 'or':
 223         if_else_statement = NormalIfElseStatement(
 224             condition_expression=condition_expression,
 225             if_statements=(),
 226             else_statements=short_circuited_statements,
 227         )
 228
 229     else:
 230         raise Exception('Unable to handle operator "{}"'.format(expression.operator))
 231
 232     return (
 233         counter,
 234         left_prestatements + (if_else_prestatment, if_else_statement),
 235         NormalVariableExpression(variable=result_variable),
 236     )
 237
 238
 239 def normalize_infix_expression(counter, expression):
 240     return {
 241         'multiplication_level': normalize_basic_infix_operation,
 242         'addition_level': normalize_basic_infix_operation,
 243         'comparison_level': normalize_comparison_expression,
 244         'and_level': normalize_boolean_expression,
 245         'or_level': normalize_boolean_expression,
 246     }[expression.order](counter, expression)
 247
 248 def normalize_negation_expression(counter, expression):
 249     counter, prestatements, internal_expression = normalize_expression(counter, expression.value)
 250
 251     internal_variable = '${}'.format(counter)
 252     counter += 1
 253
 254     return (
 255         counter,
 256         prestatements + (NormalVariableInitializationStatement(variable=internal_variable, expression=internal_expression),),
 257         NormalNegationExpression(internal_expression=NormalVariableExpression(variable=internal_variable)),
 258     )
 259
 260 def normalize_parenthesized_expression(counter, expression):
 261     return normalize_expression(counter, expression.internal)
 262
 263 def normalize_expression(counter, expression):
 264     return {
 265         NormalInfixExpression: fake_normalization,
 266         NormalVariableExpression: fake_normalization,
 267         parsing.FurFunctionCallExpression: normalize_function_call_expression,
 268         parsing.FurInfixExpression: normalize_infix_expression,
 269         parsing.FurIntegerLiteralExpression: fake_normalization,
 270         parsing.FurNegationExpression: normalize_negation_expression,
 271         parsing.FurParenthesizedExpression: normalize_parenthesized_expression,
 272         parsing.FurStringLiteralExpression: fake_normalization,
 273         parsing.FurSymbolExpression: fake_normalization,
 274     }[type(expression)](counter, expression)
 275
 276 def normalize_expression_statement(counter, statement):
 277     counter, prestatements, normalized = {
 278         parsing.FurFunctionCallExpression: normalize_function_call_expression,
 279     }[type(statement.expression)](counter, statement.expression)
 280
 281     return (
 282         counter,
 283         prestatements,
 284         NormalExpressionStatement(expression=normalized),
 285     )
 286
 287 def normalize_statement(counter, statement):
 288     return {
 289         parsing.FurExpressionStatement: normalize_expression_statement,
 290         parsing.FurAssignmentStatement: fake_normalization,
 291     }[type(statement)](counter, statement)
 292
 293 def normalize(program):
 294     counter = 0
 295     statement_list = []
 296
 297     for statement in program.statement_list:
 298         counter, prestatements, normalized = normalize_statement(counter, statement)
 299         for s in prestatements:
 300             statement_list.append(s)
 301         statement_list.append(normalized)
 302
 303     return NormalProgram(
 304         statement_list=statement_list,
 305     )