easycoder 251103.2__py2.py3-none-any.whl → 251104.2__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.2"
+__version__ = "251104.2"

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

@@ -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
 
@@ -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,22 +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):
-		if len(self.code) == 0:
-			if self.program.usingGraphics:
-				pass
+		command['bp'] = False
 		self.code.append(command)
 
+	# Test if the current token is a symbol
 	def isSymbol(self):
 		token = self.getToken()
 		try:
@@ -92,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:
@@ -105,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:
@@ -131,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]
@@ -151,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
@@ -174,6 +191,10 @@ class Compiler:
 #		print(f'Compile {token}')
 		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}
+				self.code.append(cmd)
 		mark = self.getIndex()
 		for domain in self.program.getDomains():
 			handler = domain.keywordHandler(token)
@@ -198,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
@@ -224,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
 
@@ -1772,7 +1772,7 @@ class Core(Handler):
         else:
             token = self.nextToken()
             if token in ['graphics', 'debugger']:
-                if not hasattr(self.program, 'usingGraphics'):
+                if not self.program.usingGraphics:
                     print('Loading graphics module')
                     from .ec_pyside import Graphics
                     self.program.graphics = Graphics
@@ -1823,10 +1823,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 +1847,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):

easycoder/ec_debug.py

@@ -0,0 +1,464 @@
+import sys, os, json, html
+from PySide6.QtWidgets import (
+    QMainWindow,
+    QWidget,
+    QFrame,
+    QHBoxLayout,
+    QVBoxLayout,
+    QLabel,
+    QSplitter,
+    QFileDialog,
+    QMessageBox,
+    QScrollArea,
+    QSizePolicy,
+    QToolBar
+)
+from PySide6.QtGui import QAction, QKeySequence, QTextCursor
+from PySide6.QtCore import Qt, QTimer, QProcess
+from typing import Any
+
+class Object():
+    """Dynamic object that allows arbitrary attribute assignment"""
+    def __setattr__(self, name: str, value: Any) -> None:
+        self.__dict__[name] = value
+    
+    def __getattr__(self, name: str) -> Any:
+        return self.__dict__.get(name)
+
+class Debugger(QMainWindow):
+
+    ###########################################################################
+    # The left-hand column of the main window
+    class MainLeftColumn(QWidget):
+        def __init__(self, parent=None):
+            super().__init__(parent)
+            layout = QVBoxLayout(self)
+            layout.addWidget(QLabel("Left column"))
+            layout.addStretch()
+    
+    ###########################################################################
+    # The right-hand column of the main window
+    class MainRightColumn(QWidget):
+        scroll: QScrollArea
+        layout: QHBoxLayout  # type: ignore[assignment]
+        blob: QLabel
+        
+        def __init__(self, parent=None):
+            super().__init__(parent)
+
+            # Create a scroll area - its content widget holds the lines
+            self.scroll = QScrollArea(self)
+            self.scroll.setWidgetResizable(True)
+
+            # Ensure this widget and the scroll area expand to fill available space
+            self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+            self.scroll.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+            self.content = QWidget()
+            # let the content expand horizontally but have flexible height
+            self.content.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
+
+            self.inner_layout = QVBoxLayout(self.content)
+            # spacing and small top/bottom margins to separate lines
+            self.inner_layout.setSpacing(0)
+            self.inner_layout.setContentsMargins(0, 0, 0, 0)
+
+            self.scroll.setWidget(self.content)
+
+            # outer layout for this widget contains only the scroll area
+            main_layout = QVBoxLayout(self)
+            main_layout.setContentsMargins(0, 0, 0, 0)
+            main_layout.addWidget(self.scroll)
+            # ensure the scroll area gets the stretch so it fills the parent
+            main_layout.setStretch(0, 1)
+
+        #######################################################################
+        # Add a line to the right-hand column
+        def addLine(self, spec):
+            class Label(QLabel):
+                def __init__(self, text, fixed_width=None, align=Qt.AlignmentFlag.AlignLeft, on_click=spec.onClick):
+                    super().__init__()
+                    self.setText(text)
+                    # remove QLabel's internal margins/padding to reduce top/bottom space
+                    self.setMargin(0)
+                    self.setContentsMargins(0, 0, 0, 0)
+                    self.setStyleSheet("padding:0px; margin:0px; font-family: mono")
+                    fm = self.fontMetrics()
+                    # set a compact fixed height based on font metrics
+                    self.setFixedHeight(fm.height())
+                    # optional fixed width (used for the lino column)
+                    if fixed_width is not None:
+                        self.setFixedWidth(fixed_width)
+                    # align horizontally (keep vertically centered)
+                    self.setAlignment(align | Qt.AlignmentFlag.AlignVCenter)
+                    # optional click callback
+                    self._on_click = on_click
+
+                def mousePressEvent(self, event):
+                    if self._on_click:
+                        try:
+                            self._on_click()
+                        except Exception:
+                            pass
+                    super().mousePressEvent(event)
+
+            spec.label = self
+            panel = QWidget()
+            # ensure the panel itself has no margins
+            try:
+                panel.setContentsMargins(0, 0, 0, 0)
+            except Exception:
+                pass
+            # tidy layout: remove spacing/margins so lines sit flush
+            layout = QHBoxLayout(panel)
+            layout.setSpacing(0)
+            layout.setContentsMargins(0, 0, 0, 0)
+            self.layout: QHBoxLayout = layout  # type: ignore
+            # make panel take minimal vertical space
+            panel.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+            # compute width to fit a 4-digit line number using this widget's font
+            fm_main = self.fontMetrics()
+            width_4 = fm_main.horizontalAdvance('0000') + 8
+
+            # create the red blob (always present). We'll toggle its opacity
+            # by changing the stylesheet (rgba alpha 255/0). Do NOT store it
+            # on the MainRightColumn instance — keep it per-line.
+            blob = QLabel()
+            blob_size = 10
+            blob.setFixedSize(blob_size, blob_size)
+
+            def set_blob_visible(widget, visible):
+                alpha = 255 if visible else 0
+                widget.setStyleSheet(f"background-color: rgba(255,0,0,{alpha}); border-radius: {blob_size//2}px; margin:0px; padding:0px;")
+                widget._blob_visible = visible
+                # force repaint
+                widget.update()
+
+            # attach methods to this blob so callers can toggle it via spec.label
+            blob.showBlob = lambda: set_blob_visible(blob, True)  # type: ignore[attr-defined]
+            blob.hideBlob = lambda: set_blob_visible(blob, False)  # type: ignore[attr-defined]
+
+            # initialize according to spec flag
+            if spec.bp:
+                blob.showBlob()  # type: ignore[attr-defined]
+            else:
+                blob.hideBlob()  # type: ignore[attr-defined]
+
+            # expose the blob to the outside via spec['label'] so onClick can call showBlob/hideBlob
+            spec.label = blob
+
+            # create the line-number label; clicking it reports back to the caller
+            lino_label = Label(str(spec.lino+1), fixed_width=width_4, align=Qt.AlignmentFlag.AlignRight,
+                               on_click=lambda: spec.onClick(spec.lino))
+            lino_label.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+            # create the text label for the line itself
+            text_label = Label(spec.line, fixed_width=None, align=Qt.AlignmentFlag.AlignLeft)
+            text_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+            layout.addWidget(lino_label)
+            layout.addSpacing(10)
+            layout.addWidget(blob, 0, Qt.AlignmentFlag.AlignVCenter)
+            layout.addSpacing(3)
+            layout.addWidget(text_label)
+            self.inner_layout.addWidget(panel)
+            return panel
+        
+        def showBlob(self):
+            self.blob.setStyleSheet("background-color: red; border-radius: 5px; margin:0px; padding:0px;")
+        
+        def hideBlob(self):
+            self.blob.setStyleSheet("background-color: none; border-radius: 5px; margin:0px; padding:0px;")
+        
+        def addStretch(self):
+            self.layout.addStretch()
+
+    ###########################################################################
+    # Main debugger class initializer
+    def __init__(self, program, width=800, height=600, ratio=0.2):
+        super().__init__()
+        self.program = program
+        self.setWindowTitle("EasyCoder Debugger")
+        self.setMinimumSize(width, height)
+        self.stopped = True
+
+        # try to load saved geometry from ~/.ecdebug.conf
+        cfg_path = os.path.join(os.path.expanduser("~"), ".ecdebug.conf")
+        initial_width = width
+        # default console height (pixels) if not stored in cfg
+        console_height = 150
+        try:
+            if os.path.exists(cfg_path):
+                with open(cfg_path, "r", encoding="utf-8") as f:
+                    cfg = json.load(f)
+                x = int(cfg.get("x", 0))
+                y = int(cfg.get("y", 0))
+                w = int(cfg.get("width", width))
+                h = int(cfg.get("height", height))
+                ratio =float(cfg.get("ratio", ratio))
+                # load console height if present
+                console_height = int(cfg.get("console_height", console_height))
+                # Apply loaded geometry
+                self.setGeometry(x, y, w, h)
+                initial_width = w
+        except Exception:
+            # ignore errors and continue with defaults
+            initial_width = width
+
+        # process handle for running scripts
+        self._proc = None
+        # in-process Program instance and writer
+        self._program = None
+        self._writer = None
+        self._orig_stdout = None
+        self._orig_stderr = None
+        self._flush_timer = None
+
+        # Keep a ratio so proportions are preserved when window is resized
+        self.ratio = ratio
+
+        # Central horizontal splitter (left/right)
+        self.hsplitter = QSplitter(Qt.Orientation.Horizontal, self)
+        self.hsplitter.setHandleWidth(8)
+        self.hsplitter.splitterMoved.connect(self.on_splitter_moved)
+
+        # Left pane
+        left = QFrame()
+        left.setFrameShape(QFrame.Shape.StyledPanel)
+        left_layout = QVBoxLayout(left)
+        left_layout.setContentsMargins(8, 8, 8, 8)
+        self.leftColumn = self.MainLeftColumn()
+        left_layout.addWidget(self.leftColumn)
+        left_layout.addStretch()
+
+        # Right pane
+        right = QFrame()
+        right.setFrameShape(QFrame.Shape.StyledPanel)
+        right_layout = QVBoxLayout(right)
+        right_layout.setContentsMargins(8, 8, 8, 8)
+        self.rightColumn = self.MainRightColumn()
+        # Give the rightColumn a stretch factor so its scroll area fills the vertical space
+        right_layout.addWidget(self.rightColumn, 1)
+
+        # Add panes to horizontal splitter
+        self.hsplitter.addWidget(left)
+        self.hsplitter.addWidget(right)
+
+        # Initial sizes (proportional) for horizontal splitter
+        total = initial_width
+        self.hsplitter.setSizes([int(self.ratio * total), int((1 - self.ratio) * total)])
+
+        # Create a vertical splitter so we can add a resizable console panel at the bottom
+        self.vsplitter = QSplitter(Qt.Orientation.Vertical, self)
+        self.vsplitter.setHandleWidth(6)
+        # top: the existing horizontal splitter
+        self.vsplitter.addWidget(self.hsplitter)
+
+        # bottom: console panel
+        console_frame = QFrame()
+        console_frame.setFrameShape(QFrame.Shape.StyledPanel)
+        console_layout = QVBoxLayout(console_frame)
+        console_layout.setContentsMargins(4, 4, 4, 4)
+        # simple read-only text console for script output and messages
+        from PySide6.QtWidgets import QTextEdit
+        self.console = QTextEdit()
+        self.console.setReadOnly(True)
+        console_layout.addWidget(self.console)
+        self.vsplitter.addWidget(console_frame)
+
+        # Set initial vertical sizes: prefer saved console_height if available
+        try:
+            total_h = int(h) if 'h' in locals() else max(300, self.height())
+            ch = max(50, min(total_h - 50, console_height))
+            self.vsplitter.setSizes([int(total_h - ch), int(ch)])
+        except Exception:
+            pass
+
+        # Use the vertical splitter as the central widget
+        self.setCentralWidget(self.vsplitter)
+        self.parse(program.script.lines)
+        self.show()
+
+    def on_splitter_moved(self, pos, index):
+        # Update stored ratio when user drags the splitter
+        left_width = self.hsplitter.widget(0).width()
+        total = max(1, sum(w.width() for w in (self.hsplitter.widget(0), self.hsplitter.widget(1))))
+        self.ratio = left_width / total
+
+    def resizeEvent(self, event):
+        # Preserve the proportional widths when the window is resized
+        total_width = max(1, self.width())
+        left_w = max(0, int(self.ratio * total_width))
+        right_w = max(0, total_width - left_w)
+        self.hsplitter.setSizes([left_w, right_w])
+        super().resizeEvent(event)
+
+    ###########################################################################
+    # Parse a script into the right-hand column
+    def parse(self, script):
+        self.scriptLines = []
+        # Clear existing lines from the right column layout
+        layout = self.rightColumn.inner_layout
+        while layout.count():
+            item = layout.takeAt(0)
+            widget = item.widget()
+            if widget:
+                widget.deleteLater()
+
+        # Parse and add new lines
+        lino = 0
+        for line in script:
+            if len(line) > 0:
+                line = line.replace("\t", "   ")
+                line = self.coloriseLine(line, lino)
+            else:
+                # still need to call coloriseLine to keep token list in sync
+                self.coloriseLine(line, lino)
+            lineSpec = Object()
+            lineSpec.lino = lino
+            lineSpec.line = line
+            lineSpec.bp = False
+            lineSpec.onClick = self.onClickLino
+            lino += 1
+            self.scriptLines.append(lineSpec)
+            lineSpec.panel = self.rightColumn.addLine(lineSpec)
+        self.rightColumn.addStretch()
+    
+    ###########################################################################
+    # Colorise a line of script for HTML display
+    def coloriseLine(self, line, lino=None):
+        output = ''
+
+        # Preserve leading spaces (render as   except the first)
+        if len(line) > 0 and line[0] == ' ':
+            output += '<span>'
+            n = 0
+            while n < len(line) and line[n] == ' ': n += 1
+            output += '&nbsp;' * (n - 1)
+            output += '</span>'
+
+        # Find the first unquoted ! (not inside backticks)
+        comment_start = None
+        in_backtick = False
+        for idx, c in enumerate(line):
+            if c == '`':
+                in_backtick = not in_backtick
+            elif c == '!' and not in_backtick:
+                comment_start = idx
+                break
+
+        if comment_start is not None:
+            code_part = line[:comment_start]
+            comment_part = line[comment_start:]
+        else:
+            code_part = line
+            comment_part = None
+
+        # Tokenize code_part as before (respecting backticks)
+        tokens = []
+        i = 0
+        L = len(code_part)
+        while i < L:
+            if code_part[i].isspace():
+                i += 1
+                continue
+            if code_part[i] == '`':
+                j = code_part.find('`', i + 1)
+                if j == -1:
+                    tokens.append(code_part[i:])
+                    break
+                else:
+                    tokens.append(code_part[i:j+1])
+                    i = j + 1
+            else:
+                j = i
+                while j < L and not code_part[j].isspace():
+                    j += 1
+                tokens.append(code_part[i:j])
+                i = j
+
+        # Colour code tokens and generate a list of elements
+        for token in tokens:
+            if token == '':
+                continue
+            elif token[0].isupper():
+                esc = html.escape(token)
+                element = f'&nbsp;<span style="color: purple; font-weight: bold;">{esc}</span>'
+            elif token[0].isdigit():
+                esc = html.escape(token)
+                element = f'&nbsp;<span style="color: green;">{esc}</span>'
+            elif token[0] == '`':
+                esc = html.escape(token)
+                element = f'&nbsp;<span style="color: peru;">{esc}</span>'
+            else:
+                esc = html.escape(token)
+                element = f'&nbsp;<span>{esc}</span>'
+            output += element
+        # Colour comment if present
+        if comment_part is not None:
+            esc = html.escape(comment_part)
+            output += f'<span style="color: green;">&nbsp;{esc}</span>'
+
+        return output
+    
+    ###########################################################################
+    # Here when the user clicks a line number
+    def onClickLino(self, lino):
+        lineSpec = self.scriptLines[lino]
+        lineSpec.bp = not lineSpec.bp
+        if lineSpec.bp: lineSpec.label.showBlob()
+        else: lineSpec.label.hideBlob()
+        # Set a breakpoint on this command
+        command = self.program.code[self.program.pc]
+        command['bp'] = True
+        self.program.code[self.program.pc] = command
+    
+    ###########################################################################
+    # Scroll to a given line number
+    def scrollTo(self, lino):
+        # Ensure the line number is valid
+        if lino < 0 or lino >= len(self.scriptLines):
+            return
+        
+        # Get the panel widget for this line
+        lineSpec = self.scriptLines[lino]
+        panel = lineSpec.panel
+        
+        if not panel:
+            return
+        
+        # Get the scroll area from the right column
+        scroll_area = self.rightColumn.scroll
+        
+        # Get the vertical position of the panel relative to the content widget
+        panel_y = panel.y()
+        panel_height = panel.height()
+        
+        # Get the viewport height (visible area)
+        viewport_height = scroll_area.viewport().height()
+        
+        # Calculate the target scroll position to center the panel
+        # We want the panel's center to align with the viewport's center
+        target_scroll = panel_y + (panel_height // 2) - (viewport_height // 2)
+        
+        # Clamp to valid scroll range
+        scrollbar = scroll_area.verticalScrollBar()
+        target_scroll = max(scrollbar.minimum(), min(target_scroll, scrollbar.maximum()))
+        
+        # Smoothly scroll to the target position
+        scrollbar.setValue(target_scroll)
+        
+        # Bring the window to the front
+        self.raise_()
+        self.activateWindow()
+    
+    ###########################################################################
+    # Here when each instruction is about to run
+    def step(self):
+        if self.stopped:
+            lino=self.program.code[self.program.pc]['lino']
+            print(lino)
+            self.scrollTo(lino)
+            return False
+        else:
+            if self.program.code[self.program.pc]['bp']:
+                pass
+        return True

easycoder/ec_handler.py

@@ -22,7 +22,7 @@ class Handler:
 		self.compileVariable = compiler.compileVariable
 		self.rewindTo = compiler.rewindTo
 		self.warning = compiler.warning
-		self.getPC = compiler.getPC
+		self.getCodeSize = compiler.getCodeSize
 		self.add = compiler.addCommand
 		self.getCommandAt = compiler.getCommandAt
 		self.compileOne = compiler.compileOne

easycoder/ec_program.py

@@ -47,6 +47,9 @@ class Program:
 		self.useClass(Core)
 		self.externalControl = False
 		self.ticker = 0
+		self.usingGraphics = False
+		self.debugging = False
+		self.debugger = None
 		self.running = True
 
 	# This is called at 10msec intervals by the GUI code
@@ -147,8 +150,9 @@ class Program:
 			name = value['name']
 			symbolRecord = self.getSymbolRecord(name)
 			# if symbolRecord['hasValue']:
-			handler = self.domainIndex[symbolRecord['domain']].valueHandler('symbol')
-			result = handler(symbolRecord)
+			if symbolRecord:
+				handler = self.domainIndex[symbolRecord['domain']].valueHandler('symbol')
+				result = handler(symbolRecord)
 		# 	else:
 		# 		# Call the given domain to handle a value
 		# 		# domain = self.domainIndex[value['domain']]
@@ -181,7 +185,10 @@ class Program:
 		return None
 
 	def getValue(self, value):
-		return self.evaluate(value).content
+		result = self.evaluate(value)
+		if result:
+			return result.get('content')  # type: ignore[union-attr]
+		return None
 
 	def getRuntimeValue(self, value):
 		if value is None:
@@ -287,9 +294,9 @@ class Program:
 		return
 
 	def releaseParent(self):
-		if self.parent.waiting and self.parent.program.running:
-			self.parent.waiting = False
-			self.parent.program.run(self.parent.pc)
+		if self.parent and self.parent.waiting and self.parent.program.running:  # type: ignore[union-attr]
+			self.parent.waiting = False  # type: ignore[union-attr]
+			self.parent.program.run(self.parent.pc)  # type: ignore[union-attr]
 
 	# Flush the queue
 	def flush(self, pc):
@@ -306,6 +313,8 @@ class Program:
 					lino = command['lino'] + 1
 					line = self.script.lines[command['lino']].strip()
 					print(f'{self.name}: Line {lino}: {domainName}:{keyword}:  {line}')
+				if self.debugger != None:
+					self.debugger.step()
 				domain = self.domainIndex[domainName]
 				handler = domain.runHandler(keyword)
 				if handler:
@@ -378,9 +387,9 @@ class Program:
 		if type(v2) == int:
 			if type(v1) != int:
 				v2 = f'{v2}'
-		if v1 > v2:
+		if v1 > v2:  # type: ignore[operator]
 			return 1
-		if v1 < v2:
+		if v1 < v2:  # type: ignore[operator]
 			return -1
 		return 0
 

easycoder/ec_pyside.py

@@ -3,6 +3,7 @@ from functools import partial
 from .ec_handler import Handler
 from .ec_classes import RuntimeError, Object
 from .ec_border import Border
+from .ec_debug import Debugger
 from PySide6.QtCore import Qt, QTimer, Signal, QRect
 from PySide6.QtGui import QPixmap, QPainter
 from PySide6.QtWidgets import (
@@ -835,12 +836,7 @@ class Graphics(Handler):
         return self.nextPC()
 
     # Initialize the graphics environment
-    def k_init(self, command):
-        # return True
-        if self.nextIs('graphics'):
-            self.add(command)
-            return True
-        return False
+    # Unused: def k_init(self, command):
     
     def r_init(self, command):
         self.app = QApplication(sys.argv)
@@ -862,6 +858,7 @@ class Graphics(Handler):
         timer.timeout.connect(flush)
         timer.start(10)
         QTimer.singleShot(500, init)
+        if self.program.debugging: self.program.debugger = Debugger(self.program)
         self.app.lastWindowClosed.connect(on_last_window_closed)
         self.app.exec()
 
@@ -912,11 +909,11 @@ class Graphics(Handler):
     # on tick
     def k_on(self, command):
         def setupOn():
-            command['goto'] = self.getPC() + 2
+            command['goto'] = self.getCodeSize() + 2
             self.add(command)
             self.nextToken()
             # Step over the click handler
-            pcNext = self.getPC()
+            pcNext = self.getCodeSize()
             cmd = {}
             cmd['domain'] = 'core'
             cmd['lino'] = command['lino']
@@ -933,7 +930,7 @@ class Graphics(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the goto
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            self.getCommandAt(pcNext)['goto'] = self.getCodeSize()
 
         token = self.nextToken()
         command['type'] = token
@@ -953,11 +950,11 @@ class Graphics(Handler):
                     return True
         elif token == 'tick':
             command['tick'] = True
-            command['runOnTick'] = self.getPC() + 2
+            command['runOnTick'] = self.getCodeSize() + 2
             self.add(command)
             self.nextToken()
             # Step over the on tick action
-            pcNext = self.getPC()
+            pcNext = self.getCodeSize()
             cmd = {}
             cmd['domain'] = 'core'
             cmd['lino'] = command['lino']
@@ -974,7 +971,7 @@ class Graphics(Handler):
             cmd['debug'] = False
             self.add(cmd)
             # Fixup the goto
-            self.getCommandAt(pcNext)['goto'] = self.getPC()
+            self.getCommandAt(pcNext)['goto'] = self.getCodeSize()
             return True
         return False
     

{easycoder-251103.2.dist-info → easycoder-251104.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easycoder
-Version: 251103.2
+Version: 251104.2
 Summary: Rapid scripting in English
 Keywords: compiler,scripting,prototyping,programming,coding,python,low code,hypertalk,computer language,learn to code
 Author-email: Graham Trott <gtanyware@gmail.com>

easycoder-251104.2.dist-info/RECORD

@@ -0,0 +1,20 @@
+easycoder/__init__.py,sha256=MRZ5qqYf7XUeRfrculBoOmXvlayyAdVqU7wI5n47Bqs,339
+easycoder/close.png,sha256=3B9ueRNtEu9E4QNmZhdyC4VL6uqKvGmdfeFxIV9aO_Y,9847
+easycoder/ec_border.py,sha256=KpOy0Jq8jI_6DYGo4jaFvoBP_jTIoAYWrmuHhl-FXA4,2355
+easycoder/ec_classes.py,sha256=EWpB3Wta_jvKZ8SNIWua_ElIbw1FzKMyM3_IiXBn-lg,1995
+easycoder/ec_compiler.py,sha256=Q6a9nMmZogJzHu8OB4VeMzmBBarVEl3-RkqH2gW4LiU,6599
+easycoder/ec_condition.py,sha256=uamZrlW3Ej3R4bPDuduGB2f00M80Z1D0qV8muDx4Qfw,784
+easycoder/ec_core.py,sha256=F8MQ1dJfzQoYxTrCyJ7aUrmyxjQEW4dmWd9uq71rR0w,100876
+easycoder/ec_debug.py,sha256=JrF8GDzymB2YCOuULtlot4jO1yiVEbt_hQqjZPDcPEI,18785
+easycoder/ec_handler.py,sha256=doGCMXBCQxvSaD3omKMlXoR_LvQODxV7dZyoWafecyg,2336
+easycoder/ec_keyboard.py,sha256=H8DhPT8-IvAIGgRxCs4qSaF_AQLaS6lxxtDteejbktM,19010
+easycoder/ec_program.py,sha256=biRWYKUs7ywFEgTte0oerTyPxgZlP4odfv_xJAN7ao8,10696
+easycoder/ec_pyside.py,sha256=WDzJn64fPKMJCwTBXjngCRkJyS4fA72FmwfUoqul-Hw,58400
+easycoder/ec_timestamp.py,sha256=myQnnF-mT31_1dpQKv2VEAu4BCcbypvMdzq7_DUi1xc,277
+easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
+easycoder/tick.png,sha256=OedASXJJTYvnza4J6Kv5m5lz6DrBfy667zX_WGgtbmM,9127
+easycoder-251104.2.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
+easycoder-251104.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+easycoder-251104.2.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
+easycoder-251104.2.dist-info/METADATA,sha256=SFh8m9keUUTbvuC0q4R3n7lCuBA_whA4Q2Pt8s1EMWc,6897
+easycoder-251104.2.dist-info/RECORD,,

easycoder-251103.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-easycoder/__init__.py,sha256=Lcn-X3_bWT1Leeh_wHMEaDuMq_A2Zm4GWMxwo3Ko7qI,339
-easycoder/close.png,sha256=3B9ueRNtEu9E4QNmZhdyC4VL6uqKvGmdfeFxIV9aO_Y,9847
-easycoder/ec_border.py,sha256=KpOy0Jq8jI_6DYGo4jaFvoBP_jTIoAYWrmuHhl-FXA4,2355
-easycoder/ec_classes.py,sha256=YGUiKnVN6T5scoeBmmGDQAtE8xJgaTHi0Exh9A7H2Y4,1750
-easycoder/ec_compiler.py,sha256=ZtI40G7GTkCeOYMx66TmU_SwauoktAPW3njhFWESK6k,5505
-easycoder/ec_condition.py,sha256=uamZrlW3Ej3R4bPDuduGB2f00M80Z1D0qV8muDx4Qfw,784
-easycoder/ec_core.py,sha256=c51wdwTwppZwGLOhN22SBCdAmnTFQw0eirMJxkOb8vI,100780
-easycoder/ec_handler.py,sha256=zEZ5cPruEVZp3SIQ6ZjdZN5jDyW2gFvHcNmFaet4Sd4,2324
-easycoder/ec_keyboard.py,sha256=H8DhPT8-IvAIGgRxCs4qSaF_AQLaS6lxxtDteejbktM,19010
-easycoder/ec_program.py,sha256=aPuZOYWFqGd1jsLDl5M5YmLu5LfFAewF9EZh6zHIbyM,10308
-easycoder/ec_pyside.py,sha256=Pkf0lgDTgC7WOjjleiGeBj4e9y9de4DDNlZFsajkVjU,58374
-easycoder/ec_timestamp.py,sha256=myQnnF-mT31_1dpQKv2VEAu4BCcbypvMdzq7_DUi1xc,277
-easycoder/ec_value.py,sha256=zgDJTJhIg3yOvmnnKIfccIizmIhGbtvL_ghLTL1T5fg,2516
-easycoder/tick.png,sha256=OedASXJJTYvnza4J6Kv5m5lz6DrBfy667zX_WGgtbmM,9127
-easycoder-251103.2.dist-info/entry_points.txt,sha256=JXAZbenl0TnsIft2FcGJbJ-4qoztVu2FuT8PFmWFexM,44
-easycoder-251103.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-easycoder-251103.2.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
-easycoder-251103.2.dist-info/METADATA,sha256=OntVjUUCq5GZxKP5eSqo8iKBG4WTL0tQ5ocEge4Pzbc,6897
-easycoder-251103.2.dist-info/RECORD,,