easycoder 251104.2__py2.py3-none-any.whl → 260110.1__py2.py3-none-any.whl

easycoder/ec_compiler.py

@@ -1,3 +1,4 @@
+import sys
 from .ec_classes import FatalError
 from .ec_value import Value
 from .ec_condition import Condition
@@ -55,10 +56,12 @@ class Compiler:
 
 	# Get a value
 	def getValue(self):
+		self.program.ensureNotRunning()
 		return self.value.compileValue()
 
 	# Get the next value
 	def nextValue(self):
+		self.program.ensureNotRunning()
 		self.index += 1
 		return self.value.compileValue()
 
@@ -84,7 +87,8 @@ class Compiler:
 		return self.program.code[pc]
 
 	# Add a command to the code list
-	def addCommand(self, command):
+	def addCommand(self, command, debug=True):
+		command['debug'] = debug
 		command['bp'] = False
 		self.code.append(command)
 
@@ -110,7 +114,19 @@ class Compiler:
 				if next == item:
 					self.nextToken()
 					return
-		elif next == token: self.nextToken()
+		elif next == token:
+			self.nextToken()
+
+	# Skip common articles (optional syntactic noise for readability/disambiguation)
+	# Consumes leading articles ('the', 'a', 'an') at the next position
+	def skipArticles(self):
+		# Consume leading articles at next position(s) — like skip() but for multiple
+		while True:
+			next_tok = self.peek()
+			if next_tok in ['the', 'a', 'an']:
+				self.nextToken()
+			else:
+				break
 
 	# Rewind to a given position in the code list
 	def rewindTo(self, index):
@@ -132,58 +148,83 @@ class Compiler:
 			print(warning)
 
 	# Get the symbol record for the current token (assumes it is a symbol name)
-	def getSymbolRecord(self):
-		token = self.getToken()
-		if not token in self.symbols:
-			FatalError(self, f'Undefined symbol name "{token}"')
+	def getSymbolRecord(self, name=None):
+		self.program.ensureNotRunning()
+		if name == None: name = self.getToken()
+		if not name in self.symbols:
+			FatalError(self, f'Undefined symbol name "{name}"')
 			return None
-		symbol = self.symbols[token]
+		symbol = self.symbols[name]
 		if symbol == None: return None
-		symbolRecord = self.code[symbol]
-		symbolRecord['used'] = True
-		return symbolRecord
+		record = self.code[symbol]
+		record['used'] = True
+		return record
 
 	# Add a value type
 	def addValueType(self):
-		self.valueTypes[self.getToken()] = True
+		name = self.peek()
+		record = None
+		try:
+			record = self.symbols[name]
+		except:
+			pass
+		if record != None:
+			raise FatalError(self, f'Duplicate symbol name "{name}"')
+		self.valueTypes[name] = True
 
 	# Test if a given value is in the value types list
 	def hasValue(self, type):
 		return type in self.valueTypes
-
-	# Compile a program label (a symbol ending with ':')
-	def compileLabel(self, command):
-		return self.compileSymbol(command, self.getToken())
+	
+	# Instantiate an object of the given class name
+	def instantiate(self, classname):
+		# Search through all loaded modules for the class
+		items = sys.modules.items()
+		for module_name, module in items:
+			if module is None:
+				continue
+			try:
+				if hasattr(module, classname):
+					cls = getattr(module, classname)
+					# Verify it's actually a class
+					if isinstance(cls, type):
+						# Attempt to instantiate
+						try:
+							return cls()
+						except TypeError as ex:
+							raise FatalError(self, f"Object instantiation error: {ex}")
+			except Exception:
+				continue
+		return None
 
 	# Compile a variable
-	def compileVariable(self, command, extra=None):
-		return self.compileSymbol(command, self.nextToken(), extra)
+	def compileVariable(self, command, classname):
+		return self.compileSymbol(command, self.nextToken(), classname)
 
 	# Compile a symbol
-	def compileSymbol(self, command, name, extra=None):
-		try:
-			v = self.symbols[name]
-		except:
-			v = None
-		if v:
-			FatalError(self, f'Duplicate symbol name "{name}"')
-			return False
-		self.symbols[name] = self.getCodeSize()
-		command['program'] = self.program
-		command['type'] = 'symbol'
+	def compileSymbol(self, command, name, classname):
+		# try:
+		# 	self.symbols[name]
+		# 	raise FatalError(self, f'Duplicate symbol name "{name}"')
+		# except: pass
 		command['name'] = name
-		command['elements'] = 1
-		command['index'] = 0
-		command['value'] = [None]
+		command['classname'] = classname
+		command['program'] = self.program
 		command['used'] = False
-		command['debug'] = False
-		command['import'] = None
-		command['locked'] = False
-		command['extra'] = extra
-		if 'keyword' in command: command['hasValue'] = self.hasValue(command['keyword'])
-		self.addCommand(command)
+		self.symbols[name] = self.getCodeSize()
+		if classname != ':':
+			object = self.instantiate(classname)
+			command['object'] = object
+			if object != None:
+				command['type'] = 'symbol'
+				object.setName(name) # type: ignore
+		self.addCommand(command, False)
 		return True
 
+	# Compile a program label (a symbol ending with ':')
+	def compileLabel(self, command):
+		return self.compileSymbol(command, self.getToken(), ':')
+
 	# Compile the current token
 	def compileToken(self):
 		self.warnings = []
@@ -192,8 +233,8 @@ class Compiler:
 		if not token:
 			return False
 		if len(self.code) == 0:
-			if self.program.parent == None and self.program.usingGraphics:
-				cmd = {'domain': 'graphics', 'keyword': 'init', 'debug': False}
+			if self.program.parent == None and self.program.graphics:
+				cmd = {'domain': 'graphics', 'keyword': 'init'}
 				self.code.append(cmd)
 		mark = self.getIndex()
 		for domain in self.program.getDomains():
@@ -203,8 +244,6 @@ class Compiler:
 				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
@@ -233,9 +272,7 @@ class Compiler:
 		self.index = index
 		while True:
 			token = self.tokens[self.index]
-#			keyword = token.token
-			if self.debugCompile: print(self.script.lines[token.lino])
-#			if keyword != 'else':
+			if self.debugCompile: print(f'{token.lino + 1}: {self.script.lines[token.lino]}')
 			if self.compileOne() == True:
 				if self.index == len(self.tokens) - 1:
 					return True

easycoder/ec_condition.py

@@ -16,7 +16,7 @@ class Condition:
 		for domain in self.compiler.program.getDomains():
 			condition = domain.compileCondition()
 			if condition != None:
-				condition.domain= domain.getName()
+				condition.domain = domain.getName()
 				return condition
 			self.rewindTo(mark)
 		return None