mirror of
https://github.com/irmen/prog8.git
synced 2024-07-19 04:28:56 +00:00
221 lines
12 KiB
Python
221 lines
12 KiB
Python
"""
|
|
Programming Language for 6502/6510 microprocessors, codename 'Sick'
|
|
This is the part of the compiler/optimizer that simplifies/evaluates expressions.
|
|
|
|
Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
|
|
"""
|
|
|
|
import sys
|
|
from .plylex import SourceRef
|
|
from .datatypes import VarType
|
|
from .plyparse import Module, Expression, LiteralValue, SymbolName, ParseError, VarDef, Dereference, Register,\
|
|
SubCall, AddressOf, AstNode, ExpressionWithOperator, ExpressionEvaluationError, \
|
|
math_functions, builtin_functions, check_symbol_definition
|
|
|
|
|
|
def handle_internal_error(exc: Exception, msg: str = "") -> None:
|
|
out = sys.stdout
|
|
if out.isatty():
|
|
print("\x1b[1m", file=out)
|
|
print("\nERROR: internal parser/optimizer error: ", exc, file=out)
|
|
if msg:
|
|
print(" Message:", msg, end="\n\n")
|
|
if out.isatty():
|
|
print("\x1b[0m", file=out, end="", flush=True)
|
|
raise exc
|
|
|
|
|
|
class ExpressionOptimizer:
|
|
def __init__(self, mod: Module) -> None:
|
|
self.num_warnings = 0
|
|
self.module = mod
|
|
self.optimizations_performed = False
|
|
|
|
def optimize(self, once: bool=False) -> None:
|
|
self.num_warnings = 0
|
|
if once:
|
|
self.constant_folding()
|
|
else:
|
|
self.optimizations_performed = True
|
|
# keep optimizing as long as there were changes made
|
|
while self.optimizations_performed:
|
|
self.optimizations_performed = False
|
|
self.constant_folding()
|
|
|
|
def constant_folding(self) -> None:
|
|
for expression in self.module.all_nodes(Expression):
|
|
if isinstance(expression, LiteralValue):
|
|
continue
|
|
try:
|
|
evaluated = self.process_expression(expression) # type: ignore
|
|
if evaluated is not expression:
|
|
# replace the node with the newly evaluated result
|
|
parent = expression.parent
|
|
parent.replace_node(expression, evaluated)
|
|
self.optimizations_performed = True
|
|
except ParseError:
|
|
raise
|
|
except Exception as x:
|
|
handle_internal_error(x, "process_expressions of node {}".format(expression))
|
|
|
|
def process_expression(self, expr: Expression) -> Expression:
|
|
# process/simplify all expressions (constant folding etc)
|
|
result = None # type: Expression
|
|
if expr.is_compile_constant() or isinstance(expr, ExpressionWithOperator) and expr.must_be_constant:
|
|
result = self._process_constant_expression(expr, expr.sourceref)
|
|
else:
|
|
result = self._process_dynamic_expression(expr, expr.sourceref)
|
|
result.parent = expr.parent
|
|
return result
|
|
|
|
def _process_constant_expression(self, expr: Expression, sourceref: SourceRef) -> LiteralValue:
|
|
# the expression must result in a single (constant) value (int, float, whatever) wrapped as LiteralValue.
|
|
if isinstance(expr, LiteralValue):
|
|
return expr
|
|
if expr.is_compile_constant():
|
|
return LiteralValue(value=expr.const_value(), sourceref=sourceref) # type: ignore
|
|
elif isinstance(expr, SymbolName):
|
|
value = check_symbol_definition(expr.name, expr.my_scope(), expr.sourceref)
|
|
if isinstance(value, VarDef):
|
|
if value.vartype == VarType.MEMORY:
|
|
raise ExpressionEvaluationError("can't take a memory value, must be a constant", expr.sourceref)
|
|
value = value.value
|
|
if isinstance(value, ExpressionWithOperator):
|
|
raise ExpressionEvaluationError("circular reference?", expr.sourceref)
|
|
elif isinstance(value, LiteralValue):
|
|
return value
|
|
elif isinstance(value, (int, float, str, bool)):
|
|
raise TypeError("symbol value node should not be a python primitive value", expr)
|
|
else:
|
|
raise ExpressionEvaluationError("constant symbol required, not {}".format(value.__class__.__name__), expr.sourceref)
|
|
elif isinstance(expr, AddressOf):
|
|
assert isinstance(expr.name, str)
|
|
value = check_symbol_definition(expr.name, expr.my_scope(), expr.sourceref)
|
|
if isinstance(value, VarDef):
|
|
if value.vartype == VarType.MEMORY:
|
|
if isinstance(value.value, LiteralValue):
|
|
return value.value
|
|
else:
|
|
raise ExpressionEvaluationError("constant literal value required", value.sourceref)
|
|
if value.vartype == VarType.CONST:
|
|
raise ExpressionEvaluationError("can't take the address of a constant", expr.sourceref)
|
|
raise ExpressionEvaluationError("address-of this {} isn't a compile-time constant"
|
|
.format(value.__class__.__name__), expr.sourceref)
|
|
else:
|
|
raise ExpressionEvaluationError("constant address required, not {}"
|
|
.format(value.__class__.__name__), expr.sourceref)
|
|
elif isinstance(expr, SubCall):
|
|
if isinstance(expr.target, SymbolName): # 'function(1,2,3)'
|
|
funcname = expr.target.name
|
|
if funcname in math_functions or funcname in builtin_functions:
|
|
func_args = []
|
|
for a in (self._process_constant_expression(callarg.value, sourceref) for callarg in list(expr.arguments.nodes)):
|
|
if isinstance(a, LiteralValue):
|
|
func_args.append(a.value)
|
|
else:
|
|
func_args.append(a)
|
|
func = math_functions.get(funcname, builtin_functions.get(funcname))
|
|
try:
|
|
return LiteralValue(value=func(*func_args), sourceref=expr.arguments.sourceref) # type: ignore
|
|
except Exception as x:
|
|
raise ExpressionEvaluationError(str(x), expr.sourceref)
|
|
else:
|
|
raise ExpressionEvaluationError("can only use math- or builtin function", expr.sourceref)
|
|
elif isinstance(expr.target, Dereference): # '[...](1,2,3)'
|
|
raise ExpressionEvaluationError("dereferenced value call is not a constant value", expr.sourceref)
|
|
elif isinstance(expr.target, LiteralValue) and type(expr.target.value) is int: # '64738()'
|
|
raise ExpressionEvaluationError("immediate address call is not a constant value", expr.sourceref)
|
|
else:
|
|
raise NotImplementedError("weird call target", expr.target)
|
|
elif isinstance(expr, ExpressionWithOperator):
|
|
if expr.unary:
|
|
left_sourceref = expr.left.sourceref if isinstance(expr.left, AstNode) else sourceref
|
|
expr.left = self._process_constant_expression(expr.left, left_sourceref)
|
|
expr.left.parent = expr
|
|
if isinstance(expr.left, LiteralValue) and type(expr.left.value) in (int, float):
|
|
try:
|
|
if expr.operator == '-':
|
|
return LiteralValue(value=-expr.left.value, sourceref=expr.left.sourceref) # type: ignore
|
|
elif expr.operator == '~':
|
|
return LiteralValue(value=~expr.left.value, sourceref=expr.left.sourceref) # type: ignore
|
|
elif expr.operator in ("++", "--"):
|
|
raise ValueError("incr/decr should not be an expression")
|
|
raise ValueError("invalid unary operator", expr.operator)
|
|
except TypeError as x:
|
|
raise ParseError(str(x), expr.sourceref) from None
|
|
raise ValueError("invalid operand type for unary operator", expr.left, expr.operator)
|
|
else:
|
|
left_sourceref = expr.left.sourceref if isinstance(expr.left, AstNode) else sourceref
|
|
expr.left = self._process_constant_expression(expr.left, left_sourceref)
|
|
expr.left.parent = expr
|
|
right_sourceref = expr.right.sourceref if isinstance(expr.right, AstNode) else sourceref
|
|
expr.right = self._process_constant_expression(expr.right, right_sourceref)
|
|
expr.right.parent = expr
|
|
if isinstance(expr.left, LiteralValue):
|
|
if isinstance(expr.right, LiteralValue):
|
|
return expr.evaluate_primitive_constants(expr.right.sourceref)
|
|
else:
|
|
raise ExpressionEvaluationError("constant literal value required on right, not {}"
|
|
.format(expr.right.__class__.__name__), right_sourceref)
|
|
else:
|
|
raise ExpressionEvaluationError("constant literal value required on left, not {}"
|
|
.format(expr.left.__class__.__name__), left_sourceref)
|
|
else:
|
|
raise ExpressionEvaluationError("constant value required, not {}".format(expr.__class__.__name__), expr.sourceref)
|
|
|
|
def _process_dynamic_expression(self, expr: Expression, sourceref: SourceRef) -> Expression:
|
|
# constant-fold a dynamic expression
|
|
if isinstance(expr, LiteralValue):
|
|
return expr
|
|
if expr.is_compile_constant():
|
|
return LiteralValue(value=expr.const_value(), sourceref=sourceref) # type: ignore
|
|
elif isinstance(expr, SymbolName):
|
|
if expr.is_compile_constant():
|
|
try:
|
|
return self._process_constant_expression(expr, sourceref)
|
|
except ExpressionEvaluationError:
|
|
pass
|
|
return expr
|
|
elif isinstance(expr, AddressOf):
|
|
if expr.is_compile_constant():
|
|
try:
|
|
return self._process_constant_expression(expr, sourceref)
|
|
except ExpressionEvaluationError:
|
|
pass
|
|
return expr
|
|
elif isinstance(expr, SubCall):
|
|
try:
|
|
return self._process_constant_expression(expr, sourceref)
|
|
except ExpressionEvaluationError:
|
|
if isinstance(expr.target, SymbolName):
|
|
check_symbol_definition(expr.target.name, expr.my_scope(), expr.target.sourceref)
|
|
return expr
|
|
elif isinstance(expr, (Register, Dereference)):
|
|
return expr
|
|
elif isinstance(expr, ExpressionWithOperator):
|
|
if expr.unary:
|
|
left_sourceref = expr.left.sourceref if isinstance(expr.left, AstNode) else sourceref
|
|
expr.left = self._process_dynamic_expression(expr.left, left_sourceref)
|
|
expr.left.parent = expr
|
|
if expr.is_compile_constant():
|
|
try:
|
|
return self._process_constant_expression(expr, sourceref)
|
|
except ExpressionEvaluationError:
|
|
pass
|
|
return expr
|
|
else:
|
|
left_sourceref = expr.left.sourceref if isinstance(expr.left, AstNode) else sourceref
|
|
expr.left = self._process_dynamic_expression(expr.left, left_sourceref)
|
|
expr.left.parent = expr
|
|
right_sourceref = expr.right.sourceref if isinstance(expr.right, AstNode) else sourceref
|
|
expr.right = self._process_dynamic_expression(expr.right, right_sourceref)
|
|
expr.right.parent = expr
|
|
if expr.is_compile_constant():
|
|
try:
|
|
return self._process_constant_expression(expr, sourceref)
|
|
except ExpressionEvaluationError:
|
|
pass
|
|
return expr
|
|
else:
|
|
raise ParseError("expression required, not {}".format(expr.__class__.__name__), expr.sourceref)
|