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

easycoder/__init__.py

@@ -12,4 +12,4 @@ from .ec_pyside import *
 from .ec_timestamp import *
 from .ec_value import *
 
-__version__ = "251103.4"
+__version__ = "251105.1"

easycoder/ec_border.py

@@ -9,34 +9,38 @@ class Border(QWidget):
 
     def __init__(self):
         super().__init__()
-        self.size = 40
-        self.setFixedHeight(self.size)
+        self._size = 40
+        self.setFixedHeight(self._size)
         self._drag_active = False
         self._drag_start_pos = None
+        self._tick: QPixmap = QPixmap()
+        self._close_icon: QPixmap = QPixmap()
 
     def paintEvent(self, event):
         painter = QPainter(self)
-        painter.setRenderHint(QPainter.Antialiasing)
+        painter.setRenderHint(QPainter.RenderHint.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)
+        self._tick = QPixmap(f'{os.path.dirname(os.path.abspath(__file__))}/icons/tick.png').scaled(
+            self._size, self._size, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
         x = 0
         y = 0
-        painter.drawPixmap(x, y, self.tick)
+        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()
+        self._close_icon = QPixmap(f'{os.path.dirname(os.path.abspath(__file__))}/icons/close.png').scaled(
+            self._size, self._size, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
+        x = self.width() - self._close_icon.width()
         y = 0
-        painter.drawPixmap(x, y, self.close)
+        painter.drawPixmap(x, y, self._close_icon)
 
     def mousePressEvent(self, event):
         # Tick icon
         x = 0
         y = 0
-        tickRect = self.tick.rect().translated(x, y)
+        tickRect = self._tick.rect().translated(x, y)
         # Close icon
-        x = self.width() - self.close.width()
+        x = self.width() - self._close_icon.width()
         y = 0
-        closeRect = self.close.rect().translated(x, y)
+        closeRect = self._close_icon.rect().translated(x, y)
         if tickRect.contains(event.pos()):
             self.tickClicked.emit()
         if closeRect.contains(event.pos()):

easycoder/ec_classes.py

@@ -1,6 +1,6 @@
 import sys
 
-class FatalError:
+class FatalError(BaseException):
 	def __init__(self, compiler, message):
 		compiler.showWarnings()
 		lino = compiler.tokens[compiler.index].lino
@@ -58,4 +58,9 @@ class Token:
 		self.token = token
 	
 class Object():
-    pass
+    """Dynamic object that allows arbitrary attribute assignment"""
+    def __setattr__(self, name: str, value) -> None:
+        self.__dict__[name] = value
+    
+    def __getattr__(self, name: str):
+        return self.__dict__.get(name)

easycoder/ec_compiler.py

@@ -18,9 +18,11 @@ class Compiler:
 		self.debugCompile = False
 		self.valueTypes = {}
 
-	def getPC(self):
+	# Get the current code size. Used during compilation
+	def getCodeSize(self):
 		return len(self.program.code)
 
+	# Get the current index (the program counter)
 	def getIndex(self):
 		return self.index
 
@@ -39,6 +41,7 @@ class Compiler:
 		self.index += 1
 		return self.getToken()
 
+	# Peek ahead to see the next token without advancing the index
 	def peek(self):
 		try:
 			return self.tokens[self.index + 1].token
@@ -68,19 +71,24 @@ class Compiler:
 		self.index += 1
 		return self.condition.compileCondition()
 
+	# Test if the current token has a specified value
 	def tokenIs(self, value):
 		return self.getToken() == value
 
+	# Test if the next token has the specified value
 	def nextIs(self, value):
 		return self.nextToken() == value
 
+	# Get the command at a given pc in the code list
 	def getCommandAt(self, pc):
 		return self.program.code[pc]
 
 	# Add a command to the code list
 	def addCommand(self, command):
+		command['bp'] = False
 		self.code.append(command)
 
+	# Test if the current token is a symbol
 	def isSymbol(self):
 		token = self.getToken()
 		try:
@@ -89,10 +97,12 @@ class Compiler:
 			return False
 		return True
 
+	# Test if the next token is a symbol
 	def nextIsSymbol(self):
 		self.next()
 		return self.isSymbol()
 	
+	# Skip the next token if it matches the value given
 	def skip(self, token):
 		next = self.peek()
 		if type(token) == list:
@@ -102,21 +112,26 @@ class Compiler:
 					return
 		elif next == token: self.nextToken()
 
+	# Rewind to a given position in the code list
 	def rewindTo(self, index):
 		self.index = index
 
+	# Get source line number containing the current token
 	def getLino(self):
 		if self.index >= len(self.tokens):
 			return 0
 		return self.tokens[self.index].lino
 
+	# Issue a warning
 	def warning(self, message):
 		self.warnings.append(f'Warning at line {self.getLino() + 1} of {self.program.name}: {message}')
 
+	# Print all warnings
 	def showWarnings(self):
 		for warning in self.warnings:
 			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:
@@ -128,18 +143,23 @@ class Compiler:
 		symbolRecord['used'] = True
 		return symbolRecord
 
+	# Add a value type
 	def addValueType(self):
 		self.valueTypes[self.getToken()] = 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())
 
+	# Compile a variable
 	def compileVariable(self, command, extra=None):
 		return self.compileSymbol(command, self.nextToken(), extra)
 
+	# Compile a symbol
 	def compileSymbol(self, command, name, extra=None):
 		try:
 			v = self.symbols[name]
@@ -148,7 +168,7 @@ class Compiler:
 		if v:
 			FatalError(self, f'Duplicate symbol name "{name}"')
 			return False
-		self.symbols[name] = self.getPC()
+		self.symbols[name] = self.getCodeSize()
 		command['program'] = self.program
 		command['type'] = 'symbol'
 		command['name'] = name
@@ -172,7 +192,7 @@ class Compiler:
 		if not token:
 			return False
 		if len(self.code) == 0:
-			if self.program.parent == None and hasattr(self.program, 'usingGraphics'):
+			if self.program.parent == None and self.program.usingGraphics:
 				cmd = {'domain': 'graphics', 'keyword': 'init', 'debug': False}
 				self.code.append(cmd)
 		mark = self.getIndex()
@@ -199,7 +219,7 @@ class Compiler:
 		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
@@ -225,8 +245,10 @@ class Compiler:
 			else:
 				return False
 
+	# Compile fom the current location, stopping on any of a list of tokens
 	def compileFromHere(self, stopOn):
 		return self.compileFrom(self.getIndex(), stopOn)
 
+	# Compile from the start of the script
 	def compileFromStart(self):
 		return self.compileFrom(0, [])

easycoder/ec_core.py

@@ -31,13 +31,13 @@ class Core(Handler):
             cmd['keyword'] = 'gotoPC'
             cmd['goto'] = 0
             cmd['debug'] = False
-            skip = self.getPC()
+            skip = self.getCodeSize()
             self.add(cmd)
             # Process the 'or'
-            self.getCommandAt(orHere)['or'] = self.getPC()
+            self.getCommandAt(orHere)['or'] = self.getCodeSize()
             self.compileOne()
             # Fixup the skip
-            self.getCommandAt(skip)['goto'] = self.getPC()
+            self.getCommandAt(skip)['goto'] = self.getCodeSize()
 
     #############################################################################
     # Keyword handlers
@@ -468,7 +468,7 @@ class Core(Handler):
                 if url != None:
                     command['url'] = url
                     command['or'] = None
-                    get = self.getPC()
+                    get = self.getCodeSize()
                     if self.peek() == 'timeout':
                         self.nextToken()
                         command['timeout'] = self.nextValue()
@@ -556,7 +556,7 @@ class Core(Handler):
         command['condition'] = self.nextCondition()
         self.add(command)
         self.nextToken()
-        pcElse = self.getPC()
+        pcElse = self.getCodeSize()
         cmd = {}
         cmd['lino'] = command['lino']
         cmd['domain'] = 'core'
@@ -569,7 +569,7 @@ class Core(Handler):
         if self.peek() == 'else':
             self.nextToken()
             # Add a 'goto' to skip the 'else'
-            pcNext = self.getPC()
+            pcNext = self.getCodeSize()
             cmd = {}
             cmd['lino'] = command['lino']
             cmd['domain'] = 'core'
@@ -578,15 +578,15 @@ class Core(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the link to the 'else' branch
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
+            self.getCommandAt(pcElse)['goto'] = self.getCodeSize()
             # Process the 'else' branch
             self.nextToken()
             self.compileOne()
             # Fixup the pcNext 'goto'
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            self.getCommandAt(pcNext)['goto'] = self.getCodeSize()
         else:
             # We're already at the next command
-            self.getCommandAt(pcElse)['goto'] = self.getPC()
+            self.getCommandAt(pcElse)['goto'] = self.getCodeSize()
         return True
 
     def r_if(self, command):
@@ -605,7 +605,7 @@ class Core(Handler):
             name = self.nextToken()
             item = [keyword, name]
             imports.append(item)
-            self.symbols[name] = self.getPC()
+            self.symbols[name] = self.getCodeSize()
             variable = {}
             variable['domain'] = None
             variable['name'] = name
@@ -747,7 +747,7 @@ class Core(Handler):
                     else:
                         command['file'] = self.getValue()
                     command['or'] = None
-                    load = self.getPC()
+                    load = self.getCodeSize()
                     self.processOr(command, load)
                     return True
         else:
@@ -916,7 +916,7 @@ class Core(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the link
-            command['goto'] = self.getPC()
+            command['goto'] = self.getCodeSize()
             return True
         return False
 
@@ -1007,7 +1007,7 @@ class Core(Handler):
         else:
             command['result'] = None
         command['or'] = None
-        post = self.getPC()
+        post = self.getCodeSize()
         self.processOr(command, post)
         return True
 
@@ -1106,7 +1106,7 @@ class Core(Handler):
                         FatalError(self.compiler, f'Symbol {symbolRecord["name"]} is not a value holder')
                     else:
                         command['or'] = None
-                        self.processOr(command, self.getPC())
+                        self.processOr(command, self.getCodeSize())
                         return True
                 else:
                     FatalError(self.compiler, f'Symbol {self.getToken()} is not a variable')
@@ -1274,7 +1274,7 @@ class Core(Handler):
         else:
             command['file'] = self.getValue()
         command['or'] = None
-        save = self.getPC()
+        save = self.getCodeSize()
         self.processOr(command, save)
         return True
 
@@ -1771,15 +1771,8 @@ class Core(Handler):
             return False
         else:
             token = self.nextToken()
-            if token in ['graphics', 'debugger']:
-                if not hasattr(self.program, 'usingGraphics'):
-                    print('Loading graphics module')
-                    from .ec_pyside import Graphics
-                    self.program.graphics = Graphics
-                    self.program.useClass(Graphics)
-                    self.program.usingGraphics = True
-                if token == 'debugger': self.program.debugging = True
-                return True
+            if token == 'graphics':
+                return self.program.useGraphics()
         return False
 
     # Declare a general-purpose variable
@@ -1823,10 +1816,10 @@ class Core(Handler):
             return None
         # token = self.getToken()
         command['condition'] = code
-        test = self.getPC()
+        test = self.getCodeSize()
         self.add(command)
         # Set up a goto for when the test fails
-        fail = self.getPC()
+        fail = self.getCodeSize()
         cmd = {}
         cmd['lino'] = command['lino']
         cmd['domain'] = 'core'
@@ -1847,7 +1840,7 @@ class Core(Handler):
         cmd['debug'] = False
         self.add(cmd)
         # Fixup the 'goto' on completion
-        self.getCommandAt(fail)['goto'] = self.getPC()
+        self.getCommandAt(fail)['goto'] = self.getCodeSize()
         return True
 
     def r_while(self, command):