NormalSymbolExpression = collections.namedtuple(
'NormalSymbolExpression',
- [
+ (
'symbol',
- ],
+ ),
+)
+
+NormalSymbolLiteralExpression = collections.namedtuple(
+ 'NormalSymbolLiteralExpression',
+ (
+ 'symbol',
+ ),
)
NormalPushStatement = collections.namedtuple(
],
)
-NormalArrayVariableInitializationStatement = collections.namedtuple(
- 'NormalArrayVariableInitializationStatement',
- [
- 'variable',
- 'items',
- ],
-)
-
-NormalSymbolArrayVariableInitializationStatement = collections.namedtuple(
- 'NormalSymbolArrayVariableInitializationStatement',
- [
- 'variable',
- 'symbol_list',
- ],
-)
-
NormalVariableInitializationStatement = collections.namedtuple(
'NormalVariableInitializationStatement',
[
prestatements = []
- list_expression = NormalVariableExpression(variable=list_variable)
-
for item_expression in expression.item_expression_list:
counter, item_expression_prestatements, normalized = normalize_expression(
counter,
)
)
- prestatements.append(NormalVariableInitializationStatement(
- variable=list_variable,
- expression=NormalListConstructExpression(allocate=len(expression.item_expression_list)),
- ))
-
return (
counter,
tuple(prestatements),
- list_expression,
+ NormalListConstructExpression(allocate=len(expression.item_expression_list)),
)
def normalize_string_literal_expression(counter, expression):
NormalStructureLiteralExpression = collections.namedtuple(
'NormalStructureLiteralExpression',
- [
+ (
'field_count',
- 'symbol_list_variable',
- 'value_list_variable',
- ],
+ ),
)
def normalize_structure_literal_expression(counter, expression):
prestatements = []
- field_symbol_array = []
- field_value_array = []
- for symbol_expression_pair in expression.fields:
- counter, field_prestatements, field_expression = normalize_expression(
+ for field in expression.fields:
+ counter, field_expression_prestatements, field_expression = normalize_expression(
counter,
- symbol_expression_pair.expression,
+ field.expression,
)
- for p in field_prestatements:
+ for p in field_expression_prestatements:
prestatements.append(p)
- field_symbol_array.append(symbol_expression_pair.symbol)
- field_value_array.append(field_expression)
-
- symbol_array_variable = '${}'.format(counter)
- counter += 1
-
- prestatements.append(
- NormalSymbolArrayVariableInitializationStatement(
- variable=symbol_array_variable,
- symbol_list=tuple(field_symbol_array),
- )
- )
-
- value_array_variable = '${}'.format(counter)
- counter += 1
-
- prestatements.append(
- NormalArrayVariableInitializationStatement(
- variable=value_array_variable,
- items=tuple(field_value_array),
- )
- )
-
- variable = '${}'.format(counter)
+ prestatements.append(NormalPushStatement(
+ expression=field_expression,
+ ))
- prestatements.append(
- NormalVariableInitializationStatement(
- variable=variable,
- expression=NormalStructureLiteralExpression(
- field_count=len(expression.fields),
- symbol_list_variable=symbol_array_variable,
- value_list_variable=value_array_variable,
+ prestatements.append(NormalPushStatement(
+ expression=NormalSymbolLiteralExpression(
+ symbol=field.symbol,
),
- )
- )
+ ))
return (
- counter + 1,
+ counter,
tuple(prestatements),
- NormalVariableExpression(variable=variable),
+ NormalStructureLiteralExpression(
+ field_count=len(expression.fields),
+ ),
)
-
def normalize_symbol_expression(counter, expression):
return (
counter,