stack-lang-engine 0.0.2__tar.gz → 0.0.3__tar.gz

stack_lang_engine-0.0.3/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: stack_lang_engine
+Version: 0.0.3
+Summary: An engine for creating stack-oriented DSLs or mini-programming languages.
+License-Expression: GPL-3.0-or-later
+Project-URL: Repository, https://github.com/MrHacer201145/SLE/
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# What is "Stack Lang Engine"
+SLE (Stack Lang Engine) is a simple tool for creating 
+stack-oriented DSL or even small programming languages.
+
+# Usage
+## Firstly
+Of course we need to import a module, and create object with type
+"StackEngine"
+```py
+import stack_lang_engine as sle
+
+eng = sle.StackEngine()
+```
+
+## Definition of words:
+This is how to define/delete words in StackEngine
+```py
+# Define new word
+eng.add_word("print", lambda: print(eng.pop()))
+
+# Delete word
+eng.del_word("print")
+```
+
+## How to execute text (given as string)
+```py
+# If you use the default regex pattern, 
+# it automatically recognizes whether it is a string or a number.
+eng.exec('10 20 30 "40"')
+```
+
+## How to create stack and APIs for it
+```py
+# Create new stack, we can use "create_api" option
+# to create eng.{name}_push, eng.{name}_pop() methods
+# for object
+
+eng.new_stack("stacky", create_api=True)
+# now we have eng.stacky_push and eng.stacky_pop
+
+eng.stacky_push(10)
+print(eng.stacky)
+eng.stacky_pop()
+```
+
+## Usefull APIs
+```py
+# Instead of writing "eng.stack.pop" or more we can use builtin
+# methods like eng.(push, pop, clear)
+
+eng.push(10) # For example
+```
+
+## Recognizers
+```py
+# We can create a new regex pattern, 
+# and both the parser and the interpreter must handle it.
+
+eng.add_recognizer(
+    name="Test", # Name of recognizer
+    pattern=r'Test', # Regex pattern
+    on_regex=lambda val: val, # What parser should get (or do) when it parses it
+    on_interpret=lambda val: print("Hello, Test!?"), # What interpreter should do when it gets it
+)
+
+# and if then we execute it will output
+# "Hello, Test!?" when it interprets word
+# with "Test" kind
+
+eng.exec("Test 10 20")
+print(eng.stack) # It will work correctly, so in stack only 10 and 20
+```
+
+## How to write more short code in this engine
+```py
+# For example we can set words dict instead of creating each
+# word over and over
+
+eng = sle.StackEngine(words={
+    "print": lambda: print(eng.pop())
+})
+
+# You can also read the interpreter's code itself on 
+# GitHub to better understand how it works.
+```
+### Thanks for reading the documentation!
+
+# License
+SLE is licensed under GPLv3 License

stack_lang_engine-0.0.3/README.md

@@ -0,0 +1,89 @@
+# What is "Stack Lang Engine"
+SLE (Stack Lang Engine) is a simple tool for creating 
+stack-oriented DSL or even small programming languages.
+
+# Usage
+## Firstly
+Of course we need to import a module, and create object with type
+"StackEngine"
+```py
+import stack_lang_engine as sle
+
+eng = sle.StackEngine()
+```
+
+## Definition of words:
+This is how to define/delete words in StackEngine
+```py
+# Define new word
+eng.add_word("print", lambda: print(eng.pop()))
+
+# Delete word
+eng.del_word("print")
+```
+
+## How to execute text (given as string)
+```py
+# If you use the default regex pattern, 
+# it automatically recognizes whether it is a string or a number.
+eng.exec('10 20 30 "40"')
+```
+
+## How to create stack and APIs for it
+```py
+# Create new stack, we can use "create_api" option
+# to create eng.{name}_push, eng.{name}_pop() methods
+# for object
+
+eng.new_stack("stacky", create_api=True)
+# now we have eng.stacky_push and eng.stacky_pop
+
+eng.stacky_push(10)
+print(eng.stacky)
+eng.stacky_pop()
+```
+
+## Usefull APIs
+```py
+# Instead of writing "eng.stack.pop" or more we can use builtin
+# methods like eng.(push, pop, clear)
+
+eng.push(10) # For example
+```
+
+## Recognizers
+```py
+# We can create a new regex pattern, 
+# and both the parser and the interpreter must handle it.
+
+eng.add_recognizer(
+    name="Test", # Name of recognizer
+    pattern=r'Test', # Regex pattern
+    on_regex=lambda val: val, # What parser should get (or do) when it parses it
+    on_interpret=lambda val: print("Hello, Test!?"), # What interpreter should do when it gets it
+)
+
+# and if then we execute it will output
+# "Hello, Test!?" when it interprets word
+# with "Test" kind
+
+eng.exec("Test 10 20")
+print(eng.stack) # It will work correctly, so in stack only 10 and 20
+```
+
+## How to write more short code in this engine
+```py
+# For example we can set words dict instead of creating each
+# word over and over
+
+eng = sle.StackEngine(words={
+    "print": lambda: print(eng.pop())
+})
+
+# You can also read the interpreter's code itself on 
+# GitHub to better understand how it works.
+```
+### Thanks for reading the documentation!
+
+# License
+SLE is licensed under GPLv3 License

stack_lang_engine-0.0.3/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stack_lang_engine"
+version = "0.0.3"
+description = "An engine for creating stack-oriented DSLs or mini-programming languages."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "GPL-3.0-or-later"
+
+[project.urls]
+Repository = "https://github.com/MrHacer201145/SLE/"

stack_lang_engine-0.0.3/stack_lang_engine/main.py

@@ -0,0 +1,83 @@
+import re
+
+
+class UndefinedWordError(BaseException):
+    "Exception for words that do not exist"
+
+
+class StackEngine:
+    def __init__(self, 
+                words={},
+                stack=[],
+                recognizers={},
+                regex_recognizers={},
+                undefined_error_msg=lambda word: f"Word '{word}' is not defined",
+                token_spec = [
+                    ("STR", r'"[^"]*"'),
+                    ("INT", r'\d+(\.\d+)?'),
+                    ("IDENT", r'[a-zA-Z_][a-zA-Z0-9_]*'),
+                    ("SKIP", r'[ \n\t]')
+                ]
+            ):
+        self.words = words
+        self.stack = stack
+        self.error_msg = undefined_error_msg
+        self.recognizers = recognizers
+        self.regex_recognizers = regex_recognizers
+        self.token_spec = token_spec
+
+    def add_word(self, name: str, func) -> None:
+        self.words[name] = func
+    def del_word(self, name: str) -> None:
+        del self.words[name]
+
+    def add_recognizer(self, name: str, pattern: str, on_regex: callable, on_interpret: callable) -> None:
+        self.token_spec.insert(0, (name, pattern))
+        self.recognizers[name] = on_regex
+        self.regex_recognizers[name] = on_interpret
+
+    def new_stack(self, name, content=[], create_api=False):
+        self.__dict__[name] = content
+
+        if create_api:
+            self.__dict__[f'{name}_push'] = lambda val: self.__dict__[name].append(val)
+            self.__dict__[f'{name}_pop'] = lambda: self.__dict__[name].pop()
+
+    def push(self, value: any) -> None:
+        self.stack.append(value)
+    def pop(self) -> any:
+        return self.stack.pop()
+    def clear(self) -> None:
+        self.stack.clear()
+
+    def _parse(self, text: str) -> list[tuple[str, any]]:
+        tokens = []
+        tok_regex = "|".join(f"(?P<{pair[0]}>{pair[1]})" for pair in self.token_spec)
+
+        for mo in re.finditer(tok_regex, text):
+            kind, val = mo.lastgroup, mo.group()
+
+            if kind == "SKIP": continue
+            elif kind in self.regex_recognizers:
+                val = self.regex_recognizers[kind](val)
+            elif kind == "STR": val = val[1:-1]
+            elif kind == "INT": val = int(val)
+            tokens.append((kind, val))
+
+        return tokens
+
+    def exec(self, text: str) -> None:
+        "Interprets given string"
+        words = self._parse(text)
+
+        for word in words:
+            kind, val = word
+            if kind == "IDENT":
+                if val in self.words:
+                    self.words[val]()
+                else:
+                    raise UndefinedWordError(self.error_msg(val))
+            elif kind in self.recognizers:
+                self.recognizers[kind](val)
+            else:
+                self.stack.append(val)

stack_lang_engine-0.0.3/stack_lang_engine.egg-info/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: stack_lang_engine
+Version: 0.0.3
+Summary: An engine for creating stack-oriented DSLs or mini-programming languages.
+License-Expression: GPL-3.0-or-later
+Project-URL: Repository, https://github.com/MrHacer201145/SLE/
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# What is "Stack Lang Engine"
+SLE (Stack Lang Engine) is a simple tool for creating 
+stack-oriented DSL or even small programming languages.
+
+# Usage
+## Firstly
+Of course we need to import a module, and create object with type
+"StackEngine"
+```py
+import stack_lang_engine as sle
+
+eng = sle.StackEngine()
+```
+
+## Definition of words:
+This is how to define/delete words in StackEngine
+```py
+# Define new word
+eng.add_word("print", lambda: print(eng.pop()))
+
+# Delete word
+eng.del_word("print")
+```
+
+## How to execute text (given as string)
+```py
+# If you use the default regex pattern, 
+# it automatically recognizes whether it is a string or a number.
+eng.exec('10 20 30 "40"')
+```
+
+## How to create stack and APIs for it
+```py
+# Create new stack, we can use "create_api" option
+# to create eng.{name}_push, eng.{name}_pop() methods
+# for object
+
+eng.new_stack("stacky", create_api=True)
+# now we have eng.stacky_push and eng.stacky_pop
+
+eng.stacky_push(10)
+print(eng.stacky)
+eng.stacky_pop()
+```
+
+## Usefull APIs
+```py
+# Instead of writing "eng.stack.pop" or more we can use builtin
+# methods like eng.(push, pop, clear)
+
+eng.push(10) # For example
+```
+
+## Recognizers
+```py
+# We can create a new regex pattern, 
+# and both the parser and the interpreter must handle it.
+
+eng.add_recognizer(
+    name="Test", # Name of recognizer
+    pattern=r'Test', # Regex pattern
+    on_regex=lambda val: val, # What parser should get (or do) when it parses it
+    on_interpret=lambda val: print("Hello, Test!?"), # What interpreter should do when it gets it
+)
+
+# and if then we execute it will output
+# "Hello, Test!?" when it interprets word
+# with "Test" kind
+
+eng.exec("Test 10 20")
+print(eng.stack) # It will work correctly, so in stack only 10 and 20
+```
+
+## How to write more short code in this engine
+```py
+# For example we can set words dict instead of creating each
+# word over and over
+
+eng = sle.StackEngine(words={
+    "print": lambda: print(eng.pop())
+})
+
+# You can also read the interpreter's code itself on 
+# GitHub to better understand how it works.
+```
+### Thanks for reading the documentation!
+
+# License
+SLE is licensed under GPLv3 License

stack_lang_engine-0.0.2/PKG-INFO

@@ -1,25 +0,0 @@
-Metadata-Version: 2.4
-Name: stack_lang_engine
-Version: 0.0.2
-Summary: Simple engine for building stack-oriented languages
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# About
-SLE (Stack Lang Engine) is a simple tool for creating 
-stack-oriented DSL or even small programming languages
-
-# Example of usage
-```py
-import stack_lang_engine as sle
-
-eng = sle.StackEngine()
-
-eng.add_word("print", lambda: print(eng.stack.pop()))
-
-eng.exec('"test" print') # Will print "test"
-```
-# License
-SLE is licensed under GPLv3 License

stack_lang_engine-0.0.2/README.md

@@ -1,16 +0,0 @@
-# About
-SLE (Stack Lang Engine) is a simple tool for creating 
-stack-oriented DSL or even small programming languages
-
-# Example of usage
-```py
-import stack_lang_engine as sle
-
-eng = sle.StackEngine()
-
-eng.add_word("print", lambda: print(eng.stack.pop()))
-
-eng.exec('"test" print') # Will print "test"
-```
-# License
-SLE is licensed under GPLv3 License

stack_lang_engine-0.0.2/pyproject.toml

@@ -1,10 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "stack_lang_engine"
-version = "0.0.2"
-description = "Simple engine for building stack-oriented languages"
-readme = "README.md"
-requires-python = ">=3.8"

stack_lang_engine-0.0.2/stack_lang_engine/main.py

@@ -1,46 +0,0 @@
-import re
-
-class StackEngine:
-    def __init__(self, words={}, stack=[]):
-        self.words = words
-        self.stack = stack
-
-    def add_word(self, name, func):
-        self.words[name] = func
-    def del_word(self, name):
-        del self.words[name]
-
-    def new_stack(self, name, content=[]):
-        self.__dict__[name] = content
-
-    @staticmethod
-    def _parse(text):
-        tokens = []
-        token_spec = [
-            ("STR", r'"[^"]*"'),
-            ("NUM", r'\d+(\.\d+)?'),
-            ("IDENT", r'[a-zA-Z_][a-zA-Z0-9_]*'),
-            ("SKIP", r'[ \n\t]')
-        ]
-        tok_regex = "|".join(f"(?P<{pair[0]}>{pair[1]})" for pair in token_spec)
-
-        for mo in re.finditer(tok_regex, text):
-            kind, val = mo.lastgroup, mo.group()
-
-            if kind == "SKIP": continue
-            elif kind == "STR": val = val[1:-1]
-            elif kind == "NUM": val = int(val)
-            tokens.append((kind, val))
-
-        return tokens
-
-    def exec(self, text):
-        words = self._parse(text)
-
-        for word in words:
-            kind, val = word
-            if kind == "IDENT":
-                if val in self.words:
-                    self.words[val]()
-            else:
-                self.stack.append(val)

stack_lang_engine-0.0.2/stack_lang_engine.egg-info/PKG-INFO

@@ -1,25 +0,0 @@
-Metadata-Version: 2.4
-Name: stack_lang_engine
-Version: 0.0.2
-Summary: Simple engine for building stack-oriented languages
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# About
-SLE (Stack Lang Engine) is a simple tool for creating 
-stack-oriented DSL or even small programming languages
-
-# Example of usage
-```py
-import stack_lang_engine as sle
-
-eng = sle.StackEngine()
-
-eng.add_word("print", lambda: print(eng.stack.pop()))
-
-eng.exec('"test" print') # Will print "test"
-```
-# License
-SLE is licensed under GPLv3 License