basic-pp 0.0.0__py3-none-any.whl

basic_pp-0.0.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: basic-pp
+Version: 0.0.0
+Summary: a simple language for begginers.
+Author-email: R A Veeraragavan <veeracoder123@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/veeracoder508/e2eeftp
+Project-URL: Issues, https://github.com/veeracoder508/e2eeftp/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: license
+Requires-Dist: pdoc3>=0.11.6
+Requires-Dist: pytest>=9.0.3
+Requires-Dist: rich>=15.0.0
+Requires-Dist: zensical>=0.0.43
+Dynamic: license-file
+
+# basic++
+An simple language for beginners.
+
+## usage
+bpp \[options\] \<filename\>
+
+### positional arguments:
+  - **src_file**          the source(.bpp)/byte(.bc) code
+
+### options:
+  - **-h**, **--help**: show this help message and exit
+  - **-v**, **--verbose**: increase output verbosity
+  - **-b**, **--bytecode**: display the byte code.
+  - **-bc**, **--write-bc**: write the byte code to a file.
+
+## how it works??
+Basic++ is like python-compiles an byte code and then interpret the byte code.
+The byte code is in the same style like python's.
+
+For full documentation visit [veeracoder508/basic-pp](https://veeracoder508.github.io/basic-pp)

basic_pp-0.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+basic_pp-0.0.0.dist-info/licenses/license,sha256=zC39XHU09mWV6vHqWJ38CPQ4suunMFDpTsbF3mbXq-M,1069
+basicpp/__init__.py,sha256=nAFi8DTnzkmlYQ5D05wXwIW5aFGBmARuVyuQjXZHIQs,62
+basicpp/cli.py,sha256=YHVyIMcyn973DL5NRluWgvuuzRsrIpes-e3dtHBFdFY,2811
+basicpp/bvm/__init__.py,sha256=76eQ5M58cBEXU17vQFoHv7iwdPPPgYawwJcokDM1IV0,70
+basicpp/bvm/vm.py,sha256=_LsYt4Qs97RQHuJ-F-IgnvdjT8U5MXk0ZnlgHAfQg0M,6388
+basicpp/compiler/__init__.py,sha256=Sz7hVgokXjSFGQ2lMAsEJZpZj8tG55HXlwHdB4DKlvY,231
+basicpp/compiler/ast_a.py,sha256=XFx8Bhx5N8AoWhNeGYvyiD_66xFbtYUCaKUpzAAPEKE,20071
+basicpp/compiler/lexer.py,sha256=_fgo-uicglr5_BqCaa9lykLU3XfEsJJH9vKy8Hk5JeY,13017
+basicpp/compiler/tokens.py,sha256=XX_0BJSaHbf1tp3WpGdjyWjnfxTERrdM8llDVz0td4w,3595
+basic_pp-0.0.0.dist-info/METADATA,sha256=jQwNJOwd_1eDsViqf3QOth84i4VJ__WvCDGloAEBNog,1316
+basic_pp-0.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+basic_pp-0.0.0.dist-info/entry_points.txt,sha256=3nUmNnVtZ9d0dMes_JE8IFMga7vc4NDfzm7Ju4BrHuI,40
+basic_pp-0.0.0.dist-info/top_level.txt,sha256=-Evl2Nvv3PdeLLE8un5ILeKgadx3hs-dvXUcODC6-gk,8
+basic_pp-0.0.0.dist-info/RECORD,,

basic_pp-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

basic_pp-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bpp = basicpp.cli:cli

basic_pp-0.0.0.dist-info/licenses/license

@@ -0,0 +1,19 @@
+Copyright (c) Zensical LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

basic_pp-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+basicpp

basicpp/__init__.py

@@ -0,0 +1,3 @@
+"""A simple interpreted landuage."""
+
+from .bvm import BVM

basicpp/bvm/__init__.py

@@ -0,0 +1,3 @@
+"""The Basic Virtual Machine implementation."""
+
+from .vm import BVM

basicpp/bvm/vm.py

@@ -0,0 +1,213 @@
+"""
+Basic Virtual Machine (BVM) implementation for Basic++.
+This module executes the bytecode produced by the compiler.
+"""
+
+import sys
+from typing import Any, List, Dict, Tuple
+from pprint import pprint
+
+
+class BVM:
+    """The VM for the Basic++ language."""
+
+    def __init__(self, bytecode: Dict[str, Any]):
+        """
+        Initializes the VM with the bytecode dictionary.
+
+        Args:
+            bytecode (dict): Dictionary containing 'code', 'consts', and 'names'.
+        """
+        self.code: List[Tuple[str, Any]] = bytecode.get('code', [])
+        self.consts: List[Any] = bytecode.get('consts', [])
+        self.names: List[str] = bytecode.get('names', [])
+        
+        self.stack: List[Any] = []
+        self.variables: Dict[str, Any] = {}
+        self.ip = 0  # Instruction Pointer
+        self.labels: Dict[str, int] = {}
+        
+        self._resolve_labels()
+
+    def _resolve_labels(self):
+        """Pre-pass to map labels to instruction indices."""
+        for i, (op, arg) in enumerate(self.code):
+            if op == 'LABEL':
+                self.labels[arg] = i
+
+    def push(self, value: Any):
+        self.stack.append(value)
+
+    def pop(self) -> Any:
+        if not self.stack:
+            raise RuntimeError("Stack underflow")
+        return self.stack.pop()
+
+    def run(self):
+        """Main execution loop."""
+        while self.ip < len(self.code):
+            op, arg = self.code[self.ip]
+            
+            if op == 'RETURN_VALUE':
+                break
+            
+            elif op == 'LOAD_CONST':
+                self.push(arg)
+            
+            elif op == 'LOAD_NAME':
+                if arg not in self.variables:
+                    raise NameError(f"Variable '{arg}' is not defined")
+                self.push(self.variables[arg])
+            
+            elif op == 'STORE_NAME':
+                self.variables[arg] = self.pop()
+            
+            elif op == 'READ_INPUT':
+                sys.stdout.flush()
+                val = input(arg)
+                # Attempt basic type conversion
+                try:
+                    if '.' in val:
+                        val = float(val)
+                    else:
+                        val = int(val)
+                except ValueError:
+                    pass
+                self.push(val)
+
+            elif op == 'PRINT_ITEM':
+                print(self.pop(), end=' ', flush=True)
+            
+            elif op == 'PRINT_NEWLINE':
+                print()
+
+            elif op == 'BINARY_ADD':
+                b = self.pop()
+                a = self.pop()
+                self.push(a + b)
+            
+            elif op == 'BINARY_SUBTRACT':
+                b = self.pop()
+                a = self.pop()
+                self.push(a - b)
+            
+            elif op == 'BINARY_MULTIPLY':
+                b = self.pop()
+                a = self.pop()
+                self.push(a * b)
+            
+            elif op == 'BINARY_TRUE_DIVIDE':
+                b = self.pop()
+                a = self.pop()
+                self.push(a / b)
+            
+            elif op == 'BINARY_MODULO':
+                b = self.pop()
+                a = self.pop()
+                self.push(a % b)
+
+            elif op == 'BINARY_AND':
+                b = self.pop()
+                a = self.pop()
+                self.push(a & b)
+            
+            elif op == 'BINARY_OR':
+                b = self.pop()
+                a = self.pop()
+                self.push(a | b)
+            
+            elif op == 'BINARY_XOR':
+                b = self.pop()
+                a = self.pop()
+                self.push(a ^ b)
+
+            elif op == 'BINARY_LSHIFT':
+                b = self.pop()
+                a = self.pop()
+                self.push(a << b)
+
+            elif op == 'BINARY_RSHIFT':
+                b = self.pop()
+                a = self.pop()
+                self.push(a >> b)
+
+            elif op == 'BINARY_POWER':
+                b = self.pop()
+                a = self.pop()
+                self.push(a ** b)
+
+            elif op.startswith('COMPARE_'):
+                b = self.pop()
+                a = self.pop()
+                if op == 'COMPARE_EQ': self.push(a == b)
+                elif op == 'COMPARE_NEQ': self.push(a != b)
+                elif op == 'COMPARE_GT': self.push(a > b)
+                elif op == 'COMPARE_LT': self.push(a < b)
+                elif op == 'COMPARE_GTE': self.push(a >= b)
+                elif op == 'COMPARE_LTE': self.push(a <= b)
+
+            elif op == 'UNARY_NEGATIVE':
+                self.push(-self.pop())
+
+            elif op == 'UNARY_POSITIVE':
+                self.push(+self.pop())
+
+            elif op == 'UNARY_NOT':
+                self.push(not self.pop())
+
+            elif op == 'UNARY_INVERT':
+                self.push(~self.pop())
+
+            elif op == 'LOGICAL_AND':
+                b = self.pop()
+                a = self.pop()
+                self.push(a and b)
+            
+            elif op == 'LOGICAL_OR':
+                b = self.pop()
+                a = self.pop()
+                self.push(a or b)
+
+            elif op == 'JUMP':
+                self.ip = self.labels[arg]
+                continue
+            
+            elif op == 'JUMP_IF_FALSE':
+                condition = self.pop()
+                if not condition:
+                    self.ip = self.labels[arg]
+                    continue
+
+            elif op == 'LABEL':
+                pass # Labels are handled in pre-pass
+
+            else:
+                raise RuntimeError(f"Unknown opcode: {op}")
+
+            self.ip += 1
+
+
+def main(): 
+    from basicpp.compiler import compile_source
+
+    # A small integrated test to verify the BVM works as expected
+    test_src = """
+    START
+    SET x $INT = 10 ;
+    SET y $INT = 5 ;
+    result = (x + y) * 2 ;
+    PRINT "The result of (10 + 5) * 2 is:", result ;
+    END
+    """
+    print("Running BVM Self-Test...")
+    bc = compile_source(test_src)
+    print("===== SOURCE =====")
+    print(test_src)
+    print("===== BYTECODE =====")
+    pprint(bc)
+    print("===== OUTPUT =====")
+    BVM(bc).run()
+
+if __name__ == '__main__':
+    main()
+    

basicpp/cli.py

@@ -0,0 +1,93 @@
+from . import BVM
+from .compiler import compile_source
+from .compiler.ast_a import write_bytecode_to_file
+import argparse
+import os
+from pprint import pprint
+
+parser = argparse.ArgumentParser(
+    prog="basicpp",
+    usage="%(prog)s [options] <filename>",
+    description="Basic++ Interpreter",
+)
+
+parser.add_argument('src_file',
+                    help='the source(.bpp)/byte(.bc) code')
+parser.add_argument('-v', '--verbose', 
+                    action='store_const',
+                    dest='verbose',
+                    const=True,
+                    help='increase output verbosity')
+parser.add_argument('-b', '--bytecode',
+                    action='store_const',
+                    const=True,
+                    dest='bytecode',
+                    help='display the byte code.')
+parser.add_argument('-bc', '--write-bc',
+                    action='store_const',
+                    const=True,
+                    dest='write_bc',
+                    help='write the byte code to a file.')
+
+args = parser.parse_args()
+
+def file_extension(filename: str) -> str:
+    if filename.endswith('.bpp'):
+        return 'BPP'
+    elif filename.endswith('.bc'):
+        return 'BC'
+    else:
+        return filename.split('.')[-1]
+    
+def run_bc(src: str) -> str:
+    return compile_source(src)
+
+def run_bpp(src: str) -> None:
+    return BVM(compile_source(src)).run()
+
+def disp_bytecode(src: str) -> str:
+    return compile_source(src)
+
+
+def cli():
+    """The cli for the script
+    Usage:
+    >>> basicpp <filename> [option]
+    """
+    if not os.path.exists(args.src_file):
+        print(f"Error: File '{args.src_file}' not found.")
+        return
+
+    with open(args.src_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    file_ex = file_extension(args.src_file)
+
+    if args.verbose:
+        print("===== ARGS =====")
+        print(f"file_name: {args.src_file}")
+        print(f"file_extension: {file_ex}")
+        print("================")
+
+    if args.bytecode:
+        pprint(disp_bytecode(content))
+        return
+    
+    if args.write_bc:
+        write_bytecode_to_file(file_name=f"{args.src_file.split('.')[0]}.bc", content=run_bc(content))
+        return
+
+    if file_ex == 'BPP':
+        if args.verbose:
+            print("===== SOURCE =====")
+            print(content)
+            print("===== BYTECODE =====")
+            pprint(run_bc(content))
+            print("===== OUTPUT =====")
+        run_bpp(content)
+    elif file_ex == 'BC':
+        # Currently, the VM expects a bytecode dictionary. 
+        # If .bc files are raw source, we run them; otherwise, a loader is needed.
+        run_bpp(content)
+    else:
+        raise ValueError(f"Invalid file extension: {file_ex}")

basicpp/compiler/__init__.py

@@ -0,0 +1,6 @@
+"""The compiler to compile the source code to byte code."""
+
+from .ast_a import compile_source, write_bytecode_to_file, Parser
+from .lexer import Lexer
+
+__all__ = ['compile_source', 'write_bytecode_to_file', 'Parser', 'Lexer']