easycoder 1__py2.py3-none-any.whl

easycoder/__init__.py

@@ -0,0 +1,12 @@
+'''EasyCoder for Python'''
+
+from .ec_classes import *
+from .ec_compiler import *
+from .ec_condition import *
+from .ec_core import *
+from .ec_handler import *
+from .ec_program import *
+from .ec_timestamp import *
+from .ec_value import *
+
+__version__ = "1"

easycoder/ec_classes.py

@@ -0,0 +1,51 @@
+import sys
+
+class FatalError:
+	def __init__(self, compiler, message):
+		compiler.showWarnings()
+		lino = compiler.tokens[compiler.index].lino
+		script = compiler.script.lines[lino].strip()
+		print(f'Compile error in {compiler.program.name} at line {lino + 1} ({script}): {message}')
+		sys.exit()
+
+class AssertionError:
+	def __init__(self, program):
+		code = program.code[program.pc]
+		lino = code['lino']
+		script = program.script.lines[lino].strip()
+		print(f'Assertion Error in {program.name} at line {lino + 1}')
+		sys.exit()
+
+class RuntimeError:
+	def __init__(self, program, message):
+		if program == None:
+			sys.exit(f'Runtime Error: {message}')
+		else:
+			code = program.code[program.pc]
+			lino = code['lino']
+			script = program.script.lines[lino].strip()
+			print(f'Runtime Error in {program.name} at line {lino + 1} ({script}): {message}')
+			sys.exit()
+
+class RuntimeWarning:
+	def __init__(self, program, message):
+		if program == None:
+			print(f'Runtime Warning: {message}')
+		else:
+			code = program.code[program.pc]
+			lino = code['lino']
+			script = program.script.lines[lino].strip()
+			print(f'Runtime Warning in {program.name} at line {lino + 1} ({script}): {message}')
+
+class Script:
+	def __init__(self, source):
+		self.lines = source.splitlines()
+		self.tokens = []
+
+class Token:
+	def __init__(self, lino, token):
+		self.lino = lino
+		self.token = token
+	
+class Condition():
+	negate = False

easycoder/ec_compiler.py

@@ -0,0 +1,201 @@
+from .ec_classes import Token, FatalError
+from .ec_value import Value
+from .ec_condition import Condition
+
+class Compiler:
+
+	def __init__(self, program):
+		self.program = program
+		self.domains = self.program.domains
+		self.value = Value(self)
+		self.condition = Condition(self)
+		self.marker = 0
+		self.script = self.program.script
+		self.tokens = self.script.tokens
+		self.symbols = self.program.symbols
+		self.code = self.program.code
+		self.warnings = []
+		self.program.compiler = self
+		self.addCommand = self.program.add
+
+	def getPC(self):
+		return len(self.program.code)
+
+	def getIndex(self):
+		return self.index
+
+	# Move the index along
+	def next(self):
+		self.index += 1
+
+	# Get the current token
+	def getToken(self):
+		if self.index >= len(self.tokens):
+			FatalError(self, 'Premature end of script')
+		return self.tokens[self.index].token
+
+	# Get the next token
+	def nextToken(self):
+		self.index += 1
+		return self.getToken()
+
+	def peek(self):
+		try:
+			return self.tokens[self.index + 1].token
+		except:
+			return None
+
+	# Get a value
+	def getValue(self):
+		return self.value.compileValue()
+
+	# Get the next value
+	def nextValue(self):
+		self.index += 1
+		return self.value.compileValue()
+
+	# Get a constant
+	def getConstant(self, token):
+		self.index += 1
+		return self.value.compileConstant(token)
+
+	# Get a condition
+	def getCondition(self):
+		return self.condition.compileCondition()
+
+	# Get the next condition
+	def nextCondition(self):
+		self.index += 1
+		return self.condition.compileCondition()
+
+	def tokenIs(self, value):
+		return self.getToken() == value
+
+	def nextIs(self, value):
+		return self.nextToken() == value
+
+	def getCommandAt(self, pc):
+		return self.program.code[pc]
+
+	def isSymbol(self):
+		token=self.getToken()
+		try:
+			self.symbols[token]
+		except:
+			return False
+		return True
+
+	def nextIsSymbol(self):
+		self.next()
+		return self.isSymbol()
+
+	def rewindTo(self, index):
+		self.index = index
+
+	def getLino(self):
+		if self.index >= len(self.tokens):
+			return 0
+		return self.tokens[self.index].lino
+
+	def warning(self, message):
+		self.warnings.append(message)
+
+	def showWarnings(self):
+		for warning in self.warnings:
+			print(f'Line {self.getLino() + 1}: {warning}')
+
+	def getSymbolRecord(self):
+		token = self.getToken()
+		symbol = self.symbols[token]
+		if symbol != None:
+			symbolRecord = self.code[symbol]
+			symbolRecord['used'] = True
+			return symbolRecord
+		return None
+
+	def compileLabel(self, command):
+		return self.compileSymbol(command, self.getToken(), False)
+
+	def compileVariable(self, command, valueHolder = False):
+		return self.compileSymbol(command, self.nextToken(), valueHolder)
+
+	def compileSymbol(self, command, name, valueHolder):
+		try:
+			v = self.symbols[name]
+		except:
+			v = None
+		if v:
+			FatalError(self, f'Duplicate symbol name "{name}"')
+			return False
+		self.symbols[name] = self.getPC()
+		command['type'] = 'symbol'
+		command['valueHolder'] = valueHolder
+		command['name'] = name
+		command['elements'] = 1
+		command['index'] = 0
+		command['value'] = [None]
+		command['used'] = False
+		command['debug'] = False
+		self.addCommand(command)
+		return True
+
+	# Compile the current token
+	def compileToken(self):
+		token = self.getToken()
+		# print(f'Compile {token}')
+		if not token:
+			return False
+		mark = self.getIndex()
+		for domain in self.domains:
+			handler = domain.keywordHandler(token)
+			if handler:
+				command = {}
+				command['domain'] = domain.getName()
+				command['lino'] = self.tokens[self.index].lino
+				command['keyword'] = token
+				command['type'] = None
+				command['debug'] = True
+				result = handler(command)
+				if result:
+					return result
+				else:
+					self.rewindTo(mark)
+			else:
+				self.rewindTo(mark)
+		FatalError(self, f'No handler found for "{token}"')
+		return False
+
+	# Compile a single command
+	def compileOne(self):
+		keyword = self.getToken()
+		if not keyword:
+			return False
+		# print(f'Compile keyword "{keyword}"')
+		if keyword.endswith(':'):
+			command = {}
+			command['domain'] = None
+			command['lino'] = self.tokens[self.index].lino
+			return self.compileLabel(command)
+		else:
+			return self.compileToken()
+
+	# Compile the script
+	def compileFrom(self, index, stopOn):
+		self.index = index
+		while True:
+			token = self.tokens[self.index]
+			keyword = token.token
+#			line = self.script.lines[token.lino]
+#			print(f'{keyword} - {line}')
+#			if keyword != 'else':
+			if self.compileOne() == True:
+				if self.index == len(self.tokens) - 1:
+					return True
+				token = self.nextToken()
+				if token in stopOn:
+					return True
+			else:
+				return False
+
+	def compileFromHere(self, stopOn):
+		return self.compileFrom(self.getIndex(), stopOn)

easycoder/ec_condition.py

@@ -0,0 +1,26 @@
+class Condition:
+
+	def __init__(self, compiler):
+		self.domains = compiler.domains
+		self.getToken = compiler.getToken
+		self.nextToken = compiler.nextToken
+		self.peek = compiler.peek
+		self.getIndex = compiler.getIndex
+		self.tokenIs = compiler.tokenIs
+		self.rewindTo = compiler.rewindTo
+		self.program = compiler.program
+
+	def compileCondition(self):
+		mark = self.getIndex()
+		for domain in self.domains:
+			condition = domain.compileCondition()
+			if condition != None:
+				condition.domain= domain.getName()
+				return condition
+			self.rewindTo(mark)
+			return None
+
+	def testCondition(self, condition):
+		handler = self.program.domainIndex[condition.domain]
+		handler = handler.conditionHandler(condition.type)
+		return handler(condition)