prog8/il65/symbols.py
Irmen de Jong 2f6ef28c80 rename
2017-12-31 03:30:38 +01:00

692 lines
28 KiB
Python

"""
Programming Language for 6502/6510 microprocessors
Here are the symbol (name) operations such as lookups, datatype definitions.
Written by Irmen de Jong (irmen@razorvine.net)
License: GNU GPL 3.0, see LICENSE
"""
import inspect
import math
import enum
import builtins
from functools import total_ordering
from typing import Optional, Set, Union, Tuple, Dict, Iterable, Sequence, Any, List
PrimitiveType = Union[int, float, str]
REGISTER_SYMBOLS = {"A", "X", "Y", "AX", "AY", "XY", "SC", "SI"}
REGISTER_SYMBOLS_RETURNVALUES = REGISTER_SYMBOLS | {"SZ"}
REGISTER_BYTES = {"A", "X", "Y"}
REGISTER_SBITS = {"SC", "SI", "SZ"}
REGISTER_WORDS = {"AX", "AY", "XY"}
# 5-byte cbm MFLPT format limitations:
FLOAT_MAX_POSITIVE = 1.7014118345e+38
FLOAT_MAX_NEGATIVE = -1.7014118345e+38
RESERVED_NAMES = {'true', 'false', 'var', 'memory', 'const', 'asm', 'byte', 'word', 'float'}
RESERVED_NAMES |= REGISTER_SYMBOLS
MATH_SYMBOLS = {name for name in dir(math) if name[0].islower()}
BUILTIN_SYMBOLS = {name for name in dir(builtins) if name[0].islower()}
@total_ordering
class DataType(enum.Enum):
"""The possible data types of values"""
BYTE = 1
WORD = 2
FLOAT = 3
BYTEARRAY = 4
WORDARRAY = 5
MATRIX = 6
STRING = 7
STRING_P = 8
STRING_S = 9
STRING_PS = 10
def assignable_from_value(self, value: PrimitiveType) -> bool:
if isinstance(value, (int, float)):
if self == DataType.BYTE:
return 0 <= value < 0x100
if self == DataType.WORD:
return 0 <= value < 0x10000
if self == DataType.FLOAT:
return type(value) in (float, int)
return False
def __lt__(self, other):
if self.__class__ == other.__class__:
return self.value < other.value
return NotImplemented
STRING_DATATYPES = {DataType.STRING, DataType.STRING_P, DataType.STRING_S, DataType.STRING_PS}
class SymbolError(Exception):
pass
_identifier_seq_nr = 0
class SourceRef:
__slots__ = ("file", "line", "column")
def __init__(self, file: str, line: int, column: int=0) -> None:
self.file = file
self.line = line
self.column = column
def __str__(self) -> str:
if self.column:
return "{:s}:{:d}:{:d}".format(self.file, self.line, self.column)
if self.line:
return "{:s}:{:d}".format(self.file, self.line)
return self.file
def copy(self) -> 'SourceRef':
return SourceRef(self.file, self.line, self.column)
class SymbolDefinition:
def __init__(self, blockname: str, name: str, sourceref: SourceRef, allocate: bool) -> None:
self.blockname = blockname
self.name = name
self.sourceref = sourceref.copy()
self.allocate = allocate # set to false if the variable is memory mapped (or a constant) instead of allocated
global _identifier_seq_nr
self.seq_nr = _identifier_seq_nr
_identifier_seq_nr += 1
def __lt__(self, other: 'SymbolDefinition') -> bool:
if not isinstance(other, SymbolDefinition):
return NotImplemented
return (self.blockname, self.name, self.seq_nr) < (other.blockname, other.name, self.seq_nr)
def __str__(self):
return "<{:s} {:s}.{:s}>".format(self.__class__.__name__, self.blockname, self.name)
class LabelDef(SymbolDefinition):
pass
class VariableDef(SymbolDefinition):
# if address is None, it's a dynamically allocated variable.
# if address is not None, it's a memory mapped variable (=memory address referenced by a name).
def __init__(self, blockname: str, name: str, sourceref: SourceRef,
datatype: DataType, allocate: bool, *,
value: PrimitiveType, length: int, address: Optional[int]=None,
register: str=None, matrixsize: Tuple[int, int]=None) -> None:
super().__init__(blockname, name, sourceref, allocate)
self.type = datatype
self.address = address
self.length = length
self.value = value
self.register = register
self.matrixsize = matrixsize
@property
def is_memmap(self):
return self.address is not None
def __repr__(self):
return "<Variable {:s}.{:s}, {:s}, addr {:s}, len {:s}, value {:s}>"\
.format(self.blockname, self.name, self.type, str(self.address), str(self.length), str(self.value))
def __lt__(self, other: 'SymbolDefinition') -> bool:
if not isinstance(other, VariableDef):
return NotImplemented
v1 = (self.blockname, self.name or "", self.address or 0, self.seq_nr)
v2 = (other.blockname, other.name or "", other.address or 0, self.seq_nr)
return v1 < v2
class ConstantDef(SymbolDefinition):
def __init__(self, blockname: str, name: str, sourceref: SourceRef, datatype: DataType, *,
value: PrimitiveType, length: int) -> None:
super().__init__(blockname, name, sourceref, False)
self.type = datatype
self.length = length
self.value = value
def __repr__(self):
return "<Constant {:s}.{:s}, {:s}, len {:s}, value {:s}>"\
.format(self.blockname, self.name, self.type, str(self.length), str(self.value))
def __lt__(self, other: 'SymbolDefinition') -> bool:
if not isinstance(other, ConstantDef):
return NotImplemented
v1 = (str(self.value) or "", self.blockname, self.name or "", self.seq_nr)
v2 = (str(other.value) or "", other.blockname, other.name or "", self.seq_nr)
return v1 < v2
class SubroutineDef(SymbolDefinition):
def __init__(self, blockname: str, name: str, sourceref: SourceRef,
parameters: Sequence[Tuple[str, str]], returnvalues: Sequence[str],
address: Optional[int]=None, sub_block: Any=None) -> None:
super().__init__(blockname, name, sourceref, False)
self.address = address
self.sub_block = sub_block # this is a ParseResult.Block
self.parameters = parameters
self.clobbered_registers = set() # type: Set[str]
self.return_registers = [] # type: List[str] # ordered!
for _, param in parameters:
if param in REGISTER_BYTES | REGISTER_SBITS:
self.clobbered_registers.add(param)
elif param in REGISTER_WORDS:
self.clobbered_registers.add(param[0])
self.clobbered_registers.add(param[1])
else:
raise SymbolError("invalid parameter spec: " + param)
for register in returnvalues:
if register in REGISTER_SYMBOLS_RETURNVALUES:
self.return_registers.append(register)
if len(register) == 1:
self.clobbered_registers.add(register)
else:
self.clobbered_registers.add(register[0])
self.clobbered_registers.add(register[1])
elif register[-1] == "?":
for r in register[:-1]:
if r not in REGISTER_SYMBOLS_RETURNVALUES:
raise SymbolError("invalid return value spec: " + r)
if len(r) == 1:
self.clobbered_registers.add(r)
else:
self.clobbered_registers.add(r[0])
self.clobbered_registers.add(r[1])
else:
raise SymbolError("invalid return value spec: " + register)
class Zeropage:
SCRATCH_B1 = 0x02
SCRATCH_B2 = 0x03
SCRATCH_W1 = 0xfb # $fb/$fc
SCRATCH_W2 = 0xfd # $fd/$fe
def __init__(self) -> None:
self.free = [] # type: List[int]
self.allocations = {} # type: Dict[int, Tuple[str, DataType]]
self._configured = False
def configure(self, clobber_zp: bool = False) -> None:
if self._configured:
raise SymbolError("cannot configure the ZP multiple times")
if clobber_zp:
self.free = list(range(0x04, 0xfb)) + [0xff]
for updated_by_irq in [0xa0, 0xa1, 0xa2, 0x91, 0xc0, 0xc5, 0xcb, 0xf5, 0xf6]:
self.free.remove(updated_by_irq)
else:
# these are valid for the C-64 (when no RS232 I/O is performed):
# ($02, $03, $fb-$fc, $fd-$fe are reserved as scratch addresses for various routines)
self.free = [0x04, 0x05, 0x06, 0x2a, 0x52, 0xf7, 0xf8, 0xf9, 0xfa]
assert self.SCRATCH_B1 not in self.free
assert self.SCRATCH_B2 not in self.free
assert self.SCRATCH_W1 not in self.free
assert self.SCRATCH_W2 not in self.free
self._configured = True
def allocate(self, name: str, datatype: DataType) -> int:
assert self._configured
size = {
DataType.BYTE: 1,
DataType.WORD: 2,
DataType.FLOAT: 5
}[datatype]
def sequential(loc: int) -> bool:
for i in range(size):
if loc+i not in self.free:
return False
return True
if len(self.free) > 0:
if size == 1:
assert not name or name not in {a[0] for a in self.allocations.values()}
loc = self.free.pop()
self.allocations[loc] = (name or "<unnamed>", datatype)
return loc
for candidate in range(min(self.free), max(self.free)+1):
if sequential(candidate):
assert not name or name not in {a[0] for a in self.allocations.values()}
for loc in range(candidate, candidate+size):
self.free.remove(loc)
self.allocations[candidate] = (name or "<unnamed>", datatype)
return candidate
raise LookupError("no more free space in ZP to allocate {:d} sequential bytes".format(size))
def available(self) -> int:
return len(self.free)
class SymbolTable:
def __init__(self, name: str, parent: Optional['SymbolTable'], owning_block: Any) -> None:
self.name = name
self.symbols = {} # type: Dict[str, Union[SymbolDefinition, SymbolTable]]
self.parent = parent
self.owning_block = owning_block
self.eval_dict = None
self._zeropage = parent._zeropage if parent else None # type: Zeropage
def set_zeropage(self, zp: Zeropage) -> None:
if self._zeropage is None:
self._zeropage = zp
else:
raise SymbolError("already have a zp")
def __iter__(self):
yield from self.symbols.values()
def __getitem__(self, symbolname: str) -> Union[SymbolDefinition, 'SymbolTable']:
return self.symbols[symbolname]
def __contains__(self, symbolname: str) -> bool:
return symbolname in self.symbols
def lookup(self, dottedname: str, include_builtin_names: bool=False) -> Tuple['SymbolTable', Union[SymbolDefinition, 'SymbolTable']]:
# Tries to find the dottedname in the current symbol table (if it is not scoped),
# or globally if it is scoped (=contains a '.'). If required, math and builtin symbols
# such as 'sin' or 'max' are also resolved.
# Does NOT utilize a symbol table from a preprocessing parse phase, only looks in the current.
nameparts = dottedname.split('.')
if not nameparts[0]:
nameparts = nameparts[1:]
if len(nameparts) == 1:
try:
return self, self.symbols[nameparts[0]]
except LookupError:
if include_builtin_names:
if nameparts[0] in MATH_SYMBOLS:
return self, getattr(math, nameparts[0])
elif nameparts[0] in BUILTIN_SYMBOLS:
return self, getattr(builtins, nameparts[0])
raise SymbolError("undefined symbol '{:s}'".format(nameparts[0])) from None
# restart from global namespace:
scope = self
while scope.parent:
scope = scope.parent
for namepart in nameparts[:-1]:
try:
scope = scope.symbols[namepart] # type: ignore
assert scope.name == namepart
except LookupError:
raise SymbolError("undefined block '{:s}'".format(namepart)) from None
if isinstance(scope, SymbolTable):
return scope.lookup(nameparts[-1])
elif isinstance(scope, SubroutineDef):
return scope.sub_block.symbols.lookup_with_ppsymbols(nameparts[-1])
else:
raise SymbolError("invalid block name '{:s}' in dotted name".format(namepart))
def get_address(self, name: str) -> int:
scope, symbol = self.lookup(name)
if isinstance(symbol, ConstantDef):
raise SymbolError("cannot take the address of a constant")
if not symbol or not isinstance(symbol, VariableDef):
raise SymbolError("no var or const defined by that name")
if symbol.address is None:
raise SymbolError("can only take address of memory mapped variables")
return symbol.address
def as_eval_dict(self, ppsymbols: 'SymbolTable') -> Dict[str, Any]:
# return a dictionary suitable to be passed as locals or globals to eval()
if self.eval_dict is None:
d = EvalSymbolDict(self, ppsymbols)
self.eval_dict = d # type: ignore
return self.eval_dict
def iter_variables(self) -> Iterable[VariableDef]:
yield from sorted((v for v in self.symbols.values() if isinstance(v, VariableDef)))
def iter_constants(self) -> Iterable[ConstantDef]:
yield from sorted((v for v in self.symbols.values() if isinstance(v, ConstantDef)))
def iter_subroutines(self, userdefined_only: bool=False) -> Iterable[SubroutineDef]:
if userdefined_only:
yield from sorted((sub for sub in self.symbols.values()
if isinstance(sub, SubroutineDef) and sub.address is None and sub.sub_block is not None))
else:
yield from sorted((sub for sub in self.symbols.values() if isinstance(sub, SubroutineDef)))
def iter_labels(self) -> Iterable[LabelDef]:
yield from sorted((v for v in self.symbols.values() if isinstance(v, LabelDef)))
def check_identifier_valid(self, name: str, sourceref: SourceRef) -> None:
if not name.isidentifier():
raise SymbolError("invalid identifier")
identifier = self.symbols.get(name, None)
if identifier:
if isinstance(identifier, SymbolDefinition):
raise SymbolError("identifier was already defined at " + str(identifier.sourceref))
elif isinstance(identifier, SymbolTable):
raise SymbolError("identifier already defined as block at " + str(identifier.owning_block.sourceref))
raise SymbolError("identifier already defined as " + str(type(identifier)))
if name in MATH_SYMBOLS:
print("warning: {}: identifier shadows a name from the math module".format(sourceref))
elif name in BUILTIN_SYMBOLS:
print("warning: {}: identifier shadows a builtin name".format(sourceref))
def define_variable(self, name: str, sourceref: SourceRef, datatype: DataType, *,
address: int=None, length: int=0, value: PrimitiveType=0,
matrixsize: Tuple[int, int]=None, register: str=None) -> None:
# this defines a new variable and also checks if the prefill value is allowed for the variable type.
assert value is not None
self.check_identifier_valid(name, sourceref)
range_error = check_value_in_range(datatype, register, length, value)
if range_error:
raise ValueError(range_error)
allocate = address is None
if datatype == DataType.BYTE:
if allocate and self.name == "ZP":
try:
address = self._zeropage.allocate(name, datatype)
except LookupError:
raise SymbolError("no space in ZP left for global 8-bit variable (try zp clobber)")
self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.BYTE, allocate,
value=value, length=1, address=address)
elif datatype == DataType.WORD:
if allocate and self.name == "ZP":
try:
address = self._zeropage.allocate(name, datatype)
except LookupError:
raise SymbolError("no space in ZP left for global 16-bit word variable (try zp clobber)")
self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.WORD, allocate,
value=value, length=1, address=address)
elif datatype == DataType.FLOAT:
if allocate and self.name == "ZP":
try:
address = self._zeropage.allocate(name, datatype)
except LookupError:
raise SymbolError("no space in ZP left for global 5-byte MFLT float variable (try zp clobber)")
self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.FLOAT, allocate,
value=value, length=1, address=address)
elif datatype == DataType.BYTEARRAY:
self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.BYTEARRAY, allocate,
value=value, length=length, address=address)
elif datatype == DataType.WORDARRAY:
self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.WORDARRAY, allocate,
value=value, length=length, address=address)
elif datatype in (DataType.STRING, DataType.STRING_P, DataType.STRING_S, DataType.STRING_PS):
self.symbols[name] = VariableDef(self.name, name, sourceref, datatype, True,
value=value, length=len(value)) # type: ignore
elif datatype == DataType.MATRIX:
assert isinstance(matrixsize, tuple)
length = matrixsize[0] * matrixsize[1]
self.symbols[name] = VariableDef(self.name, name, sourceref, DataType.MATRIX, allocate,
value=value, length=length, address=address, matrixsize=matrixsize)
else:
raise ValueError("unknown type " + str(datatype))
self.eval_dict = None
def define_sub(self, name: str, sourceref: SourceRef,
parameters: Sequence[Tuple[str, str]], returnvalues: Sequence[str],
address: Optional[int], sub_block: Any) -> None:
self.check_identifier_valid(name, sourceref)
self.symbols[name] = SubroutineDef(self.name, name, sourceref, parameters, returnvalues, address, sub_block)
def discard_sub(self, name: str) -> None:
sub = self.symbols[name]
if isinstance(sub, SubroutineDef):
del self.symbols[name]
else:
raise TypeError("not a subroutine")
def define_label(self, name: str, sourceref: SourceRef) -> None:
self.check_identifier_valid(name, sourceref)
self.symbols[name] = LabelDef(self.name, name, sourceref, False)
def define_scope(self, scope: 'SymbolTable', sourceref: SourceRef) -> None:
self.check_identifier_valid(scope.name, sourceref)
self.symbols[scope.name] = scope
def define_constant(self, name: str, sourceref: SourceRef, datatype: DataType, *,
length: int=0, value: PrimitiveType=0) -> None:
# this defines a new constant and also checks if the value is allowed for the data type.
assert value is not None
self.check_identifier_valid(name, sourceref)
range_error = check_value_in_range(datatype, "", length, value)
if range_error:
raise ValueError(range_error)
if datatype in (DataType.BYTE, DataType.WORD, DataType.FLOAT):
self.symbols[name] = ConstantDef(self.name, name, sourceref, datatype, value=value, length=length or 1)
elif datatype in STRING_DATATYPES:
strlen = len(value) # type: ignore
self.symbols[name] = ConstantDef(self.name, name, sourceref, datatype, value=value, length=strlen)
else:
raise ValueError("invalid data type for constant: " + str(datatype))
self.eval_dict = None
def merge_roots(self, other_root: 'SymbolTable') -> None:
assert self.parent is None and other_root.parent is None
for name, thing in other_root.symbols.items():
if isinstance(thing, SymbolTable):
try:
self.define_scope(thing, thing.owning_block.sourceref)
except SymbolError as x:
raise SymbolError("problematic symbol '{:s}' from {}; {:s}"
.format(thing.name, thing.owning_block.sourceref, str(x))) from None
def print_table(self) -> None:
def print_symbols(symbols: 'SymbolTable', level: int) -> None:
indent = '\t' * level
print("\n" + indent + "BLOCK:", symbols.name)
for name, s in sorted(symbols.symbols.items(), key=lambda x: str(getattr(x[1], "sourceref", ""))):
if isinstance(s, SymbolTable):
print_symbols(s, level + 1)
elif isinstance(s, SubroutineDef):
print(indent * 2 + "SUB: " + s.name, s.sourceref, sep="\t")
elif isinstance(s, LabelDef):
print(indent * 2 + "LABEL: " + s.name, s.sourceref, sep="\t")
elif isinstance(s, VariableDef):
print(indent * 2 + "VAR: " + s.name, s.sourceref, s.type, sep="\t")
elif isinstance(s, ConstantDef):
print(indent * 2 + "CONST: " + s.name, s.sourceref, s.type, sep="\t")
else:
raise TypeError("invalid symbol def type", s)
print("\nSymbols defined in the symbol table:")
print("------------------------------------")
print_symbols(self, 0)
print()
class EvalSymbolDict(dict):
def __init__(self, symboltable: SymbolTable, ppsymbols: SymbolTable, constant: bool=True) -> None:
super().__init__()
self._symboltable = symboltable
self._ppsymbols = ppsymbols
self._is_constant = constant
def __getattr__(self, name):
return self.__getitem__(name)
def __getitem__(self, name):
if name[0] != '_' and name in builtins.__dict__:
return builtins.__dict__[name]
try:
scope, symbol = self._symboltable.lookup(name)
except (LookupError, SymbolError):
# attempt lookup from global scope
global_scope = self._symboltable
while global_scope.parent:
global_scope = global_scope.parent
try:
scope, symbol = global_scope.lookup(name, True)
except (LookupError, SymbolError):
# try the ppsymbols
if self._ppsymbols:
return self._ppsymbols.as_eval_dict(None)[name]
raise SymbolError("undefined symbol '{:s}'".format(name)) from None
if self._is_constant:
if isinstance(symbol, ConstantDef):
return symbol.value
elif isinstance(symbol, VariableDef):
raise SymbolError("can't reference a variable inside a (constant) expression")
elif inspect.isbuiltin(symbol):
return symbol
elif isinstance(symbol, SymbolTable):
return symbol.as_eval_dict(self._ppsymbols)
elif isinstance(symbol, (LabelDef, SubroutineDef)):
raise SymbolError("can't reference a label or subroutine inside a (constant) expression")
else:
raise SymbolError("invalid symbol type referenced " + repr(symbol))
else:
raise SymbolError("no support for non-constant expression evaluation yet")
def check_value_in_range(datatype: DataType, register: str, length: int, value: PrimitiveType) -> Optional[str]:
if register:
if register in REGISTER_BYTES:
if value < 0 or value > 0xff: # type: ignore
return "value out of range, must be (unsigned) byte for a single register"
elif register in REGISTER_SBITS:
if value not in (0, 1):
return "value out of range, must be 0 or 1 for a status bit register"
elif register in REGISTER_WORDS:
if value is None and datatype in (DataType.BYTE, DataType.WORD):
return None
if value < 0 or value > 0xffff: # type: ignore
return "value out of range, must be (unsigned) word for 2 combined registers"
else:
return "strange register"
elif datatype in (DataType.BYTE, DataType.BYTEARRAY, DataType.MATRIX):
if value is None and datatype == DataType.BYTE:
return None
if value < 0 or value > 0xff: # type: ignore
return "value out of range, must be (unsigned) byte"
elif datatype in (DataType.WORD, DataType.WORDARRAY):
if value is None and datatype in (DataType.BYTE, DataType.WORD):
return None
if value < 0 or value > 0xffff: # type: ignore
return "value out of range, must be (unsigned) word"
elif datatype in STRING_DATATYPES:
if type(value) is not str:
return "value must be a string"
elif datatype == DataType.FLOAT:
if type(value) not in (int, float):
return "value must be a number"
else:
raise SymbolError("missing value check for type", datatype, register, length, value)
return None # all ok !
def char_to_bytevalue(character: str, petscii: bool=True) -> int:
assert len(character) == 1
if petscii:
return ord(character.translate(ascii_to_petscii_trans))
else:
raise NotImplementedError("screencode conversion not yet implemented for chars")
# ASCII/UNICODE-to-PETSCII translation table
# Unicode symbols supported that map to a PETSCII character: £ ↑ ← ♠ ♥ ♦ ♣ π ● ○ and various others
ascii_to_petscii_trans = str.maketrans({
'\f': 147, # form feed becomes ClearScreen "{clear}"
'\n': 13, # line feed becomes a RETURN "{cr}" (not a line feed)
'\r': 17, # CR becomes CursorDown "{down}"
'a': 65,
'b': 66,
'c': 67,
'd': 68,
'e': 69,
'f': 70,
'g': 71,
'h': 72,
'i': 73,
'j': 74,
'k': 75,
'l': 76,
'm': 77,
'n': 78,
'o': 79,
'p': 80,
'q': 81,
'r': 82,
's': 83,
't': 84,
'u': 85,
'v': 86,
'w': 87,
'x': 88,
'y': 89,
'z': 90,
'A': 97,
'B': 98,
'C': 99,
'D': 100,
'E': 101,
'F': 102,
'G': 103,
'H': 104,
'I': 105,
'J': 106,
'K': 107,
'L': 108,
'M': 109,
'N': 110,
'O': 111,
'P': 112,
'Q': 113,
'R': 114,
'S': 115,
'T': 116,
'U': 117,
'V': 118,
'W': 119,
'X': 120,
'Y': 121,
'Z': 122,
'{': 179, # left squiggle
'}': 235, # right squiggle
'£': 92, # pound currency sign
'^': 94, # up arrow
'~': 126, # pi math symbol
'π': 126, # pi symbol
'`': 39, # single quote
'': 250, # check mark
'|': 221, # vertical bar
'': 221, # vertical bar
'': 96, # horizontal bar
'': 123, # vertical and horizontal bar
'': 94, # up arrow
'': 95, # left arrow
'': 163, # upper bar
'_': 164, # lower bar (underscore)
'': 164, # lower bar
'': 165, # left bar
'': 97, # spades
'': 113, # circle
'': 115, # hearts
'': 119, # open circle
'': 120, # clubs
'': 122, # diamonds
'': 171, # vertical and right
'': 179, # vertical and left
'': 177, # horiz and up
'': 178, # horiz and down
'': 173, # up right
'': 174, # down left
'': 175, # down right
'': 189, # up left
'': 172, # block lr
'': 187, # block ll
'': 188, # block ur
'': 190, # block ul
'': 191, # block ul and lr
'': 161, # left half
'': 162, # lower half
'': 230, # raster
})