mirror of
https://github.com/irmen/prog8.git
synced 2024-08-20 21:29:18 +00:00
1771 lines
88 KiB
Python
1771 lines
88 KiB
Python
"""
|
|
Programming Language for 6502/6510 microprocessors
|
|
This is the parser of the IL65 code, that generates a parse tree.
|
|
|
|
Written by Irmen de Jong (irmen@razorvine.net)
|
|
License: GNU GPL 3.0, see LICENSE
|
|
"""
|
|
|
|
import math
|
|
import re
|
|
import os
|
|
import sys
|
|
import shutil
|
|
import enum
|
|
from collections import defaultdict
|
|
from typing import Set, List, Tuple, Optional, Any, Dict, Union, Generator
|
|
from .astparse import ParseError, parse_expr_as_int, parse_expr_as_number, parse_expr_as_primitive,\
|
|
parse_expr_as_string, parse_arguments, parse_expr_as_comparison
|
|
from .symbols import SourceRef, SymbolTable, DataType, SymbolDefinition, SubroutineDef, LabelDef, \
|
|
zeropage, check_value_in_range, char_to_bytevalue, \
|
|
PrimitiveType, VariableDef, ConstantDef, SymbolError, STRING_DATATYPES, \
|
|
REGISTER_SYMBOLS, REGISTER_WORDS, REGISTER_BYTES, REGISTER_SBITS, RESERVED_NAMES
|
|
|
|
|
|
class ProgramFormat(enum.Enum):
|
|
PRG = "prg"
|
|
RAW = "raw"
|
|
|
|
|
|
class ParseResult:
|
|
def __init__(self, sourcefile: str) -> None:
|
|
self.format = ProgramFormat.RAW
|
|
self.with_sys = False
|
|
self.sourcefile = sourcefile
|
|
self.clobberzp = False
|
|
self.restorezp = False
|
|
self.start_address = 0
|
|
self.blocks = [] # type: List['ParseResult.Block']
|
|
self.subroutine_usage = defaultdict(set) # type: Dict[Tuple[str, str], Set[str]]
|
|
|
|
def all_blocks(self) -> Generator['ParseResult.Block', None, None]:
|
|
for block in self.blocks:
|
|
yield block
|
|
for sub in block.symbols.iter_subroutines(True):
|
|
yield sub.sub_block
|
|
|
|
class Block:
|
|
_unnamed_block_labels = {} # type: Dict[ParseResult.Block, str]
|
|
|
|
def __init__(self, name: str, sourceref: SourceRef, parent_scope: SymbolTable) -> None:
|
|
self.sourceref = sourceref.copy()
|
|
self.address = 0
|
|
self.name = name
|
|
self.statements = [] # type: List[ParseResult._AstNode]
|
|
self.symbols = SymbolTable(name, parent_scope, self)
|
|
|
|
@property
|
|
def ignore(self) -> bool:
|
|
return not self.name and not self.address
|
|
|
|
@property
|
|
def label_names(self) -> Set[str]:
|
|
return {symbol.name for symbol in self.symbols.iter_labels()}
|
|
|
|
@property
|
|
def label(self) -> str:
|
|
if self.name:
|
|
return self.name
|
|
if self in self._unnamed_block_labels:
|
|
return self._unnamed_block_labels[self]
|
|
label = "il65_block_{:d}".format(len(self._unnamed_block_labels))
|
|
self._unnamed_block_labels[self] = label
|
|
return label
|
|
|
|
def lookup(self, dottedname: str) -> Tuple[Optional['ParseResult.Block'], Optional[Union[SymbolDefinition, SymbolTable]]]:
|
|
# Searches a name in the current block or globally, if the name is scoped (=contains a '.').
|
|
# Does NOT utilize a symbol table from a preprocessing parse phase, only looks in the current.
|
|
try:
|
|
scope, result = self.symbols.lookup(dottedname)
|
|
return scope.owning_block, result
|
|
except (SymbolError, LookupError):
|
|
return None, None
|
|
|
|
def all_statements(self) -> Generator[Tuple['ParseResult.Block', Optional[SubroutineDef], 'ParseResult._AstNode'], None, None]:
|
|
for stmt in self.statements:
|
|
yield self, None, stmt
|
|
for sub in self.symbols.iter_subroutines(True):
|
|
for stmt in sub.sub_block.statements:
|
|
yield sub.sub_block, sub, stmt
|
|
|
|
class Value:
|
|
def __init__(self, datatype: DataType, name: str=None, constant: bool=False) -> None:
|
|
self.datatype = datatype
|
|
self.name = name
|
|
self.constant = constant
|
|
|
|
def assignable_from(self, other: 'ParseResult.Value') -> Tuple[bool, str]:
|
|
if self.constant:
|
|
return False, "cannot assign to a constant"
|
|
return False, "incompatible value for assignment"
|
|
|
|
class IndirectValue(Value):
|
|
# only constant integers, memmapped and register values are wrapped in this.
|
|
def __init__(self, value: 'ParseResult.Value', type_modifier: DataType) -> None:
|
|
assert type_modifier
|
|
super().__init__(type_modifier, value.name, False)
|
|
self.value = value
|
|
|
|
def __str__(self):
|
|
return "<IndirectValue {} itype={} name={}>".format(self.value, self.datatype, self.name)
|
|
|
|
def __hash__(self):
|
|
return hash((self.datatype, self.name, self.value))
|
|
|
|
def __eq__(self, other: Any) -> bool:
|
|
if not isinstance(other, ParseResult.IndirectValue):
|
|
return NotImplemented
|
|
elif self is other:
|
|
return True
|
|
else:
|
|
vvo = getattr(other.value, "value", getattr(other.value, "address", None))
|
|
vvs = getattr(self.value, "value", getattr(self.value, "address", None))
|
|
return (other.datatype, other.name, other.value.name, other.value.datatype, other.value.constant, vvo) ==\
|
|
(self.datatype, self.name, self.value.name, self.value.datatype, self.value.constant, vvs)
|
|
|
|
def assignable_from(self, other: 'ParseResult.Value') -> Tuple[bool, str]:
|
|
if self.constant:
|
|
return False, "cannot assign to a constant"
|
|
if self.datatype == DataType.BYTE:
|
|
if other.datatype == DataType.BYTE:
|
|
return True, ""
|
|
if self.datatype == DataType.WORD:
|
|
if other.datatype in {DataType.BYTE, DataType.WORD} | STRING_DATATYPES:
|
|
return True, ""
|
|
if self.datatype == DataType.FLOAT:
|
|
if other.datatype in {DataType.BYTE, DataType.WORD, DataType.FLOAT}:
|
|
return True, ""
|
|
if isinstance(other, (ParseResult.IntegerValue, ParseResult.FloatValue, ParseResult.StringValue)):
|
|
rangefault = check_value_in_range(self.datatype, "", 1, other.value)
|
|
if rangefault:
|
|
return False, rangefault
|
|
return True, ""
|
|
return False, "incompatible value for indirect assignment (need byte, word, float or string)"
|
|
|
|
class IntegerValue(Value):
|
|
def __init__(self, value: Optional[int], *, datatype: DataType=None, name: str=None) -> None:
|
|
if type(value) is int:
|
|
if datatype is None:
|
|
if 0 <= value < 0x100:
|
|
datatype = DataType.BYTE
|
|
elif value < 0x10000:
|
|
datatype = DataType.WORD
|
|
else:
|
|
raise OverflowError("value too big: ${:x}".format(value))
|
|
else:
|
|
faultreason = check_value_in_range(datatype, "", 1, value)
|
|
if faultreason:
|
|
raise OverflowError(faultreason)
|
|
super().__init__(datatype, name, True)
|
|
self.value = value
|
|
elif value is None:
|
|
if not name:
|
|
raise ValueError("when integer value is not given, the name symbol should be speicified")
|
|
super().__init__(datatype, name, True)
|
|
self.value = None
|
|
else:
|
|
raise TypeError("invalid data type")
|
|
|
|
def __hash__(self):
|
|
return hash((self.datatype, self.value, self.name))
|
|
|
|
def __eq__(self, other: Any) -> bool:
|
|
if not isinstance(other, ParseResult.IntegerValue):
|
|
return NotImplemented
|
|
elif self is other:
|
|
return True
|
|
else:
|
|
return (other.datatype, other.value, other.name) == (self.datatype, self.value, self.name)
|
|
|
|
def __str__(self):
|
|
return "<IntegerValue {} name={}>".format(self.value, self.name)
|
|
|
|
class FloatValue(Value):
|
|
def __init__(self, value: float, name: str=None) -> None:
|
|
if type(value) is float:
|
|
super().__init__(DataType.FLOAT, name, True)
|
|
self.value = value
|
|
else:
|
|
raise TypeError("invalid data type")
|
|
|
|
def __hash__(self):
|
|
return hash((self.datatype, self.value, self.name))
|
|
|
|
def __eq__(self, other: Any) -> bool:
|
|
if not isinstance(other, ParseResult.FloatValue):
|
|
return NotImplemented
|
|
elif self is other:
|
|
return True
|
|
else:
|
|
return (other.datatype, other.value, other.name) == (self.datatype, self.value, self.name)
|
|
|
|
def __str__(self):
|
|
return "<FloatValue {} name={}>".format(self.value, self.name)
|
|
|
|
class StringValue(Value):
|
|
def __init__(self, value: str, name: str=None, constant: bool=False) -> None:
|
|
super().__init__(DataType.STRING, name, constant)
|
|
self.value = value
|
|
|
|
def __hash__(self):
|
|
return hash((self.datatype, self.value, self.name, self.constant))
|
|
|
|
def __eq__(self, other: Any) -> bool:
|
|
if not isinstance(other, ParseResult.StringValue):
|
|
return NotImplemented
|
|
elif self is other:
|
|
return True
|
|
else:
|
|
return (other.datatype, other.value, other.name, other.constant) == (self.datatype, self.value, self.name, self.constant)
|
|
|
|
def __str__(self):
|
|
return "<StringValue {!r:s} name={} constant={}>".format(self.value, self.name, self.constant)
|
|
|
|
class RegisterValue(Value):
|
|
def __init__(self, register: str, datatype: DataType, name: str=None) -> None:
|
|
assert datatype in (DataType.BYTE, DataType.WORD)
|
|
assert register in REGISTER_SYMBOLS
|
|
super().__init__(datatype, name, False)
|
|
self.register = register
|
|
|
|
def __hash__(self):
|
|
return hash((self.datatype, self.register, self.name))
|
|
|
|
def __eq__(self, other: Any) -> bool:
|
|
if not isinstance(other, ParseResult.RegisterValue):
|
|
return NotImplemented
|
|
elif self is other:
|
|
return True
|
|
else:
|
|
return (other.datatype, other.register, other.name) == (self.datatype, self.register, self.name)
|
|
|
|
def __str__(self):
|
|
return "<RegisterValue {:s} type {:s} name={}>".format(self.register, self.datatype, self.name)
|
|
|
|
def assignable_from(self, other: 'ParseResult.Value') -> Tuple[bool, str]:
|
|
if isinstance(other, ParseResult.IndirectValue):
|
|
if self.datatype == DataType.BYTE:
|
|
if other.datatype == DataType.BYTE:
|
|
return True, ""
|
|
return False, "(unsigned) byte required"
|
|
if self.datatype == DataType.WORD:
|
|
if other.datatype in (DataType.BYTE, DataType.WORD):
|
|
return True, ""
|
|
return False, "(unsigned) byte required"
|
|
return False, "incompatible indirect value for register assignment"
|
|
if self.register in ("SC", "SI"):
|
|
if isinstance(other, ParseResult.IntegerValue) and other.value in (0, 1):
|
|
return True, ""
|
|
return False, "can only assign an integer constant value of 0 or 1 to SC and SI"
|
|
if self.constant:
|
|
return False, "cannot assign to a constant"
|
|
if isinstance(other, ParseResult.RegisterValue):
|
|
if other.register in {"SI", "SC", "SZ"}:
|
|
return False, "cannot explicitly assign from a status bit register alias"
|
|
if len(self.register) < len(other.register):
|
|
return False, "register size mismatch"
|
|
if isinstance(other, ParseResult.StringValue) and self.register in REGISTER_BYTES | REGISTER_SBITS:
|
|
return False, "string address requires 16 bits combined register"
|
|
if isinstance(other, ParseResult.IntegerValue):
|
|
if other.value is not None:
|
|
range_error = check_value_in_range(self.datatype, self.register, 1, other.value)
|
|
if range_error:
|
|
return False, range_error
|
|
return True, ""
|
|
if self.datatype == DataType.WORD:
|
|
return True, ""
|
|
return False, "cannot assign address to single register"
|
|
if isinstance(other, ParseResult.FloatValue):
|
|
range_error = check_value_in_range(self.datatype, self.register, 1, other.value)
|
|
if range_error:
|
|
return False, range_error
|
|
return True, ""
|
|
if self.datatype == DataType.BYTE:
|
|
if other.datatype != DataType.BYTE:
|
|
return False, "(unsigned) byte required"
|
|
return True, ""
|
|
if self.datatype == DataType.WORD:
|
|
if other.datatype in (DataType.BYTE, DataType.WORD) or other.datatype in STRING_DATATYPES:
|
|
return True, ""
|
|
return False, "(unsigned) byte, word or string required"
|
|
return False, "incompatible value for register assignment"
|
|
|
|
class MemMappedValue(Value):
|
|
def __init__(self, address: Optional[int], datatype: DataType, length: int, name: str=None, constant: bool=False) -> None:
|
|
super().__init__(datatype, name, constant)
|
|
self.address = address
|
|
self.length = length
|
|
assert address is None or type(address) is int
|
|
|
|
def __hash__(self):
|
|
return hash((self.datatype, self.address, self.length, self.name, self.constant))
|
|
|
|
def __eq__(self, other: Any) -> bool:
|
|
if not isinstance(other, ParseResult.MemMappedValue):
|
|
return NotImplemented
|
|
elif self is other:
|
|
return True
|
|
else:
|
|
return (other.datatype, other.address, other.length, other.name, other.constant) ==\
|
|
(self.datatype, self.address, self.length, self.name, self.constant)
|
|
|
|
def __str__(self):
|
|
addr = "" if self.address is None else "${:04x}".format(self.address)
|
|
return "<MemMappedValue {:s} type={:s} #={:d} name={} constant={}>"\
|
|
.format(addr, self.datatype, self.length, self.name, self.constant)
|
|
|
|
def assignable_from(self, other: 'ParseResult.Value') -> Tuple[bool, str]:
|
|
if self.constant:
|
|
return False, "cannot assign to a constant"
|
|
if isinstance(other, ParseResult.IndirectValue):
|
|
return False, "can not yet assign memory mapped value from indirect value" # @todo indirect v assign
|
|
if self.datatype == DataType.BYTE:
|
|
if isinstance(other, (ParseResult.IntegerValue, ParseResult.RegisterValue, ParseResult.MemMappedValue)):
|
|
if other.datatype == DataType.BYTE:
|
|
return True, ""
|
|
return False, "(unsigned) byte required"
|
|
elif isinstance(other, ParseResult.FloatValue):
|
|
range_error = check_value_in_range(self.datatype, "", 1, other.value)
|
|
if range_error:
|
|
return False, range_error
|
|
return True, ""
|
|
else:
|
|
return False, "(unsigned) byte required"
|
|
elif self.datatype in (DataType.WORD, DataType.FLOAT):
|
|
if isinstance(other, (ParseResult.IntegerValue, ParseResult.FloatValue)):
|
|
range_error = check_value_in_range(self.datatype, "", 1, other.value)
|
|
if range_error:
|
|
return False, range_error
|
|
return True, ""
|
|
elif isinstance(other, (ParseResult.RegisterValue, ParseResult.MemMappedValue)):
|
|
if other.datatype in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
|
|
return True, ""
|
|
else:
|
|
return False, "byte or word or float required"
|
|
elif isinstance(other, ParseResult.StringValue):
|
|
if self.datatype == DataType.WORD:
|
|
return True, ""
|
|
return False, "string address requires 16 bits (a word)"
|
|
if self.datatype == DataType.BYTE:
|
|
return False, "(unsigned) byte required"
|
|
if self.datatype == DataType.WORD:
|
|
return False, "(unsigned) word required"
|
|
return False, "incompatible value for assignment"
|
|
|
|
class _AstNode: # @todo merge Value with this?
|
|
def __init__(self, lineno: int) -> None:
|
|
self.lineno = lineno
|
|
|
|
class Comment(_AstNode):
|
|
def __init__(self, text: str, lineno: int) -> None:
|
|
super().__init__(lineno)
|
|
self.text = text
|
|
|
|
class Label(_AstNode):
|
|
def __init__(self, name: str, lineno: int) -> None:
|
|
super().__init__(lineno)
|
|
self.name = name
|
|
|
|
class AssignmentStmt(_AstNode):
|
|
def __init__(self, leftvalues: List['ParseResult.Value'], right: 'ParseResult.Value', lineno: int) -> None:
|
|
super().__init__(lineno)
|
|
self.leftvalues = leftvalues
|
|
self.right = right
|
|
|
|
def __str__(self):
|
|
return "<Assign {:s} to {:s}>".format(str(self.right), ",".join(str(lv) for lv in self.leftvalues))
|
|
|
|
_immediate_string_vars = {} # type: Dict[str, Tuple[str, str]]
|
|
|
|
def desugar_immediate_string(self, parser: 'Parser') -> None:
|
|
if self.right.name or not isinstance(self.right, ParseResult.StringValue):
|
|
return
|
|
if self.right.value in self._immediate_string_vars:
|
|
blockname, stringvar_name = self._immediate_string_vars[self.right.value]
|
|
if blockname:
|
|
self.right.name = blockname + '.' + stringvar_name
|
|
else:
|
|
self.right.name = stringvar_name
|
|
else:
|
|
cur_block = parser.cur_block
|
|
stringvar_name = "il65_str_{:d}".format(id(self))
|
|
value = self.right.value
|
|
cur_block.symbols.define_variable(stringvar_name, cur_block.sourceref, DataType.STRING, value=value)
|
|
self.right.name = stringvar_name
|
|
self._immediate_string_vars[self.right.value] = (cur_block.name, stringvar_name)
|
|
|
|
def remove_identity_lvalues(self, filename: str, lineno: int) -> None:
|
|
for lv in self.leftvalues:
|
|
if lv == self.right:
|
|
print("{:s}:{:d}: removed identity assignment".format(filename, lineno))
|
|
remaining_leftvalues = [lv for lv in self.leftvalues if lv != self.right]
|
|
self.leftvalues = remaining_leftvalues
|
|
|
|
def is_identity(self) -> bool:
|
|
return all(lv == self.right for lv in self.leftvalues)
|
|
|
|
class AugmentedAssignmentStmt(AssignmentStmt):
|
|
SUPPORTED_OPERATORS = {"+=", "-=", "&=", "|=", "^=", ">>=", "<<="}
|
|
# full set: {"+=", "-=", "*=", "/=", "%=", "//=", "**=", "&=", "|=", "^=", ">>=", "<<="}
|
|
|
|
def __init__(self, left: 'ParseResult.Value', operator: str, right: 'ParseResult.Value', lineno: int) -> None:
|
|
assert operator in self.SUPPORTED_OPERATORS
|
|
super().__init__([left], right, lineno)
|
|
self.operator = operator
|
|
|
|
def __str__(self):
|
|
return "<AugAssign {:s} {:s} {:s}>".format(str(self.leftvalues[0]), self.operator, str(self.right))
|
|
|
|
class ReturnStmt(_AstNode):
|
|
def __init__(self, lineno: int, a: Optional['ParseResult.Value']=None,
|
|
x: Optional['ParseResult.Value']=None,
|
|
y: Optional['ParseResult.Value']=None) -> None:
|
|
super().__init__(lineno)
|
|
self.a = a
|
|
self.x = x
|
|
self.y = y
|
|
|
|
class InplaceIncrStmt(_AstNode):
|
|
def __init__(self, what: 'ParseResult.Value', howmuch: Union[int, float], lineno: int) -> None:
|
|
super().__init__(lineno)
|
|
assert howmuch > 0
|
|
self.what = what
|
|
self.howmuch = howmuch
|
|
|
|
class InplaceDecrStmt(_AstNode):
|
|
def __init__(self, what: 'ParseResult.Value', howmuch: Union[int, float], lineno: int) -> None:
|
|
super().__init__(lineno)
|
|
assert howmuch > 0
|
|
self.what = what
|
|
self.howmuch = howmuch
|
|
|
|
class CallStmt(_AstNode):
|
|
def __init__(self, lineno: int, target: Optional['ParseResult.Value']=None, *,
|
|
address: Optional[int]=None, arguments: List[Tuple[str, Any]]=None,
|
|
outputs: List[Tuple[str, 'ParseResult.Value']]=None, is_goto: bool=False,
|
|
preserve_regs: bool=True, condition: 'ParseResult.IfCondition'=None) -> None:
|
|
if not is_goto:
|
|
assert condition is None
|
|
super().__init__(lineno)
|
|
self.target = target
|
|
self.address = address
|
|
self.arguments = arguments
|
|
self.outputvars = outputs
|
|
self.is_goto = is_goto
|
|
self.condition = condition
|
|
self.preserve_regs = preserve_regs
|
|
self.desugared_call_arguments = [] # type: List[ParseResult.AssignmentStmt]
|
|
self.desugared_output_assignments = [] # type: List[ParseResult.AssignmentStmt]
|
|
|
|
def desugar_call_arguments_and_outputs(self, parser: 'Parser') -> None:
|
|
self.desugared_call_arguments.clear()
|
|
self.desugared_output_assignments.clear()
|
|
for name, value in self.arguments or []:
|
|
assert name is not None, "all call arguments should have a name or be matched on a named parameter"
|
|
assignment = parser.parse_assignment(name, value)
|
|
if not assignment.is_identity():
|
|
assignment.lineno = self.lineno
|
|
self.desugared_call_arguments.append(assignment)
|
|
for register, value in self.outputvars or []:
|
|
rvalue = parser.parse_expression(register)
|
|
assignment = ParseResult.AssignmentStmt([value], rvalue, self.lineno)
|
|
# note: we need the identity assignment here or the output register handling generates buggy code
|
|
assignment.lineno = self.lineno
|
|
self.desugared_output_assignments.append(assignment)
|
|
|
|
class InlineAsm(_AstNode):
|
|
def __init__(self, asmlines: List[str], lineno: int) -> None:
|
|
super().__init__(lineno)
|
|
self.asmlines = asmlines
|
|
|
|
class IfCondition(_AstNode):
|
|
SWAPPED_OPERATOR = {"==": "==",
|
|
"!=": "!=",
|
|
"<=": ">=",
|
|
">=": "<=",
|
|
"<": ">",
|
|
">": "<"}
|
|
IF_STATUSES = {"cc", "cs", "vc", "vs", "eq", "ne", "true", "not", "zero", "lt", "gt", "le", "ge"}
|
|
|
|
def __init__(self, ifstatus: str, leftvalue: Optional['ParseResult.Value'],
|
|
operator: str, rightvalue: Optional['ParseResult.Value'], lineno: int) -> None:
|
|
assert ifstatus in self.IF_STATUSES
|
|
assert operator in (None, "") or operator in self.SWAPPED_OPERATOR
|
|
if operator:
|
|
assert ifstatus in ("true", "not", "zero")
|
|
super().__init__(lineno)
|
|
self.ifstatus = ifstatus
|
|
self.lvalue = leftvalue
|
|
self.comparison_op = operator
|
|
self.rvalue = rightvalue
|
|
|
|
def __str__(self):
|
|
return "<IfCondition if_{:s} {} {:s} {}>".format(self.ifstatus, self.lvalue, self.comparison_op, self.rvalue)
|
|
|
|
def make_if_true(self) -> bool:
|
|
# makes a condition of the form if_not a < b into: if a > b (gets rid of the not)
|
|
# returns whether the change was made or not
|
|
if self.ifstatus == "not" and self.comparison_op:
|
|
self.ifstatus = "true"
|
|
self.comparison_op = self.SWAPPED_OPERATOR[self.comparison_op]
|
|
return True
|
|
return False
|
|
|
|
def swap(self) -> Tuple['ParseResult.Value', str, 'ParseResult.Value']:
|
|
self.lvalue, self.comparison_op, self.rvalue = self.rvalue, self.SWAPPED_OPERATOR[self.comparison_op], self.lvalue
|
|
return self.lvalue, self.comparison_op, self.rvalue
|
|
|
|
class BreakpointStmt(_AstNode):
|
|
def __init__(self, lineno: int) -> None:
|
|
super().__init__(lineno)
|
|
|
|
def add_block(self, block: 'ParseResult.Block', position: Optional[int]=None) -> None:
|
|
if position is not None:
|
|
self.blocks.insert(position, block)
|
|
else:
|
|
self.blocks.append(block)
|
|
|
|
def merge(self, parsed: 'ParseResult') -> None:
|
|
existing_blocknames = set(block.name for block in self.blocks)
|
|
other_blocknames = set(block.name for block in parsed.blocks)
|
|
overlap = existing_blocknames & other_blocknames
|
|
if overlap != {"<header>"}:
|
|
raise SymbolError("double block names: {}".format(overlap))
|
|
for block in parsed.blocks:
|
|
if block.name != "<header>":
|
|
self.blocks.append(block)
|
|
|
|
def find_block(self, name: str) -> Block:
|
|
for block in self.blocks:
|
|
if block.name == name:
|
|
return block
|
|
raise KeyError("block not found: " + name)
|
|
|
|
def sub_used_by(self, sub: SubroutineDef, sourceref: SourceRef) -> None:
|
|
self.subroutine_usage[(sub.blockname, sub.name)].add(str(sourceref))
|
|
|
|
|
|
class Parser:
|
|
def __init__(self, filename: str, outputdir: str, sourcelines: List[Tuple[int, str]] = None, parsing_import: bool = False,
|
|
ppsymbols: SymbolTable = None, sub_usage: Dict=None) -> None:
|
|
self.result = ParseResult(filename)
|
|
if sub_usage is not None:
|
|
# re-use the (global) subroutine usage tracking
|
|
self.result.subroutine_usage = sub_usage
|
|
self.sourceref = SourceRef(filename, -1, 0)
|
|
if sourcelines:
|
|
self.lines = sourcelines
|
|
else:
|
|
self.lines = self.load_source(filename)
|
|
self.outputdir = outputdir
|
|
self.parsing_import = parsing_import # are we parsing a import file?
|
|
self._cur_lineidx = -1 # used to efficiently go to next/previous line in source
|
|
self.cur_block = None # type: ParseResult.Block
|
|
self.root_scope = SymbolTable("<root>", None, None)
|
|
self.ppsymbols = ppsymbols # symboltable from preprocess phase
|
|
self.print_block_parsing = True
|
|
|
|
def load_source(self, filename: str) -> List[Tuple[int, str]]:
|
|
with open(filename, "rU") as source:
|
|
sourcelines = source.readlines()
|
|
# store all lines that aren't empty
|
|
# comments are kept (end-of-line comments are stripped though)
|
|
lines = []
|
|
for num, line in enumerate(sourcelines, start=1):
|
|
line = line.rstrip()
|
|
if line.lstrip().startswith(';'):
|
|
lines.append((num, line.lstrip()))
|
|
else:
|
|
line2, sep, comment = line.rpartition(';')
|
|
if sep:
|
|
line = line2.rstrip()
|
|
if line:
|
|
lines.append((num, line))
|
|
return lines
|
|
|
|
def parse(self) -> Optional[ParseResult]:
|
|
# start the parsing
|
|
try:
|
|
return self.parse_file()
|
|
except ParseError as x:
|
|
if sys.stderr.isatty():
|
|
print("\x1b[1m", file=sys.stderr)
|
|
print("", file=sys.stderr)
|
|
if x.sourcetext:
|
|
print("\tsource text: '{:s}'".format(x.sourcetext), file=sys.stderr)
|
|
if x.sourceref.column:
|
|
print("\t" + ' '*x.sourceref.column + ' ^', file=sys.stderr)
|
|
if self.parsing_import:
|
|
print("Error (in imported file):", str(x), file=sys.stderr)
|
|
else:
|
|
print("Error:", str(x), file=sys.stderr)
|
|
if sys.stderr.isatty():
|
|
print("\x1b[0m", file=sys.stderr)
|
|
raise # XXX temporary solution to get stack trace info in the event of parse errors
|
|
except Exception as x:
|
|
if sys.stderr.isatty():
|
|
print("\x1b[1m", file=sys.stderr)
|
|
print("\nERROR: internal parser error: ", x, file=sys.stderr)
|
|
if self.cur_block:
|
|
print(" file:", self.sourceref.file, "block:", self.cur_block.name, "line:", self.sourceref.line, file=sys.stderr)
|
|
else:
|
|
print(" file:", self.sourceref.file, file=sys.stderr)
|
|
if sys.stderr.isatty():
|
|
print("\x1b[0m", file=sys.stderr)
|
|
raise # XXX temporary solution to get stack trace info in the event of parse errors
|
|
|
|
def parse_file(self) -> ParseResult:
|
|
print("\nparsing", self.sourceref.file)
|
|
self._parse_1()
|
|
self._parse_2()
|
|
return self.result
|
|
|
|
def print_warning(self, text: str, sourceref: SourceRef=None) -> None:
|
|
self.print_bold("warning: {}: {:s}".format(sourceref or self.sourceref, text))
|
|
|
|
def print_bold(self, text: str) -> None:
|
|
if sys.stdout.isatty():
|
|
print("\x1b[1m" + text + "\x1b[0m")
|
|
else:
|
|
print(text)
|
|
|
|
def _parse_comments(self) -> None:
|
|
while True:
|
|
line = self.next_line().lstrip()
|
|
if line.startswith(';'):
|
|
self.cur_block.statements.append(ParseResult.Comment(line, self.sourceref.line))
|
|
continue
|
|
self.prev_line()
|
|
break
|
|
|
|
def _parse_1(self) -> None:
|
|
self.cur_block = ParseResult.Block("<header>", self.sourceref, self.root_scope)
|
|
self.result.add_block(self.cur_block)
|
|
self.parse_header()
|
|
zeropage.configure(self.result.clobberzp)
|
|
while True:
|
|
self._parse_comments()
|
|
next_line = self.peek_next_line().lstrip()
|
|
if next_line.startswith("~"):
|
|
block = self.parse_block()
|
|
if block:
|
|
self.result.add_block(block)
|
|
elif next_line.startswith("import"):
|
|
self.parse_import()
|
|
else:
|
|
break
|
|
line = self.next_line()
|
|
if line:
|
|
raise self.PError("invalid statement or characters, block expected")
|
|
if not self.parsing_import:
|
|
# check if we have a proper main block to contain the program's entry point
|
|
main_found = False
|
|
for block in self.result.blocks:
|
|
if block.name == "main":
|
|
main_found = True
|
|
if "start" not in block.label_names:
|
|
self.sourceref.line = block.sourceref.line
|
|
self.sourceref.column = 0
|
|
raise self.PError("block 'main' should contain the program entry point 'start'")
|
|
self._check_return_statement(block, "'main' block")
|
|
for sub in block.symbols.iter_subroutines(True):
|
|
self._check_return_statement(sub.sub_block, "subroutine '{:s}'".format(sub.name))
|
|
if not main_found:
|
|
raise self.PError("a block 'main' should be defined and contain the program's entry point label 'start'")
|
|
|
|
def _check_return_statement(self, block: ParseResult.Block, message: str) -> None:
|
|
# find last statement that isn't a comment
|
|
for stmt in reversed(block.statements):
|
|
if isinstance(stmt, ParseResult.Comment):
|
|
continue
|
|
if isinstance(stmt, ParseResult.ReturnStmt) or isinstance(stmt, ParseResult.CallStmt) and stmt.is_goto:
|
|
return
|
|
if isinstance(stmt, ParseResult.InlineAsm):
|
|
# check that the last asm line is a jmp or a rts
|
|
for asmline in reversed(stmt.asmlines):
|
|
if asmline.lstrip().startswith(';'):
|
|
continue
|
|
if " rts" in asmline or "\trts" in asmline or " jmp" in asmline or "\tjmp" in asmline:
|
|
return
|
|
if asmline.strip():
|
|
if asmline.split()[0].isidentifier():
|
|
continue
|
|
break
|
|
break
|
|
self.print_warning("{:s} doesn't end with a return statement".format(message), block.sourceref)
|
|
|
|
def _parse_2(self) -> None:
|
|
# parsing pass 2 (not done during preprocessing!)
|
|
self.cur_block = None
|
|
self.sourceref.line = -1
|
|
self.sourceref.column = 0
|
|
|
|
def desugar_immediate_strings(stmt: ParseResult._AstNode) -> None:
|
|
if isinstance(stmt, ParseResult.CallStmt):
|
|
for s in stmt.desugared_call_arguments:
|
|
self.sourceref.line = s.lineno
|
|
self.sourceref.column = 0
|
|
s.desugar_immediate_string(self)
|
|
for s in stmt.desugared_output_assignments:
|
|
self.sourceref.line = s.lineno
|
|
self.sourceref.column = 0
|
|
s.desugar_immediate_string(self)
|
|
if isinstance(stmt, ParseResult.AssignmentStmt):
|
|
self.sourceref.line = stmt.lineno
|
|
self.sourceref.column = 0
|
|
stmt.desugar_immediate_string(self)
|
|
|
|
for block in self.result.blocks:
|
|
self.cur_block = block
|
|
self.sourceref = block.sourceref.copy()
|
|
self.sourceref.column = 0
|
|
for block, sub, stmt in block.all_statements():
|
|
if isinstance(stmt, ParseResult.CallStmt):
|
|
self.sourceref.line = stmt.lineno
|
|
stmt.desugar_call_arguments_and_outputs(self)
|
|
desugar_immediate_strings(stmt)
|
|
|
|
def next_line(self) -> str:
|
|
self._cur_lineidx += 1
|
|
try:
|
|
self.sourceref.line, line = self.lines[self._cur_lineidx]
|
|
self.sourceref.column = 0
|
|
return line
|
|
except IndexError:
|
|
return ""
|
|
|
|
def prev_line(self) -> str:
|
|
self._cur_lineidx -= 1
|
|
self.sourceref.line, line = self.lines[self._cur_lineidx]
|
|
return line
|
|
|
|
def peek_next_line(self) -> str:
|
|
if (self._cur_lineidx + 1) < len(self.lines):
|
|
return self.lines[self._cur_lineidx + 1][1]
|
|
return ""
|
|
|
|
def PError(self, message: str, lineno: int=0, column: int=0) -> ParseError:
|
|
sourceline = ""
|
|
lineno = lineno or self.sourceref.line
|
|
column = column or self.sourceref.column
|
|
for num, text in self.lines:
|
|
if num == lineno:
|
|
sourceline = text.strip()
|
|
break
|
|
return ParseError(message, sourceline, SourceRef(self.sourceref.file, lineno, column))
|
|
|
|
def get_datatype(self, typestr: str) -> Tuple[DataType, int, Optional[Tuple[int, int]]]:
|
|
if typestr == ".byte":
|
|
return DataType.BYTE, 1, None
|
|
elif typestr == ".word":
|
|
return DataType.WORD, 1, None
|
|
elif typestr == ".float":
|
|
return DataType.FLOAT, 1, None
|
|
elif typestr.endswith("text"):
|
|
if typestr == ".text":
|
|
return DataType.STRING, 0, None
|
|
elif typestr == ".ptext":
|
|
return DataType.STRING_P, 0, None
|
|
elif typestr == ".stext":
|
|
return DataType.STRING_S, 0, None
|
|
elif typestr == ".pstext":
|
|
return DataType.STRING_PS, 0, None
|
|
elif typestr.startswith(".array(") and typestr.endswith(")"):
|
|
return DataType.BYTEARRAY, self._size_from_arraydecl(typestr), None
|
|
elif typestr.startswith(".wordarray(") and typestr.endswith(")"):
|
|
return DataType.WORDARRAY, self._size_from_arraydecl(typestr), None
|
|
elif typestr.startswith(".matrix(") and typestr.endswith(")"):
|
|
dimensions = self._size_from_matrixdecl(typestr)
|
|
return DataType.MATRIX, dimensions[0] * dimensions[1], dimensions
|
|
raise self.PError("invalid data type: " + typestr)
|
|
|
|
def parse_header(self) -> None:
|
|
self.result.with_sys = False
|
|
self.result.format = ProgramFormat.RAW
|
|
output_specified = False
|
|
zp_specified = False
|
|
while True:
|
|
self._parse_comments()
|
|
line = self.next_line()
|
|
if line.startswith(("output ", "output\t")):
|
|
if output_specified:
|
|
raise self.PError("can only specify output options once")
|
|
output_specified = True
|
|
_, _, optionstr = line.partition(" ")
|
|
options = set(optionstr.replace(' ', '').split(','))
|
|
self.result.with_sys = False
|
|
self.result.format = ProgramFormat.RAW
|
|
if "raw" in options:
|
|
options.remove("raw")
|
|
if "prg" in options:
|
|
options.remove("prg")
|
|
self.result.format = ProgramFormat.PRG
|
|
if "basic" in options:
|
|
options.remove("basic")
|
|
if self.result.format == ProgramFormat.PRG:
|
|
self.result.with_sys = True
|
|
else:
|
|
raise self.PError("can only use basic output option with prg, not raw")
|
|
if options:
|
|
raise self.PError("invalid output option(s): " + str(options))
|
|
elif line.startswith(("zp ", "zp\t")):
|
|
if zp_specified:
|
|
raise self.PError("can only specify ZP options once")
|
|
zp_specified = True
|
|
_, _, optionstr = line.partition(" ")
|
|
options = set(optionstr.replace(' ', '').split(','))
|
|
self.result.clobberzp = False
|
|
self.result.restorezp = False
|
|
if "clobber" in options:
|
|
options.remove("clobber")
|
|
self.result.clobberzp = True
|
|
if "restore" in options:
|
|
options.remove("restore")
|
|
if self.result.clobberzp:
|
|
self.result.restorezp = True
|
|
else:
|
|
raise self.PError("can only use restore zp option if clobber zp is used as well")
|
|
if options:
|
|
raise self.PError("invalid zp option(s): " + str(options))
|
|
elif line.startswith("address"):
|
|
if self.result.start_address:
|
|
raise self.PError("multiple occurrences of 'address'")
|
|
_, _, arg = line.partition(" ")
|
|
try:
|
|
self.result.start_address = parse_expr_as_int(arg, None, None, self.sourceref)
|
|
except ParseError:
|
|
raise self.PError("invalid address")
|
|
if self.result.format == ProgramFormat.PRG and self.result.with_sys and self.result.start_address != 0x0801:
|
|
raise self.PError("cannot use non-default 'address' when output format includes basic SYS program")
|
|
else:
|
|
# header parsing finished!
|
|
self.prev_line()
|
|
if not self.result.start_address:
|
|
# set the proper default start address
|
|
if self.result.format == ProgramFormat.PRG:
|
|
self.result.start_address = 0x0801 # normal C-64 basic program start address
|
|
elif self.result.format == ProgramFormat.RAW:
|
|
self.result.start_address = 0xc000 # default start for raw assembly
|
|
if self.result.format == ProgramFormat.PRG and self.result.with_sys and self.result.start_address != 0x0801:
|
|
raise self.PError("cannot use non-default 'address' when output format includes basic SYS program")
|
|
return
|
|
|
|
def parse_import(self) -> None:
|
|
line = self.next_line()
|
|
line = line.lstrip()
|
|
if not line.startswith("import"):
|
|
raise self.PError("expected import")
|
|
try:
|
|
_, arg = line.split(maxsplit=1)
|
|
except ValueError:
|
|
raise self.PError("invalid import statement")
|
|
if not arg.startswith('"') or not arg.endswith('"'):
|
|
raise self.PError("filename must be between quotes")
|
|
filename = arg[1:-1]
|
|
if not filename:
|
|
raise self.PError("invalid filename")
|
|
filename_at_source_location = os.path.join(os.path.split(self.sourceref.file)[0], filename)
|
|
filename_at_libs_location = os.path.join(os.getcwd(), "lib", filename)
|
|
candidates = [filename,
|
|
filename_at_source_location,
|
|
filename_at_libs_location,
|
|
filename+".ill",
|
|
filename_at_source_location+".ill",
|
|
filename_at_libs_location+".ill"]
|
|
for filename in candidates:
|
|
if os.path.isfile(filename):
|
|
print("importing", filename)
|
|
parser = self.create_import_parser(filename, self.outputdir)
|
|
result = parser.parse()
|
|
print("\ncontinuing", self.sourceref.file)
|
|
if result:
|
|
# merge the symbol table of the imported file into our own
|
|
try:
|
|
self.root_scope.merge_roots(parser.root_scope)
|
|
self.result.merge(result)
|
|
except SymbolError as x:
|
|
raise self.PError(str(x))
|
|
return
|
|
else:
|
|
raise self.PError("Error while parsing imported file")
|
|
raise self.PError("imported file not found")
|
|
|
|
def create_import_parser(self, filename: str, outputdir: str) -> 'Parser':
|
|
return Parser(filename, outputdir, parsing_import=True, ppsymbols=self.ppsymbols, sub_usage=self.result.subroutine_usage)
|
|
|
|
def parse_block(self) -> Optional[ParseResult.Block]:
|
|
# first line contains block header "~ [name] [addr]" followed by a '{'
|
|
self._parse_comments()
|
|
line = self.next_line()
|
|
line = line.lstrip()
|
|
if not line.startswith("~"):
|
|
raise self.PError("expected '~' (block)")
|
|
block_args = line[1:].split()
|
|
arg = ""
|
|
self.cur_block = ParseResult.Block("", self.sourceref.copy(), self.root_scope)
|
|
is_zp_block = False
|
|
while block_args:
|
|
arg = block_args.pop(0)
|
|
if arg.isidentifier():
|
|
if arg.lower() == "zeropage" or arg in ("zp", "zP", "Zp"):
|
|
raise self.PError("zero page block should be named 'ZP'")
|
|
is_zp_block = arg == "ZP"
|
|
if arg in set(b.name for b in self.result.blocks):
|
|
orig = [b for b in self.result.blocks if b.name == arg][0]
|
|
if not is_zp_block:
|
|
raise self.PError("duplicate block name '{:s}', original definition at {}".format(arg, orig.sourceref))
|
|
self.cur_block = orig # zero page block occurrences are merged
|
|
else:
|
|
self.cur_block = ParseResult.Block(arg, self.sourceref.copy(), self.root_scope)
|
|
try:
|
|
self.root_scope.define_scope(self.cur_block.symbols, self.cur_block.sourceref)
|
|
except SymbolError as x:
|
|
raise self.PError(str(x))
|
|
elif arg == "{":
|
|
break
|
|
elif arg.endswith("{"):
|
|
# when there is no whitespace before the {
|
|
block_args.insert(0, "{")
|
|
block_args.insert(0, arg[:-1])
|
|
continue
|
|
else:
|
|
try:
|
|
block_address = parse_expr_as_int(arg, self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
except ParseError:
|
|
raise self.PError("Invalid block address")
|
|
if block_address == 0 or (block_address < 0x0200 and not is_zp_block):
|
|
raise self.PError("block address must be >= $0200 (or omitted)")
|
|
if is_zp_block:
|
|
if block_address not in (0, 0x04):
|
|
raise self.PError("zero page block address must be $04 (or omittted)")
|
|
block_address = 0x04
|
|
self.cur_block.address = block_address
|
|
if arg != "{":
|
|
line = self.peek_next_line()
|
|
if line != "{":
|
|
raise self.PError("expected '{' after block")
|
|
else:
|
|
self.next_line()
|
|
if self.print_block_parsing:
|
|
if self.cur_block.address:
|
|
print(" parsing block '{:s}' at ${:04x}".format(self.cur_block.name, self.cur_block.address))
|
|
else:
|
|
print(" parsing block '{:s}'".format(self.cur_block.name))
|
|
if self.cur_block.ignore:
|
|
# just skip the lines until we hit a '}' that closes the block
|
|
nesting_level = 1
|
|
while True:
|
|
line = self.next_line().strip()
|
|
if line.endswith("{"):
|
|
nesting_level += 1
|
|
elif line == "}":
|
|
nesting_level -= 1
|
|
if nesting_level == 0:
|
|
self.print_warning("ignoring block without name and address", self.cur_block.sourceref)
|
|
return None
|
|
else:
|
|
raise self.PError("invalid statement in block")
|
|
while True:
|
|
self._parse_comments()
|
|
line = self.next_line()
|
|
unstripped_line = line
|
|
line = line.strip()
|
|
if line == "}":
|
|
if is_zp_block and any(b.name == "ZP" for b in self.result.blocks):
|
|
return None # we already have the ZP block
|
|
if self.cur_block.ignore:
|
|
self.print_warning("ignoring block without name and address", self.cur_block.sourceref)
|
|
return None
|
|
return self.cur_block
|
|
if line.startswith(("var ", "var\t")):
|
|
self.parse_var_def(line)
|
|
elif line.startswith(("const ", "const\t")):
|
|
self.parse_const_def(line)
|
|
elif line.startswith(("memory ", "memory\t")):
|
|
self.parse_memory_def(line, is_zp_block)
|
|
elif line.startswith(("sub ", "sub\t")):
|
|
if is_zp_block:
|
|
raise self.PError("ZP block cannot contain subroutines")
|
|
self.parse_subroutine_def(line)
|
|
elif line.startswith(("asminclude ", "asminclude\t", "asmbinary ", "asmbinary\t")):
|
|
if is_zp_block:
|
|
raise self.PError("ZP block cannot contain assembler directives")
|
|
self.cur_block.statements.append(self.parse_asminclude(line))
|
|
elif line.startswith(("asm ", "asm\t")):
|
|
if is_zp_block:
|
|
raise self.PError("ZP block cannot contain code statements")
|
|
self.prev_line()
|
|
self.cur_block.statements.append(self.parse_asm())
|
|
elif line == "breakpoint":
|
|
self.cur_block.statements.append(ParseResult.BreakpointStmt(self.sourceref.line))
|
|
self.print_warning("breakpoint defined")
|
|
elif unstripped_line.startswith((" ", "\t")):
|
|
if is_zp_block:
|
|
raise self.PError("ZP block cannot contain code statements")
|
|
self.cur_block.statements.append(self.parse_statement(line))
|
|
elif line:
|
|
if is_zp_block:
|
|
raise self.PError("ZP block cannot contain code labels")
|
|
self.parse_label(line)
|
|
else:
|
|
raise self.PError("invalid statement in block")
|
|
|
|
def parse_label(self, line: str) -> None:
|
|
label_line = line.split(maxsplit=1)
|
|
if str.isidentifier(label_line[0]):
|
|
labelname = label_line[0]
|
|
if labelname in self.cur_block.label_names:
|
|
raise self.PError("label already defined")
|
|
if labelname in self.cur_block.symbols:
|
|
raise self.PError("symbol already defined")
|
|
self.cur_block.symbols.define_label(labelname, self.sourceref)
|
|
self.cur_block.statements.append(ParseResult.Label(labelname, self.sourceref.line))
|
|
if len(label_line) > 1:
|
|
rest = label_line[1]
|
|
self.cur_block.statements.append(self.parse_statement(rest))
|
|
else:
|
|
raise self.PError("invalid label name")
|
|
|
|
def parse_memory_def(self, line: str, is_zeropage: bool=False) -> None:
|
|
varname, datatype, length, dimensions, valuetext = self.parse_def_common(line, "memory")
|
|
memaddress = parse_expr_as_int(valuetext, self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
if is_zeropage and memaddress > 0xff:
|
|
raise self.PError("address must lie in zeropage $00-$ff")
|
|
try:
|
|
self.cur_block.symbols.define_variable(varname, self.sourceref, datatype,
|
|
length=length, address=memaddress, matrixsize=dimensions)
|
|
except SymbolError as x:
|
|
raise self.PError(str(x)) from x
|
|
|
|
def parse_const_def(self, line: str) -> None:
|
|
varname, datatype, length, dimensions, valuetext = self.parse_def_common(line, "const")
|
|
if dimensions:
|
|
raise self.PError("cannot declare a constant matrix")
|
|
value = parse_expr_as_primitive(valuetext, self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
_, value = self.coerce_value(self.sourceref, datatype, value)
|
|
try:
|
|
self.cur_block.symbols.define_constant(varname, self.sourceref, datatype, length=length, value=value)
|
|
except (ValueError, SymbolError) as x:
|
|
raise self.PError(str(x)) from x
|
|
|
|
def parse_subroutine_def(self, line: str) -> None:
|
|
match = re.fullmatch(r"sub\s+(?P<name>\w+)\s+"
|
|
r"\((?P<parameters>[\w\s:,]*)\)"
|
|
r"\s*->\s*"
|
|
r"\((?P<results>[\w\s?,]*)\)\s*"
|
|
r"(?P<decltype>\s+=\s+(?P<address>\S*)|{)\s*", line)
|
|
if not match:
|
|
raise self.PError("invalid sub declaration")
|
|
groups = match.groupdict()
|
|
code_decl = groups["decltype"] == "{"
|
|
name, parameterlist, resultlist, address_str = groups["name"], groups["parameters"], groups["results"], groups["address"]
|
|
parameters = [(m.group("name"), m.group("target"))
|
|
for m in re.finditer(r"(?:(?:(?P<name>[\w]+)\s*:\s*)?(?P<target>[\w]+))(?:,|$)", parameterlist)]
|
|
for _, regs in parameters:
|
|
if regs not in REGISTER_SYMBOLS:
|
|
raise self.PError("invalid register(s) in parameter or return values")
|
|
all_paramnames = [p[0] for p in parameters if p[0]]
|
|
if len(all_paramnames) != len(set(all_paramnames)):
|
|
raise self.PError("duplicates in parameter names")
|
|
results = [m.group("name") for m in re.finditer(r"\s*(?P<name>(?:\w+)\??)\s*(?:,|$)", resultlist)]
|
|
subroutine_block = None
|
|
if code_decl:
|
|
address = None
|
|
# parse the subroutine code lines (until the closing '}')
|
|
subroutine_block = ParseResult.Block(self.cur_block.name + "." + name, self.sourceref, self.cur_block.symbols)
|
|
current_block = self.cur_block
|
|
self.cur_block = subroutine_block
|
|
while True:
|
|
self._parse_comments()
|
|
line = self.next_line()
|
|
unstripped_line = line
|
|
line = line.strip()
|
|
if line == "}":
|
|
# subroutine end
|
|
break
|
|
if line.startswith(("sub ", "sub\t")):
|
|
raise self.PError("cannot nest subroutines")
|
|
elif line.startswith(("asm ", "asm\t")):
|
|
self.prev_line()
|
|
subroutine_block.statements.append(self.parse_asm())
|
|
elif unstripped_line.startswith((" ", "\t")):
|
|
subroutine_block.statements.append(self.parse_statement(line))
|
|
elif line:
|
|
self.parse_label(line)
|
|
else:
|
|
raise self.PError("invalid statement in subroutine")
|
|
self.cur_block = current_block
|
|
self.cur_block.sourceref = subroutine_block.sourceref
|
|
else:
|
|
try:
|
|
address = parse_expr_as_int(address_str, self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
except ParseError:
|
|
raise self.PError("invalid subroutine address")
|
|
try:
|
|
self.cur_block.symbols.define_sub(name, self.sourceref, parameters, results, address, subroutine_block)
|
|
except SymbolError as x:
|
|
raise self.PError(str(x)) from x
|
|
|
|
def parse_var_def(self, line: str) -> None:
|
|
varname, datatype, length, dimensions, valuetext = self.parse_def_common(line, "var", False)
|
|
value = parse_expr_as_primitive(valuetext, self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
_, value = self.coerce_value(self.sourceref, datatype, value)
|
|
try:
|
|
self.cur_block.symbols.define_variable(varname, self.sourceref, datatype,
|
|
length=length, value=value, matrixsize=dimensions)
|
|
except (ValueError, SymbolError) as x:
|
|
raise self.PError(str(x)) from x
|
|
|
|
def parse_def_common(self, line: str, what: str, value_required: bool=True) -> \
|
|
Tuple[str, DataType, int, Optional[Tuple[int, int]], str]:
|
|
try:
|
|
vartext, valuetext = line.split("=", maxsplit=1)
|
|
except ValueError:
|
|
if '=' not in line:
|
|
if value_required:
|
|
raise self.PError("missing value assignment")
|
|
vartext, valuetext = line, "0" # unspecified value is '0'
|
|
else:
|
|
raise self.PError("invalid {:s} decl, '=' missing?".format(what))
|
|
args = self.psplit(vartext)
|
|
if args[0] != what or len(args) < 2:
|
|
raise self.PError("invalid {:s} decl".format(what))
|
|
if len(args) > 3 or valuetext.startswith('='):
|
|
raise self.PError("invalid {:s} decl, '=' missing?".format(what))
|
|
if len(args) == 2:
|
|
args.insert(1, ".byte") # unspecified data type is ".byte"
|
|
if not args[1].startswith("."):
|
|
raise self.PError("invalid {:s} decl, type is missing".format(what))
|
|
varname = args[2]
|
|
if not varname.isidentifier():
|
|
raise self.PError("invalid {:s} name".format(what))
|
|
if varname in RESERVED_NAMES:
|
|
raise self.PError("can't use a reserved name as {:s} name".format(what))
|
|
datatype, length, matrix_dimensions = self.get_datatype(args[1])
|
|
return varname, datatype, length, matrix_dimensions, valuetext
|
|
|
|
def parse_statement(self, line: str) -> ParseResult._AstNode:
|
|
match = re.fullmatch(r"(?P<if>if(_[a-z]+)?)\s+(?P<cond>.+)?goto\s+(?P<subname>[\S]+?)\s*(\((?P<arguments>.*)\))?\s*", line)
|
|
if match:
|
|
# conditional goto
|
|
groups = match.groupdict()
|
|
subname = groups["subname"]
|
|
if '!' in subname:
|
|
raise self.PError("goto is always without register preservation, should not have exclamation mark")
|
|
if groups["if"] == "if" and not groups["cond"]:
|
|
raise self.PError("need explicit if status when a condition is not present")
|
|
condition = self.parse_if_condition(groups["if"], groups["cond"])
|
|
return self.parse_call_or_goto(subname, groups["arguments"], None, False, True, condition=condition)
|
|
match = re.fullmatch(r"goto\s+(?P<subname>[\S]+?)\s*(\((?P<arguments>.*)\))?\s*", line)
|
|
if match:
|
|
# goto
|
|
groups = match.groupdict()
|
|
subname = groups["subname"]
|
|
if '!' in subname:
|
|
raise self.PError("goto is always without register preservation, should not have exclamation mark")
|
|
return self.parse_call_or_goto(subname, groups["arguments"], None, False, True)
|
|
match = re.fullmatch(r"(?P<outputs>[^\(]*\s*=)?\s*(?P<subname>[\S]+?)\s*(?P<fcall>[!]?)\s*(\((?P<arguments>.*)\))?\s*", line)
|
|
if match:
|
|
# subroutine call (not a goto) with possible output param assignment
|
|
groups = match.groupdict()
|
|
preserve = not bool(groups["fcall"])
|
|
subname = groups["subname"]
|
|
arguments = groups["arguments"]
|
|
outputs = groups["outputs"] or ""
|
|
if outputs.strip() == "=":
|
|
raise self.PError("missing assignment target variables")
|
|
outputs = outputs.rstrip("=")
|
|
if arguments or match.group(4): # group 4 = (possibly empty) parenthesis
|
|
return self.parse_call_or_goto(subname, arguments, outputs, preserve, False)
|
|
# apparently it is not a call (no arguments), fall through
|
|
if line == "return" or line.startswith(("return ", "return\t")):
|
|
return self.parse_return(line)
|
|
elif line.endswith(("++", "--")):
|
|
incr = line.endswith("++")
|
|
what = self.parse_expression(line[:-2].rstrip())
|
|
if isinstance(what, ParseResult.IntegerValue):
|
|
raise self.PError("cannot in/decrement a constant value")
|
|
if incr:
|
|
return ParseResult.InplaceIncrStmt(what, 1, self.sourceref.line)
|
|
return ParseResult.InplaceDecrStmt(what, 1, self.sourceref.line)
|
|
else:
|
|
# perhaps it is an augmented assignment statement
|
|
match = re.fullmatch(r"(?P<left>\S+)\s*(?P<assignment>\+=|-=|\*=|/=|%=|//=|\*\*=|&=|\|=|\^=|>>=|<<=)\s*(?P<right>\S.*)", line)
|
|
if match:
|
|
return self.parse_augmented_assignment(match.group("left"), match.group("assignment"), match.group("right"))
|
|
# a normal assignment perhaps?
|
|
splits = [s.strip() for s in line.split('=')]
|
|
if len(splits) > 1 and all(splits):
|
|
return self.parse_assignment(*splits)
|
|
raise self.PError("invalid statement")
|
|
|
|
def parse_call_or_goto(self, targetstr: str, argumentstr: str, outputstr: str,
|
|
preserve_regs=True, is_goto=False, condition: ParseResult.IfCondition=None) -> ParseResult.CallStmt:
|
|
if not is_goto:
|
|
assert condition is None
|
|
argumentstr = argumentstr.strip() if argumentstr else ""
|
|
outputstr = outputstr.strip() if outputstr else ""
|
|
arguments = None
|
|
outputvars = None
|
|
if argumentstr:
|
|
arguments = parse_arguments(argumentstr, self.sourceref)
|
|
target = None # type: ParseResult.Value
|
|
if targetstr[0] == '[' and targetstr[-1] == ']':
|
|
# indirect call to address in register pair or memory location
|
|
targetstr, target = self.parse_indirect_value(targetstr, True)
|
|
if target.datatype != DataType.WORD:
|
|
raise self.PError("invalid call target (should contain 16-bit)")
|
|
else:
|
|
target = self.parse_expression(targetstr)
|
|
if not isinstance(target, (ParseResult.IntegerValue, ParseResult.RegisterValue,
|
|
ParseResult.MemMappedValue, ParseResult.IndirectValue)):
|
|
raise self.PError("cannot call that type of symbol")
|
|
if isinstance(target, ParseResult.IndirectValue) \
|
|
and not isinstance(target.value, (ParseResult.IntegerValue, ParseResult.RegisterValue, ParseResult.MemMappedValue)):
|
|
raise self.PError("cannot call that type of indirect symbol")
|
|
address = target.address if isinstance(target, ParseResult.MemMappedValue) else None
|
|
try:
|
|
_, symbol = self.lookup_with_ppsymbols(targetstr)
|
|
except ParseError:
|
|
symbol = None # it's probably a number or a register then
|
|
if isinstance(symbol, SubroutineDef):
|
|
if condition and symbol.parameters:
|
|
raise self.PError("cannot use a subroutine that requires parameters as a target for conditional goto")
|
|
# verify subroutine arguments
|
|
if len(arguments or []) != len(symbol.parameters):
|
|
raise self.PError("invalid number of arguments ({:d}, expected {:d})"
|
|
.format(len(arguments or []), len(symbol.parameters)))
|
|
args_with_pnames = []
|
|
for i, (argname, value) in enumerate(arguments or []):
|
|
pname, preg = symbol.parameters[i]
|
|
required_name = pname or preg
|
|
if argname and argname != required_name:
|
|
raise self.PError("parameter mismatch ('{:s}', expected '{:s}')".format(argname, required_name))
|
|
argname = preg
|
|
args_with_pnames.append((argname, value))
|
|
arguments = args_with_pnames
|
|
# verify output parameters
|
|
if symbol.return_registers:
|
|
if outputstr:
|
|
outputs = [r.strip() for r in outputstr.split(",")]
|
|
if len(outputs) != len(symbol.return_registers):
|
|
raise self.PError("invalid number of output parameters consumed ({:d}, expected {:d})"
|
|
.format(len(outputs), len(symbol.return_registers)))
|
|
outputvars = list(zip(symbol.return_registers, (self.parse_expression(out) for out in outputs)))
|
|
else:
|
|
self.print_warning("return values discarded")
|
|
else:
|
|
if outputstr:
|
|
raise self.PError("this subroutine doesn't have output parameters")
|
|
self.result.sub_used_by(symbol, self.sourceref) # sub usage tracking
|
|
else:
|
|
if outputstr:
|
|
raise self.PError("call cannot use output parameter assignment here, a subroutine is required for that")
|
|
if arguments:
|
|
raise self.PError("call cannot take any arguments here, a subroutine is required for that")
|
|
# verify that all arguments have gotten a name
|
|
if any(not a[0] for a in arguments or []):
|
|
raise self.PError("all call arguments should have a name or be matched on a named parameter")
|
|
if isinstance(target, (type(None), ParseResult.Value)):
|
|
if is_goto:
|
|
return ParseResult.CallStmt(self.sourceref.line, target, address=address,
|
|
arguments=arguments, outputs=outputvars, is_goto=True, condition=condition)
|
|
else:
|
|
return ParseResult.CallStmt(self.sourceref.line, target, address=address,
|
|
arguments=arguments, outputs=outputvars, preserve_regs=preserve_regs)
|
|
else:
|
|
raise TypeError("target should be a Value", target)
|
|
|
|
def parse_integer(self, text: str) -> int:
|
|
text = text.strip()
|
|
if text.startswith('$'):
|
|
return int(text[1:], 16)
|
|
if text.startswith('%'):
|
|
return int(text[1:], 2)
|
|
return int(text)
|
|
|
|
def parse_assignment(self, *parts) -> ParseResult.AssignmentStmt:
|
|
# parses the assignment of one rvalue to one or more lvalues
|
|
l_values = [self.parse_expression(p) for p in parts[:-1]]
|
|
r_value = self.parse_expression(parts[-1])
|
|
if any(lv.constant for lv in l_values):
|
|
raise self.PError("can't have a constant as assignment target, perhaps you wanted indirection [...] instead?")
|
|
for lv in l_values:
|
|
assignable, reason = lv.assignable_from(r_value)
|
|
if not assignable:
|
|
raise self.PError("cannot assign {0} to {1}; {2}".format(r_value, lv, reason))
|
|
if lv.datatype in (DataType.BYTE, DataType.WORD, DataType.MATRIX):
|
|
# truncate the rvalue if needed
|
|
if isinstance(r_value, ParseResult.FloatValue):
|
|
truncated, value = self.coerce_value(self.sourceref, lv.datatype, r_value.value)
|
|
if truncated:
|
|
r_value = ParseResult.IntegerValue(int(value), datatype=lv.datatype, name=r_value.name)
|
|
return ParseResult.AssignmentStmt(l_values, r_value, self.sourceref.line)
|
|
|
|
def parse_augmented_assignment(self, leftstr: str, operator: str, rightstr: str) \
|
|
-> Union[ParseResult.AssignmentStmt, ParseResult.InplaceDecrStmt, ParseResult.InplaceIncrStmt]:
|
|
# parses an augmented assignment (for instance: value += 3)
|
|
if operator not in ParseResult.AugmentedAssignmentStmt.SUPPORTED_OPERATORS:
|
|
raise self.PError("augmented assignment operator '{:s}' not supported".format(operator))
|
|
l_value = self.parse_expression(leftstr)
|
|
r_value = self.parse_expression(rightstr)
|
|
if l_value.constant:
|
|
raise self.PError("can't have a constant as assignment target, perhaps you wanted indirection [...] instead?")
|
|
if l_value.datatype in (DataType.BYTE, DataType.WORD, DataType.MATRIX):
|
|
# truncate the rvalue if needed
|
|
if isinstance(r_value, ParseResult.FloatValue):
|
|
truncated, value = self.coerce_value(self.sourceref, l_value.datatype, r_value.value)
|
|
if truncated:
|
|
r_value = ParseResult.IntegerValue(int(value), datatype=l_value.datatype, name=r_value.name)
|
|
if r_value.constant and operator in ("+=", "-="):
|
|
if operator == "+=":
|
|
if r_value.value > 0: # type: ignore
|
|
return ParseResult.InplaceIncrStmt(l_value, r_value.value, self.sourceref.line) # type: ignore
|
|
elif r_value.value < 0: # type: ignore
|
|
return ParseResult.InplaceDecrStmt(l_value, -r_value.value, self.sourceref.line) # type: ignore
|
|
else:
|
|
self.print_warning("incr with zero, ignored")
|
|
else:
|
|
if r_value.value > 0: # type: ignore
|
|
return ParseResult.InplaceDecrStmt(l_value, r_value.value, self.sourceref.line) # type: ignore
|
|
elif r_value.value < 0: # type: ignore
|
|
return ParseResult.InplaceIncrStmt(l_value, -r_value.value, self.sourceref.line) # type: ignore
|
|
else:
|
|
self.print_warning("decr with zero, ignored")
|
|
return ParseResult.AugmentedAssignmentStmt(l_value, operator, r_value, self.sourceref.line)
|
|
|
|
def parse_return(self, line: str) -> ParseResult.ReturnStmt:
|
|
parts = line.split(maxsplit=1)
|
|
if parts[0] != "return":
|
|
raise self.PError("invalid statement, return expected")
|
|
a = x = y = None
|
|
values = [] # type: List[str]
|
|
if len(parts) > 1:
|
|
values = parts[1].split(",")
|
|
if len(values) == 0:
|
|
return ParseResult.ReturnStmt(self.sourceref.line)
|
|
else:
|
|
a = self.parse_expression(values[0]) if values[0] else None
|
|
if len(values) > 1:
|
|
x = self.parse_expression(values[1]) if values[1] else None
|
|
if len(values) > 2:
|
|
y = self.parse_expression(values[2]) if values[2] else None
|
|
if len(values) > 3:
|
|
raise self.PError("too many returnvalues")
|
|
return ParseResult.ReturnStmt(self.sourceref.line, a, x, y)
|
|
|
|
def parse_asm(self) -> ParseResult.InlineAsm:
|
|
line = self.next_line()
|
|
lineno = self.sourceref.line
|
|
aline = line.split()
|
|
if not len(aline) == 2 or aline[0] != "asm" or aline[1] != "{":
|
|
raise self.PError("invalid asm start")
|
|
asmlines = [] # type: List[str]
|
|
while True:
|
|
line = self.next_line()
|
|
if line.strip() == "}":
|
|
return ParseResult.InlineAsm(asmlines, lineno)
|
|
# asm can refer to other symbols as well, track subroutine usage
|
|
splits = line.split(maxsplit=1)
|
|
if len(splits) == 2:
|
|
for match in re.finditer(r"(?P<symbol>[a-zA-Z_$][a-zA-Z0-9_\.]+)", splits[1]):
|
|
name = match.group("symbol")
|
|
if name[0] == '$':
|
|
continue
|
|
try:
|
|
if '.' not in name:
|
|
name = self.cur_block.symbols.parent.name + '.' + name
|
|
_, symbol = self.lookup_with_ppsymbols(name)
|
|
except ParseError:
|
|
pass
|
|
else:
|
|
if isinstance(symbol, SubroutineDef):
|
|
self.result.sub_used_by(symbol, self.sourceref)
|
|
asmlines.append(line)
|
|
|
|
def parse_asminclude(self, line: str) -> ParseResult.InlineAsm:
|
|
aline = line.split()
|
|
if len(aline) < 2:
|
|
raise self.PError("invalid asminclude or asmbinary statement")
|
|
filename = aline[1]
|
|
if not filename.startswith('"') or not filename.endswith('"'):
|
|
raise self.PError("filename must be between quotes")
|
|
filename = filename[1:-1]
|
|
if not filename:
|
|
raise self.PError("invalid filename")
|
|
filename_in_sourcedir = os.path.join(os.path.split(self.sourceref.file)[0], filename)
|
|
filename_in_output_location = os.path.join(self.outputdir, filename)
|
|
if not os.path.isfile(filename_in_sourcedir):
|
|
raise self.PError("included file not found")
|
|
print("copying included file to output location:", filename)
|
|
shutil.copy(filename_in_sourcedir, filename_in_output_location)
|
|
if aline[0] == "asminclude":
|
|
if len(aline) == 3:
|
|
scopename = aline[2]
|
|
lines = ['{:s}\t.binclude "{:s}"'.format(scopename, filename)]
|
|
else:
|
|
raise self.PError("invalid asminclude statement")
|
|
return ParseResult.InlineAsm(lines, self.sourceref.line)
|
|
elif aline[0] == "asmbinary":
|
|
if len(aline) == 4:
|
|
offset = parse_expr_as_int(aline[2], None, None, self.sourceref)
|
|
length = parse_expr_as_int(aline[3], None, None, self.sourceref)
|
|
lines = ['\t.binary "{:s}", ${:04x}, ${:04x}'.format(filename, offset, length)]
|
|
elif len(aline) == 3:
|
|
offset = parse_expr_as_int(aline[2], None, None, self.sourceref)
|
|
lines = ['\t.binary "{:s}", ${:04x}'.format(filename, offset)]
|
|
elif len(aline) == 2:
|
|
lines = ['\t.binary "{:s}"'.format(filename)]
|
|
else:
|
|
raise self.PError("invalid asmbinary statement")
|
|
return ParseResult.InlineAsm(lines, self.sourceref.line)
|
|
else:
|
|
raise self.PError("invalid statement")
|
|
|
|
def parse_expression(self, text: str, is_indirect=False) -> ParseResult.Value:
|
|
# parse an expression into whatever it is (primitive value, register, memory, register, etc)
|
|
text = text.strip()
|
|
if not text:
|
|
raise self.PError("value expected")
|
|
if text[0] == '#':
|
|
if is_indirect:
|
|
raise self.PError("using the address-of something in an indirect value makes no sense")
|
|
# take the pointer (memory address) from the thing that follows this
|
|
expression = self.parse_expression(text[1:])
|
|
if isinstance(expression, ParseResult.StringValue):
|
|
return expression
|
|
elif isinstance(expression, ParseResult.MemMappedValue):
|
|
return ParseResult.IntegerValue(expression.address, datatype=DataType.WORD, name=expression.name)
|
|
else:
|
|
raise self.PError("cannot take the address of this type")
|
|
elif text[0] in "-.0123456789$%~":
|
|
number = parse_expr_as_number(text, self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
try:
|
|
if type(number) is int:
|
|
return ParseResult.IntegerValue(int(number))
|
|
elif type(number) is float:
|
|
return ParseResult.FloatValue(number)
|
|
else:
|
|
raise TypeError("invalid number type")
|
|
except (ValueError, OverflowError) as ex:
|
|
raise self.PError(str(ex))
|
|
elif text in REGISTER_WORDS:
|
|
return ParseResult.RegisterValue(text, DataType.WORD)
|
|
elif text in REGISTER_BYTES | REGISTER_SBITS:
|
|
return ParseResult.RegisterValue(text, DataType.BYTE)
|
|
elif (text.startswith("'") and text.endswith("'")) or (text.startswith('"') and text.endswith('"')):
|
|
strvalue = parse_expr_as_string(text, self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
if len(strvalue) == 1:
|
|
petscii_code = char_to_bytevalue(strvalue)
|
|
return ParseResult.IntegerValue(petscii_code)
|
|
return ParseResult.StringValue(strvalue)
|
|
elif text == "true":
|
|
return ParseResult.IntegerValue(1)
|
|
elif text == "false":
|
|
return ParseResult.IntegerValue(0)
|
|
elif self.is_identifier(text):
|
|
symblock, sym = self.lookup_with_ppsymbols(text)
|
|
if isinstance(sym, (VariableDef, ConstantDef)):
|
|
constant = isinstance(sym, ConstantDef)
|
|
if self.cur_block is symblock:
|
|
symbolname = sym.name
|
|
else:
|
|
symbolname = "{:s}.{:s}".format(sym.blockname, sym.name)
|
|
if isinstance(sym, VariableDef) and sym.register:
|
|
return ParseResult.RegisterValue(sym.register, sym.type, name=symbolname)
|
|
elif sym.type in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
|
|
if isinstance(sym, ConstantDef):
|
|
if sym.type == DataType.FLOAT:
|
|
return ParseResult.FloatValue(sym.value, sym.name) # type: ignore
|
|
elif sym.type in (DataType.BYTE, DataType.WORD):
|
|
return ParseResult.IntegerValue(sym.value, datatype=sym.type, name=sym.name) # type: ignore
|
|
elif sym.type in STRING_DATATYPES:
|
|
return ParseResult.StringValue(sym.value, sym.name, True) # type: ignore
|
|
else:
|
|
raise TypeError("invalid const type", sym.type)
|
|
else:
|
|
return ParseResult.MemMappedValue(sym.address, sym.type, sym.length, name=symbolname, constant=constant)
|
|
elif sym.type in STRING_DATATYPES:
|
|
return ParseResult.StringValue(sym.value, name=symbolname, constant=constant) # type: ignore
|
|
elif sym.type == DataType.MATRIX:
|
|
raise self.PError("cannot manipulate matrix directly, use one of the matrix procedures")
|
|
elif sym.type == DataType.BYTEARRAY or sym.type == DataType.WORDARRAY:
|
|
raise self.PError("cannot manipulate array directly, use one of the array procedures")
|
|
else:
|
|
raise self.PError("invalid symbol type")
|
|
elif isinstance(sym, LabelDef):
|
|
name = sym.name if symblock is self.cur_block else sym.blockname + '.' + sym.name
|
|
return ParseResult.MemMappedValue(None, DataType.WORD, 1, name, True)
|
|
elif isinstance(sym, SubroutineDef):
|
|
self.result.sub_used_by(sym, self.sourceref)
|
|
name = sym.name if symblock is self.cur_block else sym.blockname + '.' + sym.name
|
|
return ParseResult.MemMappedValue(sym.address, DataType.WORD, 1, name, True)
|
|
else:
|
|
raise self.PError("invalid symbol type")
|
|
elif text.startswith('[') and text.endswith(']'):
|
|
return self.parse_indirect_value(text)[1]
|
|
else:
|
|
raise self.PError("invalid single value '" + text + "'") # @todo understand complex expressions
|
|
|
|
def parse_indirect_value(self, text: str, allow_mmapped_for_call: bool=False) -> Tuple[str, ParseResult.IndirectValue]:
|
|
indirect = text[1:-1].strip()
|
|
indirect2, sep, typestr = indirect.rpartition('.')
|
|
type_modifier = None
|
|
if sep:
|
|
if typestr in ("byte", "word", "float"):
|
|
type_modifier, type_len, _ = self.get_datatype(sep + typestr)
|
|
indirect = indirect2
|
|
expr = self.parse_expression(indirect, True)
|
|
if not isinstance(expr, (ParseResult.IntegerValue, ParseResult.MemMappedValue, ParseResult.RegisterValue)):
|
|
raise self.PError("only integers, memmapped vars, and registers can be used in an indirect value")
|
|
if type_modifier is None:
|
|
if isinstance(expr, (ParseResult.RegisterValue, ParseResult.MemMappedValue)):
|
|
type_modifier = expr.datatype
|
|
else:
|
|
type_modifier = DataType.BYTE
|
|
if isinstance(expr, ParseResult.IntegerValue):
|
|
if type_modifier not in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
|
|
raise self.PError("invalid type modifier for the value's datatype")
|
|
elif isinstance(expr, ParseResult.MemMappedValue):
|
|
if allow_mmapped_for_call:
|
|
if type_modifier and expr.datatype != type_modifier:
|
|
raise self.PError("invalid type modifier for the value's datatype, must be " + expr.datatype.name)
|
|
else:
|
|
raise self.PError("use variable directly instead of using indirect addressing")
|
|
return indirect, ParseResult.IndirectValue(expr, type_modifier)
|
|
|
|
def is_identifier(self, name: str) -> bool:
|
|
if name.isidentifier():
|
|
return True
|
|
blockname, sep, name = name.partition(".")
|
|
if sep:
|
|
return blockname.isidentifier() and name.isidentifier()
|
|
return False
|
|
|
|
def lookup_with_ppsymbols(self, dottedname: str) -> Tuple[ParseResult.Block, Union[SymbolDefinition, SymbolTable]]:
|
|
# Tries to find a symbol, if it cannot be located, the symbol table from the preprocess parse phase is consulted as well
|
|
symblock, sym = self.cur_block.lookup(dottedname)
|
|
if sym is None and self.ppsymbols:
|
|
# symbol is not (yet) known, see if the symbols from the preprocess parse phase know about it
|
|
if '.' not in dottedname:
|
|
dottedname = self.cur_block.name + '.' + dottedname
|
|
try:
|
|
symtable, sym = self.ppsymbols.lookup(dottedname)
|
|
assert dottedname.startswith(symtable.name)
|
|
symblock = None # the block might not have been parsed yet, so just return this instead
|
|
except (LookupError, SymbolError) as x:
|
|
raise self.PError(str(x))
|
|
return symblock, sym
|
|
|
|
def _size_from_arraydecl(self, decl: str) -> int:
|
|
return parse_expr_as_int(decl[:-1].split("(")[-1], self.cur_block.symbols, self.ppsymbols, self.sourceref)
|
|
|
|
def _size_from_matrixdecl(self, decl: str) -> Tuple[int, int]:
|
|
dimensions = decl[:-1].split("(")[-1]
|
|
try:
|
|
xs, ys = dimensions.split(",")
|
|
except ValueError:
|
|
raise self.PError("invalid matrix dimensions")
|
|
return (parse_expr_as_int(xs, self.cur_block.symbols, self.ppsymbols, self.sourceref),
|
|
parse_expr_as_int(ys, self.cur_block.symbols, self.ppsymbols, self.sourceref))
|
|
|
|
def coerce_value(self, sourceref: SourceRef, datatype: DataType, value: PrimitiveType) -> Tuple[bool, PrimitiveType]:
|
|
# if we're a BYTE type, and the value is a single character, convert it to the numeric value
|
|
if datatype in (DataType.BYTE, DataType.BYTEARRAY, DataType.MATRIX) and isinstance(value, str):
|
|
if len(value) == 1:
|
|
return True, char_to_bytevalue(value)
|
|
# if we're an integer value and the passed value is float, truncate it (and give a warning)
|
|
if datatype in (DataType.BYTE, DataType.WORD, DataType.MATRIX) and type(value) is float:
|
|
frac = math.modf(value) # type:ignore
|
|
if frac != 0:
|
|
self.print_warning("float value truncated")
|
|
return True, int(value)
|
|
return False, value
|
|
|
|
@staticmethod
|
|
def to_hex(number: int) -> str:
|
|
# 0..255 -> "$00".."$ff"
|
|
# 256..65536 -> "$0100".."$ffff"
|
|
if 0 <= number < 0x100:
|
|
return "${:02x}".format(number)
|
|
if number < 0x10000:
|
|
return "${:04x}".format(number)
|
|
raise OverflowError(number)
|
|
|
|
def psplit(self, sentence: str, separators: str=" \t", lparen: str="(", rparen: str=")") -> List[str]:
|
|
"""split a sentence but not on separators within parenthesis"""
|
|
nb_brackets = 0
|
|
sentence = sentence.strip(separators) # get rid of leading/trailing seps
|
|
indices = [0]
|
|
for i, c in enumerate(sentence):
|
|
if c == lparen:
|
|
nb_brackets += 1
|
|
elif c == rparen:
|
|
nb_brackets -= 1
|
|
elif c in separators and nb_brackets == 0:
|
|
indices.append(i)
|
|
# handle malformed string
|
|
if nb_brackets < 0:
|
|
raise self.PError("syntax error")
|
|
|
|
indices.append(len(sentence))
|
|
# handle missing closing parentheses
|
|
if nb_brackets > 0:
|
|
raise self.PError("syntax error")
|
|
result = [sentence[i:j].strip(separators) for i, j in zip(indices, indices[1:])]
|
|
return list(filter(None, result)) # remove empty strings
|
|
|
|
def parse_if_condition(self, ifpart: str, conditionpart: str) -> ParseResult.IfCondition:
|
|
if ifpart == "if":
|
|
ifstatus = "true"
|
|
else:
|
|
ifstatus = ifpart[3:]
|
|
if ifstatus not in ParseResult.IfCondition.IF_STATUSES:
|
|
raise self.PError("invalid if form")
|
|
if conditionpart:
|
|
if ifstatus not in ("true", "not", "zero"):
|
|
raise self.PError("can only have if[_true], if_not or if_zero when using a comparison expression")
|
|
left, operator, right = parse_expr_as_comparison(conditionpart, self.sourceref)
|
|
leftv = self.parse_expression(left)
|
|
if not operator and isinstance(leftv, (ParseResult.IntegerValue, ParseResult.FloatValue, ParseResult.StringValue)):
|
|
raise self.PError("condition is a constant value")
|
|
if isinstance(leftv, ParseResult.RegisterValue):
|
|
if leftv.register in {"SC", "SZ", "SI"}:
|
|
raise self.PError("cannot use a status bit register explicitly in a condition")
|
|
if operator:
|
|
rightv = self.parse_expression(right)
|
|
else:
|
|
rightv = None
|
|
if leftv == rightv:
|
|
raise self.PError("left and right values in comparison are identical")
|
|
result = ParseResult.IfCondition(ifstatus, leftv, operator, rightv, self.sourceref.line)
|
|
else:
|
|
result = ParseResult.IfCondition(ifstatus, None, "", None, self.sourceref.line)
|
|
if result.make_if_true():
|
|
self.print_warning("if_not condition inverted to if")
|
|
return result
|
|
|
|
|
|
class Optimizer:
|
|
def __init__(self, parseresult: ParseResult) -> None:
|
|
self.parsed = parseresult
|
|
|
|
def optimize(self) -> ParseResult:
|
|
print("\noptimizing parse tree")
|
|
for block in self.parsed.all_blocks():
|
|
self.remove_identity_assigns(block)
|
|
self.combine_assignments_into_multi(block)
|
|
self.optimize_multiassigns(block)
|
|
self.remove_unused_subroutines(block)
|
|
self.optimize_compare_with_zero(block)
|
|
return self.parsed
|
|
|
|
def optimize_compare_with_zero(self, block: ParseResult.Block) -> None:
|
|
# a conditional goto that compares a value to zero will be simplified
|
|
# the comparison operator and rvalue (0) will be removed and the if-status changed accordingly
|
|
for stmt in block.statements:
|
|
if isinstance(stmt, ParseResult.CallStmt):
|
|
cond = stmt.condition
|
|
if cond and isinstance(cond.rvalue, (ParseResult.IntegerValue, ParseResult.FloatValue)) and cond.rvalue.value == 0:
|
|
simplified = False
|
|
if cond.ifstatus in ("true", "ne"):
|
|
if cond.comparison_op == "==":
|
|
# if_true something == 0 -> if_not something
|
|
cond.ifstatus = "not"
|
|
cond.comparison_op, cond.rvalue = "", None
|
|
simplified = True
|
|
elif cond.comparison_op == "!=":
|
|
# if_true something != 0 -> if_true something
|
|
cond.comparison_op, cond.rvalue = "", None
|
|
simplified = True
|
|
elif cond.ifstatus in ("not", "eq"):
|
|
if cond.comparison_op == "==":
|
|
# if_not something == 0 -> if_true something
|
|
cond.ifstatus = "true"
|
|
cond.comparison_op, cond.rvalue = "", None
|
|
simplified = True
|
|
elif cond.comparison_op == "!=":
|
|
# if_not something != 0 -> if_not something
|
|
cond.comparison_op, cond.rvalue = "", None
|
|
simplified = True
|
|
if simplified:
|
|
print("{:s}:{:d}: simplified comparison with zero".format(block.sourceref.file, stmt.lineno))
|
|
|
|
def combine_assignments_into_multi(self, block: ParseResult.Block) -> None:
|
|
# fold multiple consecutive assignments with the same rvalue into one multi-assignment
|
|
statements = [] # type: List[ParseResult._AstNode]
|
|
multi_assign_statement = None
|
|
for stmt in block.statements:
|
|
if isinstance(stmt, ParseResult.AssignmentStmt) and not isinstance(stmt, ParseResult.AugmentedAssignmentStmt):
|
|
if multi_assign_statement and multi_assign_statement.right == stmt.right:
|
|
multi_assign_statement.leftvalues.extend(stmt.leftvalues)
|
|
print("{:s}:{:d}: joined with previous line into multi-assign statement".format(block.sourceref.file, stmt.lineno))
|
|
else:
|
|
if multi_assign_statement:
|
|
statements.append(multi_assign_statement)
|
|
multi_assign_statement = stmt
|
|
else:
|
|
if multi_assign_statement:
|
|
statements.append(multi_assign_statement)
|
|
multi_assign_statement = None
|
|
statements.append(stmt)
|
|
if multi_assign_statement:
|
|
statements.append(multi_assign_statement)
|
|
block.statements = statements
|
|
|
|
def optimize_multiassigns(self, block: ParseResult.Block) -> None:
|
|
# optimize multi-assign statements.
|
|
for stmt in block.statements:
|
|
if isinstance(stmt, ParseResult.AssignmentStmt) and len(stmt.leftvalues) > 1:
|
|
# remove duplicates
|
|
lvalues = list(set(stmt.leftvalues))
|
|
if len(lvalues) != len(stmt.leftvalues):
|
|
print("{:s}:{:d}: removed duplicate assignment targets".format(block.sourceref.file, stmt.lineno))
|
|
# change order: first registers, then zp addresses, then non-zp addresses, then the rest (if any)
|
|
stmt.leftvalues = list(sorted(lvalues, key=_value_sortkey))
|
|
|
|
def remove_identity_assigns(self, block: ParseResult.Block) -> None:
|
|
have_removed_stmts = False
|
|
for index, stmt in enumerate(list(block.statements)):
|
|
if isinstance(stmt, ParseResult.AssignmentStmt):
|
|
stmt.remove_identity_lvalues(block.sourceref.file, stmt.lineno)
|
|
if not stmt.leftvalues:
|
|
print("{:s}:{:d}: removed identity assignment statement".format(block.sourceref.file, stmt.lineno))
|
|
have_removed_stmts = True
|
|
block.statements[index] = None
|
|
if have_removed_stmts:
|
|
# remove the Nones
|
|
block.statements = [s for s in block.statements if s is not None]
|
|
|
|
def remove_unused_subroutines(self, block: ParseResult.Block) -> None:
|
|
# some symbols are used by the emitted assembly code from the code generator,
|
|
# and should never be removed or the assembler will fail
|
|
never_remove = {"c64util.GIVUAYF", "c64.FREADUY", "c64.FTOMEMXY"}
|
|
discarded = []
|
|
for sub in list(block.symbols.iter_subroutines()):
|
|
usages = self.parsed.subroutine_usage[(sub.blockname, sub.name)]
|
|
if not usages and sub.blockname + '.' + sub.name not in never_remove:
|
|
block.symbols.discard_sub(sub.name)
|
|
discarded.append(sub.name)
|
|
if discarded:
|
|
print("{}: discarded unused subroutines from block '{:s}': ".format(block.sourceref, block.name), end="")
|
|
print(", ".join(discarded))
|
|
|
|
|
|
def _value_sortkey(value: ParseResult.Value) -> int:
|
|
if isinstance(value, ParseResult.RegisterValue):
|
|
num = 0
|
|
for char in value.register:
|
|
num *= 100
|
|
num += ord(char)
|
|
return num
|
|
elif isinstance(value, ParseResult.MemMappedValue):
|
|
if value.address is None:
|
|
return 99999999
|
|
if value.address < 0x100:
|
|
return 10000 + value.address
|
|
else:
|
|
return 20000 + value.address
|
|
else:
|
|
return 99999999
|