rising-sse 0.1.dev0__tar.gz

rising_sse-0.1.dev0/.gitignore

@@ -0,0 +1,2 @@
+# Created by venv; see https://docs.python.org/3/library/venv.html
+*

rising_sse-0.1.dev0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: rising-sse
+Version: 0.1.dev0
+Summary: The base interpreter and mode system for semantic syntax
+Author-email: rising <risingwanabe@gmail.com>
+Maintainer-email: rising <risingwanabe@gmail.com>
+Requires-Dist: lark

rising_sse-0.1.dev0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "rising-sse"
+version = "0.1dev"
+description = "The base interpreter and mode system for semantic syntax"
+authors = [
+  { name = "rising", email = "risingwanabe@gmail.com" },
+]
+maintainers = [
+  { name = "rising", email = "risingwanabe@gmail.com" },
+]
+dependencies = ["lark"]
+
+[tool.hatch.envs.stretch]
+type = "virtual"
+path = ".stretch"
+dependencies = ["requests", "lark"]
+
+[tool.hatch.build]
+include = ["sse"]
+
+[tool.hatch.version]
+#[project.scripts]
+

rising_sse-0.1.dev0/sse/__init__.py

@@ -0,0 +1,17 @@
+from .engine import Engine, run
+from .mode import Mode, GetMode, primitive, prompt
+
+def basic_engine():
+    """
+        call this function if you just want to play around with the base form of the engine
+    without modifying or extending its functionality or hooking it into an API or game.
+    Otherwise, you can create an instance of the engine using Engine(), and start it by calling run()
+    on it, or ticking it within your own loop function. 
+    To retrieve any mode use its modename in GetMode(modename:str).
+    To create a mode use Mode(modename:str, available:bool=True), set available to False to hide it
+    from GetMode
+    """
+    
+    semantic_syntax_engine = Engine()
+    run(semantic_syntax_engine)
+    

rising_sse-0.1.dev0/sse/engine.py

@@ -0,0 +1,214 @@
+from .mode import GetMode, default_globals
+from .parser import tokenize
+
+class Engine:
+    __slots__ = ("frame_stack", "running", "engine_globals", "mode")
+    def __init__(self, starter = GetMode('main'), engine_globals = default_globals):
+        self.frame_stack = []
+        self.running = False
+        self.mode = starter
+        self.engine_globals = engine_globals
+    @property
+    def frame(self):
+        return self.frame_stack[-1]
+    def tick(self):
+
+        if len(self.frame_stack) > 0:
+            # get the engines current frame
+            frame = self.frame
+            
+            # extract the frames mode
+            mode = frame['mode']
+            # the frames positions
+            line_position = frame['line_position']
+            element_position = frame['element_position']
+            
+            # the frames instructions
+            instructions = frame['instructions']
+            # the frames scope and the frames stack
+            scope = frame['scope']
+            stack = frame['stack']
+            
+            engine_globals = self.engine_globals
+            
+            if line_position >= len(instructions):
+                previous_frame = self.frame_stack.pop()
+            else:
+                # get the current line and element
+                current_line = instructions[line_position]
+                if element_position is None:
+                    element_position = len(current_line) - 1
+                current_element = current_line[element_position]
+                frame['element_position'] = element_position
+                
+                # TICK LOGIC
+                self.handle_element(current_element, frame, mode, scope, stack)
+                
+                # increment positions
+                element_position = frame['element_position']
+                element_position -= 1
+                if element_position <= -1:
+                    element_position = None
+                    line_position += 1
+                    frame['line_position'] = line_position
+                    stack.clear()
+                frame['element_position'] = element_position
+                
+        else:
+            mode = self.mode
+            if 'prompt' in mode:
+                mode['prompt'](mode)
+            else:
+                self.engine_globals["prompt"](mode)
+            usertext = input()
+            code = tokenize(self.structure_input(usertext))
+            frame = self.Frame(mode, mode['main'], code)
+            self.AddFrame(frame)
+            
+    def handle_element(self, current_element, frame, mode, scope, stack):
+        element_type, value = current_element
+        
+        engine_globals = self.engine_globals
+                
+        match element_type:
+            case "string" | "integer" | "float" | "rawtoken" | "dotchain":
+                stack.append(value)
+            case "primitive":
+                mode_primitives = mode['primitives']
+                global_primitives = engine_globals['primitives']
+                if value in mode_primitives:
+                    mode_primitives[value](frame, self, stack)
+                elif value in global_primitives:
+                    global_primitives[value](frame, self, stack)
+                else:
+                    self.error(f"There is no available primitive called '{value}'.", "Missing Primitive")
+            case "intentive":
+                if len(stack) > 0:
+                    intent = stack.pop()
+                    if isinstance(intent, list):
+                        intent = intent[::-1]
+                        mode_primitives = mode['primitives']
+                        global_primitives = engine_globals['primitives']
+                        if value in mode_primitives:
+                            mode_primitives[value](frame, self, intent)
+                        elif value in global_primitives:
+                            global_primitives[value](frame, self, intent)
+                        else:
+                            self.error(f"There is no available primitive called '{value}'.", "Missing Primitive")
+                    else:
+                        self.error(f"Intentive primitive expects a stack not {intent}.", "Incorrect Intent")
+                else:
+                    self.error(f"No available intentive stack.", "Missing Intent")
+            case "set_var":
+                set_val = stack.pop()
+
+                # find the start of the path
+                # only set in current_scope
+                current_scope = scope
+
+                for link in value[:-1]:
+                    if link in current_scope:
+                        current_scope = current_scope[link]
+                    else:
+                        self.error(f"Could not follow the path {value} past '{link}'.", "Missing Link")
+                        break
+                else:
+                    current_scope[value[-1]] = set_val
+
+            case "get_var":
+                start, path = value[0], value[1:]
+
+                current_scope = scope
+                nonlocal_scope = current_scope if '__nonlocal__' in current_scope else current_scope
+                global_scope = engine_globals['main']
+
+                # find the start of the path
+                # prioritize current_scope -> nonlocal_scope -> global_scope
+                getting = None
+                if start in current_scope:
+                    getting = current_scope[start]
+                elif start in nonlocal_scope:
+                    getting = nonlocal_scope[start]
+                elif start in global_scope:
+                    getting = global_scope[start]
+                else:
+                    self.error(f"There is no available variable called '{start}'.", "Missing Variable")
+                if getting is not None:
+                    if len(path) > 0:
+                        for link in path:
+                            if link in getting:
+                                getting = getting[link]
+                            else:
+                                self.error(f"Could not follow the path {path} from {start} past '{link}'.", "Missing Link")
+                                getting = None
+                                break
+                        if getting is not None:
+                            stack.append(getting)
+                    else:
+                        stack.append(getting)
+            case "stack":
+                new_stack = []
+                for element in value[::-1]:
+                    self.handle_element(element, frame, mode, scope, new_stack)
+                stack.append(new_stack[::-1])
+            case "block":
+                stack.append({"__instructions__":value})
+            case other:
+                print(other, value)
+        
+    @staticmethod
+    def Frame(mode, scope, instructions):
+        return {
+            "mode":mode,
+            "line_position":0,
+            "element_position":None,
+            "scope":scope,
+            "instructions":instructions,
+            "stack":[]
+            }
+    def AddFrame(self, frame):
+        self.frame_stack.append(frame)
+    def say(self, message:str, name:str="Semantic Syntax Engine"):
+        print(f"[{name}]: {message}")
+    def announce(self, message:str):
+        print(message)
+    def error(self, message:str, errortype:str="Exception"):
+        self.say(f"({errortype}) {message}")
+        
+    def structure_input(self, usertext:str, section_start:str="[", section_end:str="]"):# -> list:
+        index = 0
+        section = ""
+        depth = 0
+        sections = []
+        while index < len(usertext):
+            char = usertext[index]
+            if char == section_start:
+                if depth > 0:
+                    section += char
+                depth += 1
+            
+            elif char == section_end:
+                if depth == 0:
+                    raise Exception(f"No starting '[' to ']' at character {index}")
+                elif depth == 1:
+                    sections.append(section)
+                    section = ""
+                elif depth > 1:
+                    section += char
+                
+                depth -= 1
+            else:
+                if depth > 0:
+                    section += char
+            index += 1
+        return "; ".join(sections)
+    def SetMode(self, modename:str):
+        mode = GetMode(modename)
+        if mode is not None:
+            self.mode = mode
+        else:
+            self.error(f"There is no available mode called {modename}", "Missing Mode")
+def run(engine:Engine):
+    engine.running = True
+    while engine.running:
+        engine.tick()

rising_sse-0.1.dev0/sse/mode.py

@@ -0,0 +1,191 @@
+"""
+In the Semantic Syntax Engine a mode is a module of the language
+the engine will use its mode to determine how to interpret Semantic Syntax
+switching out modules is like switching to an entirely new set of tools
+while the basic structure remains the same
+"""
+from .parser import tokenize
+import os
+
+__modes = {}
+
+def Mode(modename:str, available:bool=True):
+    mode = {
+        "name":modename,
+        "primitives":{},
+        "main":{},
+        }
+    if available:
+        __modes[modename] = mode
+    return mode
+
+def GetMode(modename:str):
+    if modename in __modes:
+        return __modes[modename]
+    else:
+        return None
+    
+def primitive(mode, name):
+    def wrap(method):
+        mode['primitives'][name] = method
+    return wrap
+
+def prompt(mode):
+    def wrap(method):
+        mode['prompt'] = method
+    return wrap
+    
+# the default mode for globals that are accessible in any other mode (can be changed)
+default_globals = Mode('default_globals', False)
+main = Mode('main')
+
+
+@prompt(default_globals)
+def _prompt(self):
+    pass
+
+
+# OUTPUT
+@primitive(default_globals, "print")
+def _print(frame, engine, stack):
+    output = " ".join(str(element) for element in stack[::-1])
+    print(output)
+    if not output.endswith('\n'):
+        print()
+    
+    stack.clear()
+
+# MATHEMATICS
+@primitive(default_globals, "add")
+def add(frame, engine, stack):
+    obj_a = stack.pop()
+    obj_b = stack.pop()
+    stack.append(obj_a + obj_b)
+@primitive(default_globals, "sub")
+def subtract(frame, engine, stack):
+    obj_a = stack.pop()
+    obj_b = stack.pop()
+    stack.append(obj_a - obj_b)
+@primitive(default_globals, "mul")
+def multiply(frame, engine, stack):
+    obj_a = stack.pop()
+    obj_b = stack.pop()
+    stack.append(obj_a * obj_b)
+@primitive(default_globals, "div")
+def divide(frame, engine, stack):
+    obj_a = stack.pop()
+    obj_b = stack.pop()
+    stack.append(obj_a / obj_b)
+    
+# STACK
+@primitive(default_globals, "Stack")
+def create_stack(frame, engine, stack):
+    new_stack = stack[::-1]
+    stack.clear()
+    stack.append(new_stack)
+@primitive(default_globals, "pull")
+def pull_stack(frame, engine, stack):
+    _stack = stack[-1]
+    stack.append(_stack.pop(0))
+@primitive(default_globals, "push")
+def push_stack(frame, engine, stack):
+    value = stack.pop()
+    _stack = stack[-1]
+    _stack.insert(0, value)
+    
+# BLOCK
+@primitive(default_globals, "Block") # create an empty block
+def create_block(frame, engine, stack):
+    new_block = {}
+    stack.append(new_block)
+@primitive(default_globals, "def") # add parameters to a block
+def define(frame, engine, stack):
+    parameters = stack.pop()
+    obj = stack.pop()
+    if '__instructions__' in obj:
+        obj['__params__'] = parameters
+        stack.append(obj)
+    else:
+        engine.error(f"Cannot add parameters to {obj}", "Incallable Object")   
+@primitive(default_globals, "call") # call a block
+def call(frame, engine, stack):
+    obj = stack.pop()
+    if '__instructions__' in obj:
+        params = obj.get('__params__', tuple())
+        for param in params:
+            if len(stack) > 0:
+                argument = stack.pop()
+                obj[param] = argument
+            else:
+                engine.error(f"Failed to call {obj}", "Insifficient Arguments")
+                break
+        else:
+            new_frame = engine.Frame(frame['mode'], obj, obj['__instructions__'])
+            engine.AddFrame(new_frame)
+    else:
+        engine.error(f"Cannot call {obj}", "Incallable Object")
+@primitive(default_globals, "return") # return a value
+def return_value(frame, engine, stack):
+    if len(engine.frame_stack) > 1:
+        engine.frame_stack[-2]['stack'].append(stack.pop())
+    engine.frame_stack.pop()
+@primitive(default_globals, "yield") # return a value without stopping
+def return_value(frame, engine, stack):
+    if len(engine.frame_stack) > 1:
+        engine.frame_stack[-2]['stack'].append(stack.pop())
+@primitive(default_globals, "script") # import a .sse file as a block
+def script(frame, engine, stack):
+    dotchain = stack.pop()
+    if not isinstance(dotchain, str):
+        dotchain = "/".join(dotchain)
+    filepath = dotchain + ".sse"
+    if os.path.exists(filepath):
+        with open(filepath) as file:
+            code = file.read()
+        stack.append({'__instructions__':tokenize(code)})
+    else:
+        engine.error(f"Could not load script '{filepath}'.", "Missing File")
+
+# CONTROL FLOW
+@primitive(default_globals, "line") # get the current line as an integer
+def get_current_line(frame, engine, stack):
+    stack.append(frame['line_position'])
+@primitive(default_globals, "goto") # goto a given line
+def goto_line(frame, engine, stack):
+    line_position = stack.pop()
+    engine.frame_stack.pop()
+    new_frame = engine.Frame(frame['mode'], frame['scope'], frame['instructions'])
+    new_frame['line_position'] = line_position
+    engine.AddFrame(new_frame)
+@primitive(default_globals, "if")
+def if_statement(frame, engine, stack):
+    if len(stack) > 0:
+        if stack.pop():
+            return
+    frame['element_position'] = 0
+@primitive(default_globals, "not")
+def _not(frame, engine, stack):
+    if len(stack) > 0:
+        stack.append(not stack.pop())
+    else:
+        stack.append(True)
+@primitive(default_globals, "True")
+def true(frame, engine, stack):
+    stack.append(True)
+@primitive(default_globals, "False")
+def false(frame, engine, stack):
+    stack.append(False)
+   
+@primitive(default_globals, "mode")
+def get_mode_name(frame, engine, stack):
+    stack.insert(0, frame['mode']['name'])
+@primitive(default_globals, "setmode")
+def set_mode(frame, engine, stack):
+    modename = stack.pop()
+    engine.SetMode(modename)
+    
+
+
+
+
+

rising_sse-0.1.dev0/sse/parser.py

@@ -0,0 +1,126 @@
+from lark import Lark, Transformer, Discard
+
+
+ss_structure = r"""
+
+%import common.WS
+
+
+
+ws: WS ?
+
+start: ws (line (";" line)*) ? ws
+
+line: ws (element (WS element)*) ? ws
+
+element: STRING | NUMBER | rawtoken | stack | block | primitive | intentive | get_var | set_var | dotchain
+
+%import common.ESCAPED_STRING -> STRING
+%import common.SIGNED_NUMBER -> NUMBER
+RAWTOKEN: /[a-zA-Z_][a-zA-Z0-9_-]*/
+rawtoken: RAWTOKEN
+
+stack: "[" line "]"
+block: "{" start "}"
+
+primitive: "/" RAWTOKEN
+intentive: RAWTOKEN ws "->"
+
+rawchain: (RAWTOKEN ("." RAWTOKEN)*) | ("." RAWTOKEN ("." RAWTOKEN)*) | (RAWTOKEN "." (RAWTOKEN ".")*) | ("." RAWTOKEN "." (RAWTOKEN ".")*) | (".")
+dotchain: rawchain
+
+get_var: rawchain "?"
+set_var: rawchain ":"
+
+"""
+
+class SS_Builder(Transformer):
+    def ws(self, ws):
+        return Discard
+    def WS(self, WS):
+        return Discard
+    def start(self, lines):
+        return tuple(lines)
+    def line(self, elements):
+        if len(elements) < 1:
+            return Discard
+        return tuple(elements)
+    def element(self, element):
+        return element[0]
+    def STRING(self, string):
+        return ("string", string[1:-1])
+    def NUMBER(self, number):
+        if '.' in number:
+            return ("float", float(number))
+        else:
+            return ("integer", int(number))
+    def RAWTOKEN(self, rawtoken):
+        return rawtoken[:]
+    def rawtoken(self, rawtoken):
+        return ("string", rawtoken[0])
+    def stack(self, stack):
+        if len(stack) >= 1:
+            return ("stack", stack[0])
+        else:
+            return ("stack", [])
+    def block(self, instructions):
+        if len(instructions) > 0:
+            return ("block", instructions[0])
+        else:
+            return ("block", tuple())
+    def primitive(self, primitive):
+        return ("primitive", primitive[0])
+    def intentive(self, primitive):
+        return ("intentive", primitive[0])
+    def rawchain(self, RAWTOKENS):
+        return tuple(RAWTOKENS)
+    def dotchain(self, rawchain):
+        return ("dotchain",rawchain[0])
+    
+    def get_var(self, get_var):
+        return ("get_var", get_var[0])
+    def set_var(self, set_var):
+        return ("set_var", set_var[0])
+ss_parser = Lark(ss_structure)
+ss_builder = SS_Builder()
+
+def tokenize(ss:str):
+    ss_tree = ss_parser.parse(ss)
+    ss_tokens = ss_builder.transform(ss_tree)
+    return ss_tokens
+
+if __name__ == '__main__':
+    string_example = """
+    "here is a string" "and another"
+    """
+    print(tokenize(string_example))
+    number_example = """
+    0.1 0 9 3 1.335
+    """
+    tokenize(number_example)
+    rawtoken_example = """
+    hello_wha-t9_
+    """
+    tokenize(rawtoken_example)
+    var_example = """
+    x: 0; x?;
+    x.x: 7;
+    """
+    print(tokenize(var_example))
+    stack_example = """
+    [0 hello_wow "heres a string in a stack"]
+    """
+    print(tokenize(stack_example))
+    block_example = """
+    {x 0 x-1;2.4 "string baby" i-1000}
+    """
+    print(tokenize(block_example))
+    primitive_example = """
+    ~prim
+    """
+    print(tokenize(primitive_example))
+    
+    
+    
+
+