easycoder 250118.1__py2.py3-none-any.whl → 251103.4__py2.py3-none-any.whl

easycoder/__init__.py

@@ -5,8 +5,11 @@ from .ec_compiler import *
 from .ec_condition import *
 from .ec_core import *
 from .ec_handler import *
+from .ec_keyboard import *
+from .ec_border import *
 from .ec_program import *
+from .ec_pyside import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "250118.1"
+__version__ = "251103.4"

easycoder/ec_border.py

@@ -0,0 +1,63 @@
+import os
+from PySide6.QtWidgets import QWidget
+from PySide6.QtGui import QPixmap, QPainter
+from PySide6.QtCore import Qt, Signal, QRect
+
+class Border(QWidget):
+    tickClicked = Signal()
+    closeClicked = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self.size = 40
+        self.setFixedHeight(self.size)
+        self._drag_active = False
+        self._drag_start_pos = None
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+        # Draw the tick icon
+        self.tick = QPixmap(f'{os.path.dirname(os.path.abspath(__file__))}/tick.png').scaled(self.size, self.size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+        x = 0
+        y = 0
+        painter.drawPixmap(x, y, self.tick)
+        # Draw the close icon
+        self.close = QPixmap(f'{os.path.dirname(os.path.abspath(__file__))}/close.png').scaled(self.size, self.size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+        x = self.width() - self.close.width()
+        y = 0
+        painter.drawPixmap(x, y, self.close)
+
+    def mousePressEvent(self, event):
+        # Tick icon
+        x = 0
+        y = 0
+        tickRect = self.tick.rect().translated(x, y)
+        # Close icon
+        x = self.width() - self.close.width()
+        y = 0
+        closeRect = self.close.rect().translated(x, y)
+        if tickRect.contains(event.pos()):
+            self.tickClicked.emit()
+        if closeRect.contains(event.pos()):
+            self.closeClicked.emit()
+        elif QRect(0, 0, self.width(), self.height()).contains(event.pos()):
+            if hasattr(self.window().windowHandle(), 'startSystemMove'):
+                self.window().windowHandle().startSystemMove()
+            else:
+                self._drag_active = True
+                self._drag_start_pos = event.globalPosition().toPoint()
+                self._dialog_start_pos = self.window().pos()
+        else:
+            super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        if self._drag_active:
+            delta = event.globalPosition().toPoint() - self._drag_start_pos
+            self.window().move(self._dialog_start_pos + delta)
+        else:
+            super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        self._drag_active = False
+        super().mouseReleaseEvent(event)

easycoder/ec_classes.py

@@ -5,14 +5,17 @@ class FatalError:
 		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}')
+		print(f'Compile error in {compiler.program.name} at line {lino + 1} ({script}):\n-> {message}')
 		sys.exit()
 
+class NoValueError(FatalError):
+	def __init__(self, compiler, record):
+		super().__init__(compiler, f'Variable {record["name"]} does not hold a value')
+
 class AssertionError:
 	def __init__(self, program, msg=None):
 		code = program.code[program.pc]
 		lino = code['lino']
-		script = program.script.lines[lino].strip()
 		message = f'Assertion Error in {program.name} at line {lino + 1}'
 		if msg != None:
 			message += f': {msg}'
@@ -27,9 +30,13 @@ class RuntimeError:
 			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}')
+			print(f'Runtime Error in {program.name} at line {lino + 1} ({script}):\n-> {message}')
 			sys.exit()
 
+class NoValueRuntimeError(RuntimeError):
+	def __init__(self, program, record):
+		super().__init__(program, 'Variable {record["name"]} does not hold a value')
+
 class RuntimeWarning:
 	def __init__(self, program, message):
 		if program == None:
@@ -50,8 +57,5 @@ class Token:
 		self.lino = lino
 		self.token = token
 	
-class Condition():
-	negate = False
-
 class Object():
     pass

easycoder/ec_compiler.py

@@ -1,4 +1,4 @@
-from .ec_classes import Token, FatalError
+from .ec_classes import FatalError
 from .ec_value import Value
 from .ec_condition import Condition
 
@@ -13,10 +13,10 @@ class Compiler:
 		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
 		self.compileConstant = self.value.compileConstant
+		self.debugCompile = False
+		self.valueTypes = {}
 
 	def getPC(self):
 		return len(self.program.code)
@@ -77,8 +77,12 @@ class Compiler:
 	def getCommandAt(self, pc):
 		return self.program.code[pc]
 
+	# Add a command to the code list
+	def addCommand(self, command):
+		self.code.append(command)
+
 	def isSymbol(self):
-		token=self.getToken()
+		token = self.getToken()
 		try:
 			self.symbols[token]
 		except:
@@ -88,6 +92,15 @@ class Compiler:
 	def nextIsSymbol(self):
 		self.next()
 		return self.isSymbol()
+	
+	def skip(self, token):
+		next = self.peek()
+		if type(token) == list:
+			for item in token:
+				if next == item:
+					self.nextToken()
+					return
+		elif next == token: self.nextToken()
 
 	def rewindTo(self, index):
 		self.index = index
@@ -106,20 +119,28 @@ class Compiler:
 
 	def getSymbolRecord(self):
 		token = self.getToken()
+		if not token in self.symbols:
+			FatalError(self, f'Undefined symbol name "{token}"')
+			return None
 		symbol = self.symbols[token]
-		if symbol != None:
-			symbolRecord = self.code[symbol]
-			symbolRecord['used'] = True
-			return symbolRecord
-		return None
+		if symbol == None: return None
+		symbolRecord = self.code[symbol]
+		symbolRecord['used'] = True
+		return symbolRecord
+
+	def addValueType(self):
+		self.valueTypes[self.getToken()] = True
+
+	def hasValue(self, type):
+		return type in self.valueTypes
 
 	def compileLabel(self, command):
-		return self.compileSymbol(command, self.getToken(), False)
+		return self.compileSymbol(command, self.getToken())
 
-	def compileVariable(self, command, valueHolder = False):
-		return self.compileSymbol(command, self.nextToken(), valueHolder)
+	def compileVariable(self, command, extra=None):
+		return self.compileSymbol(command, self.nextToken(), extra)
 
-	def compileSymbol(self, command, name, valueHolder):
+	def compileSymbol(self, command, name, extra=None):
 		try:
 			v = self.symbols[name]
 		except:
@@ -130,7 +151,6 @@ class Compiler:
 		self.symbols[name] = self.getPC()
 		command['program'] = self.program
 		command['type'] = 'symbol'
-		command['valueHolder'] = valueHolder
 		command['name'] = name
 		command['elements'] = 1
 		command['index'] = 0
@@ -139,15 +159,22 @@ class Compiler:
 		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)
 		return True
 
 	# Compile the current token
 	def compileToken(self):
+		self.warnings = []
 		token = self.getToken()
 #		print(f'Compile {token}')
 		if not token:
 			return False
+		if len(self.code) == 0:
+			if self.program.parent == None and hasattr(self.program, 'usingGraphics'):
+				cmd = {'domain': 'graphics', 'keyword': 'init', 'debug': False}
+				self.code.append(cmd)
 		mark = self.getIndex()
 		for domain in self.program.getDomains():
 			handler = domain.keywordHandler(token)
@@ -165,14 +192,14 @@ class Compiler:
 					self.rewindTo(mark)
 			else:
 				self.rewindTo(mark)
-		FatalError(self, f'No handler found for "{token}"')
+		FatalError(self, f'Unable to compile this "{token}" command')
 
 	# Compile a single command
 	def compileOne(self):
 		keyword = self.getToken()
 		if not keyword:
 			return False
-		# print(f'Compile keyword "{keyword}"')
+		print(f'Compile keyword "{keyword}"')
 		if keyword.endswith(':'):
 			command = {}
 			command['domain'] = None
@@ -186,9 +213,8 @@ class Compiler:
 		self.index = index
 		while True:
 			token = self.tokens[self.index]
-			keyword = token.token
-#			line = self.script.lines[token.lino]
-#			print(f'{keyword} - {line}')
+#			keyword = token.token
+			if self.debugCompile: print(self.script.lines[token.lino])
 #			if keyword != 'else':
 			if self.compileOne() == True:
 				if self.index == len(self.tokens) - 1:
@@ -201,3 +227,6 @@ class Compiler:
 
 	def compileFromHere(self, stopOn):
 		return self.compileFrom(self.getIndex(), stopOn)
+
+	def compileFromStart(self):
+		return self.compileFrom(0, [])

easycoder/ec_condition.py

@@ -9,6 +9,7 @@ class Condition:
 		self.tokenIs = compiler.tokenIs
 		self.rewindTo = compiler.rewindTo
 		self.program = compiler.program
+		self.negate = False
 
 	def compileCondition(self):
 		mark = self.getIndex()
@@ -18,7 +19,7 @@ class Condition:
 				condition.domain= domain.getName()
 				return condition
 			self.rewindTo(mark)
-			return None
+		return None
 
 	def testCondition(self, condition):
 		handler = self.program.domainIndex[condition.domain]