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

   1 import jinja2
   2
   3 import transformation
   4
   5 ENV = jinja2.Environment(
   6     autoescape=jinja2.select_autoescape([]),
   7     loader=jinja2.FileSystemLoader('templates'),
   8     trim_blocks=True,
   9 )
  10
  11 def generate_integer_literal(c_integer_literal):
  12     return 'integerLiteral({})'.format(c_integer_literal.value)
  13
  14 def generate_string_literal(c_string_literal):
  15     return 'stringLiteral(STRING_LITERAL_LIST[{}] /* string: {} */)'.format(
  16         c_string_literal.index,
  17         repr(c_string_literal.value),
  18     )
  19
  20 def generate_symbol_expression(symbol_expression):
  21     return 'Environment_get(environment, SYMBOL_LIST[{}] /* symbol: {} */)'.format(
  22         symbol_expression.symbol_list_index,
  23         symbol_expression.symbol,
  24     )
  25
  26 def generate_variable_expression(expression):
  27     return expression.variable
  28
  29 def generate_structure_literal_expression(expression):
  30     return 'Structure_construct({}, {}, {})'.format(
  31         expression.field_count,
  32         expression.symbol_list_variable,
  33         expression.value_list_variable,
  34     )
  35
  36 def generate_lambda_expression(expression):
  37     return '(Object){{ CLOSURE, (Instance)(Closure){{ environment, user${}${}$implementation }} }}'.format(
  38         expression.name,
  39         expression.index,
  40     )
  41
  42 def generate_list_construct_expression(expression):
  43     return 'List_construct({})'.format(expression.allocate)
  44
  45 def generate_expression(expression):
  46     return {
  47         transformation.CFunctionCallExpression: generate_function_call,
  48         transformation.CIfElseExpression: generate_if_else_expression,
  49         transformation.CIntegerLiteral: generate_integer_literal,
  50         transformation.CLambdaExpression: generate_lambda_expression,
  51         transformation.CListConstructExpression: generate_list_construct_expression,
  52         transformation.CStringLiteral: generate_string_literal,
  53         transformation.CStructureLiteralExpression: generate_structure_literal_expression,
  54         transformation.CSymbolExpression: generate_symbol_expression,
  55         transformation.CVariableExpression: generate_variable_expression,
  56     }[type(expression)](expression)
  57
  58 def generate_function_call(function_call):
  59     # This gets called twice, so we want to be sure it is efficient and without side effects
  60     assert isinstance(function_call.function_expression, transformation.CSymbolExpression)
  61
  62     # TODO Check the type of the things being called
  63     function_expression = generate_expression(function_call.function_expression)
  64     return '{}.instance.closure.call(environmentPool, {}.instance.closure.closed, {}, stack, {}, jump)'.format(
  65         function_expression,
  66         function_expression,
  67         function_call.argument_count,
  68         function_call.metadata.line,
  69     )
  70
  71 def generate_expression_statement(statement):
  72     return 'Object_deinitialize(&({}));'.format(generate_expression(statement.expression))
  73
  74 def generate_symbol_assignment_statement(statement):
  75     return 'Environment_set(environment, SYMBOL_LIST[{}] /* symbol: {} */, {});'.format(
  76         statement.target_symbol_list_index,
  77         statement.target,
  78         generate_expression(statement.expression),
  79     )
  80
  81 def generate_array_variable_initialization_statement(statement):
  82     return 'Object {}[] = {{ {} }};'.format(
  83         statement.variable,
  84         ', '.join(generate_expression(i) for i in statement.items),
  85     )
  86
  87 def generate_symbol_array_variable_initialization_statement(statement):
  88     return 'const char* {}[] = {{ {} }};'.format(
  89         statement.variable,
  90         ', '.join('SYMBOL_LIST[{}] /* symbol: "{}" */'.format(
  91             statement.symbol_list_indices[i],
  92             statement.symbol_list[i],
  93         ) for i in range(len(statement.symbol_list))),
  94     )
  95
  96 def generate_variable_initialization_statement(statement):
  97     return 'Object {} = {};'.format(
  98         statement.variable,
  99         generate_expression(statement.expression),
 100     )
 101
 102 def indent(s):
 103     return '\n'.join(' ' * 2 + l for l in s.split('\n'))
 104
 105 def generate_if_else_expression(statement):
 106     # TODO Check that the argument is boolean
 107     condition_expression = '{}.instance.boolean'.format(
 108         generate_expression(statement.condition_expression),
 109     )
 110
 111     if len(statement.if_statement_list) == 0:
 112         condition_expression = '!({})'.format(condition_expression)
 113         if_statement_list = statement.else_statement_list
 114         else_statement_list = ()
 115     else:
 116         if_statement_list = statement.if_statement_list
 117         else_statement_list = statement.else_statement_list
 118
 119     generated_if_clause = 'if({})'.format(condition_expression)
 120
 121     if len(if_statement_list) == 0:
 122         generated_if_statement_list = ';'
 123     else:
 124         generated_if_statement_list = indent('\n{{\n{}\n}}'.format(
 125             indent('\n'.join(generate_statement(s) for s in if_statement_list)),
 126         ))
 127
 128     if len(else_statement_list) == 0:
 129         generated_else_statement_list = ''
 130     else:
 131         generated_else_statement_list = indent('\nelse\n{{\n{}\n}}'.format(
 132             indent('\n'.join(generate_statement(s) for s in else_statement_list)),
 133         ))
 134
 135     return generated_if_clause + generated_if_statement_list + generated_else_statement_list
 136
 137 def generate_list_append_statement(statement):
 138     return 'List_append(&{}, {});'.format(
 139         generate_expression(statement.list_expression),
 140         generate_expression(statement.item_expression),
 141     )
 142
 143 def generate_push_statement(statement):
 144     return 'Stack_push(stack, {});'.format(generate_expression(statement.expression))
 145
 146 def generate_statement(statement):
 147     return {
 148         transformation.CArrayVariableInitializationStatement: generate_array_variable_initialization_statement,
 149         transformation.CExpressionStatement: generate_expression_statement,
 150         transformation.CListAppendStatement: generate_list_append_statement,
 151         transformation.CPushStatement: generate_push_statement,
 152         transformation.CSymbolAssignmentStatement: generate_symbol_assignment_statement,
 153         transformation.CSymbolArrayVariableInitializationStatement: generate_symbol_array_variable_initialization_statement,
 154         transformation.CVariableInitializationStatement: generate_variable_initialization_statement,
 155     }[type(statement)](statement)
 156
 157 def generate_function_definition(definition):
 158     template = ENV.get_template('function_definition.c')
 159     return template.render(
 160         name=definition.name,
 161         index=definition.index,
 162         argument_name_list=definition.argument_name_list,
 163         statement_list=list(generate_statement(s) for s in definition.statement_list),
 164     )
 165     return definition
 166
 167 C_ESCAPES = {
 168     '"':    r'\"',
 169 }
 170
 171 def escape_character(ch):
 172     return C_ESCAPES.get(ch, ch)
 173
 174 def escape_string_literal(string_literal):
 175     return  ''.join(escape_character(ch) for ch in string_literal)
 176
 177 def generate(program):
 178     template = ENV.get_template('program.c')
 179     return template.render(
 180         builtins=tuple(sorted(program.builtin_set)),
 181         function_definition_list=list(generate_function_definition(fd) for fd in program.function_definition_list),
 182         infix_declarations=program.operator_declarations,
 183         statements=list(generate_statement(s) for s in program.statements),
 184         standard_libraries=list(sorted(program.standard_libraries)),
 185         string_literal_list=list(escape_string_literal(s) for s in program.string_literal_list),
 186         symbol_list=program.symbol_list,
 187     )
 188
 189 if __name__ == '__main__':
 190     import unittest
 191
 192     unittest.main()