multilingualprogramming 0.2.0__py3-none-any.whl

multilingualprogramming/__init__.py

@@ -0,0 +1,74 @@
+#
+# SPDX-FileCopyrightText: 2022 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""multilingualprogramming is an application for multilingual programming."""
+
+from multilingualprogramming.numeral.mp_numeral import MPNumeral
+from multilingualprogramming.numeral.unicode_numeral import UnicodeNumeral
+from multilingualprogramming.numeral.roman_numeral import RomanNumeral
+from multilingualprogramming.numeral.complex_numeral import ComplexNumeral
+from multilingualprogramming.numeral.fraction_numeral import FractionNumeral
+from multilingualprogramming.numeral.numeral_converter import NumeralConverter
+from multilingualprogramming.keyword.keyword_registry import KeywordRegistry
+from multilingualprogramming.keyword.keyword_validator import KeywordValidator
+from multilingualprogramming.keyword.language_pack_validator import (
+    LanguagePackValidator,
+)
+from multilingualprogramming.datetime.mp_date import MPDate
+from multilingualprogramming.datetime.mp_time import MPTime
+from multilingualprogramming.datetime.mp_datetime import MPDatetime
+from multilingualprogramming.lexer.lexer import Lexer
+from multilingualprogramming.lexer.token import Token
+from multilingualprogramming.lexer.token_types import TokenType
+from multilingualprogramming.parser.parser import Parser
+from multilingualprogramming.parser.ast_printer import ASTPrinter
+from multilingualprogramming.parser.semantic_analyzer import (
+    Symbol, Scope, SymbolTable, SemanticAnalyzer,
+)
+from multilingualprogramming.parser.error_messages import ErrorMessageRegistry
+from multilingualprogramming.codegen.python_generator import PythonCodeGenerator
+from multilingualprogramming.codegen.runtime_builtins import RuntimeBuiltins
+from multilingualprogramming.codegen.executor import ProgramExecutor, ExecutionResult
+from multilingualprogramming.codegen.repl import REPL
+from multilingualprogramming.core.ir import CoreIRProgram
+from multilingualprogramming.core.lowering import lower_to_core_ir
+from multilingualprogramming.imports import (
+    enable_multilingual_imports, disable_multilingual_imports,
+)
+
+__all__ = [
+    "MPNumeral",
+    "UnicodeNumeral",
+    "RomanNumeral",
+    "ComplexNumeral",
+    "FractionNumeral",
+    "NumeralConverter",
+    "KeywordRegistry",
+    "KeywordValidator",
+    "LanguagePackValidator",
+    "MPDate",
+    "MPTime",
+    "MPDatetime",
+    "Lexer",
+    "Token",
+    "TokenType",
+    "Parser",
+    "ASTPrinter",
+    "Symbol",
+    "Scope",
+    "SymbolTable",
+    "SemanticAnalyzer",
+    "ErrorMessageRegistry",
+    "PythonCodeGenerator",
+    "RuntimeBuiltins",
+    "ProgramExecutor",
+    "ExecutionResult",
+    "REPL",
+    "CoreIRProgram",
+    "lower_to_core_ir",
+    "enable_multilingual_imports",
+    "disable_multilingual_imports",
+]

multilingualprogramming/__main__.py

@@ -0,0 +1,194 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""
+CLI entry point for the multilingual programming language.
+
+Usage:
+    python -m multilingualprogramming                     # Start REPL
+    python -m multilingualprogramming run <file>           # Execute a file
+    python -m multilingualprogramming repl [--lang XX]     # Start REPL
+    python -m multilingualprogramming compile <file>       # Show generated Python
+    python -m multilingualprogramming smoke --lang fr      # Validate one language pack
+    python -m multilingualprogramming smoke --all          # Validate all language packs
+"""
+
+import argparse
+import sys
+
+from multilingualprogramming.codegen.executor import ProgramExecutor
+from multilingualprogramming.codegen.python_generator import PythonCodeGenerator
+from multilingualprogramming.codegen.repl import REPL
+from multilingualprogramming.keyword.language_pack_validator import (
+    LanguagePackValidator,
+)
+from multilingualprogramming.exceptions import UnsupportedLanguageError
+from multilingualprogramming.lexer.lexer import Lexer
+from multilingualprogramming.parser.parser import Parser
+from multilingualprogramming.version import __version__
+
+
+def cmd_run(args):
+    """Execute a multilingual source file."""
+
+    try:
+        with open(args.file, encoding="utf-8") as f:
+            source = f.read()
+    except FileNotFoundError:
+        print(f"Error: file not found: {args.file}", file=sys.stderr)
+        sys.exit(1)
+    except OSError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    executor = ProgramExecutor(language=args.lang)
+    result = executor.execute(source)
+
+    if result.output:
+        sys.stdout.write(result.output)
+
+    if not result.success:
+        for err in result.errors:
+            print(err, file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_repl(args):
+    """Start the interactive REPL."""
+    repl = REPL(language=args.lang, show_python=args.show_python)
+    repl.run()
+
+
+def cmd_compile(args):
+    """Compile a source file and print the generated Python."""
+
+    try:
+        with open(args.file, encoding="utf-8") as f:
+            source = f.read()
+    except FileNotFoundError:
+        print(f"Error: file not found: {args.file}", file=sys.stderr)
+        sys.exit(1)
+    except OSError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    lang = args.lang
+    lexer = Lexer(source, language=lang)
+    tokens = lexer.tokenize()
+    detected_lang = lexer.language or lang or "en"
+
+    parser = Parser(tokens, source_language=detected_lang)
+    program = parser.parse()
+
+    generator = PythonCodeGenerator()
+    python_source = generator.generate(program)
+    print(python_source)
+
+
+def cmd_smoke(args):
+    """Run language-pack smoke validation checks."""
+    registry_validator = LanguagePackValidator()
+    languages = (
+        sorted(registry_validator.get_supported_languages())
+        if args.all
+        else [args.lang]
+    )
+
+    failed = False
+    for language in languages:
+        try:
+            errors = registry_validator.validate(language)
+        except UnsupportedLanguageError as exc:
+            failed = True
+            print(f"[FAIL] {language}: {exc}", file=sys.stderr)
+            continue
+
+        if errors:
+            failed = True
+            print(f"[FAIL] {language}", file=sys.stderr)
+            for error in errors:
+                print(f"  - {error}", file=sys.stderr)
+        else:
+            print(f"[PASS] {language}")
+
+    if failed:
+        sys.exit(1)
+
+
+def main():
+    """Run the CLI entry point and dispatch subcommands."""
+    parser = argparse.ArgumentParser(
+        prog="multilingual",
+        description="Multilingual Programming Language CLI",
+    )
+    parser.add_argument(
+        "--version", action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # run subcommand
+    run_parser = subparsers.add_parser("run", help="Execute a source file")
+    run_parser.add_argument("file", help="Path to the source file")
+    run_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+
+    # repl subcommand
+    repl_parser = subparsers.add_parser("repl", help="Start interactive REPL")
+    repl_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+    repl_parser.add_argument(
+        "--show-python", action="store_true",
+        help="Display generated Python code before execution",
+    )
+
+    # compile subcommand
+    compile_parser = subparsers.add_parser(
+        "compile", help="Show generated Python code"
+    )
+    compile_parser.add_argument("file", help="Path to the source file")
+    compile_parser.add_argument(
+        "--lang", default=None,
+        help="Source language code (e.g., en, fr, hi). Auto-detect if omitted.",
+    )
+
+    # smoke subcommand
+    smoke_parser = subparsers.add_parser(
+        "smoke", help="Validate language pack(s)"
+    )
+    smoke_parser.add_argument(
+        "--lang", default="en",
+        help="Language code to validate (default: en)",
+    )
+    smoke_parser.add_argument(
+        "--all", action="store_true",
+        help="Validate all supported languages",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "run":
+        cmd_run(args)
+    elif args.command == "repl":
+        cmd_repl(args)
+    elif args.command == "compile":
+        cmd_compile(args)
+    elif args.command == "smoke":
+        cmd_smoke(args)
+    else:
+        # Default: start REPL
+        args.lang = None
+        args.show_python = False
+        cmd_repl(args)
+
+
+if __name__ == "__main__":
+    main()

multilingualprogramming/codegen/__init__.py

@@ -0,0 +1,12 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Code generation and runtime subpackage for the multilingual programming language."""
+
+from multilingualprogramming.codegen.python_generator import PythonCodeGenerator
+from multilingualprogramming.codegen.runtime_builtins import RuntimeBuiltins
+from multilingualprogramming.codegen.executor import ProgramExecutor, ExecutionResult
+from multilingualprogramming.codegen.repl import REPL

multilingualprogramming/codegen/executor.py

@@ -0,0 +1,215 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""
+Program executor: full pipeline from multilingual source to execution.
+
+    source (any language) -> Lexer -> Parser -> SemanticAnalyzer
+        -> PythonCodeGenerator -> compile + exec
+"""
+
+import io
+import sys
+
+from multilingualprogramming.lexer.lexer import Lexer
+from multilingualprogramming.parser.parser import Parser
+from multilingualprogramming.parser.semantic_analyzer import SemanticAnalyzer
+from multilingualprogramming.codegen.python_generator import PythonCodeGenerator
+from multilingualprogramming.codegen.runtime_builtins import RuntimeBuiltins
+from multilingualprogramming.core.lowering import lower_to_core_ir
+from multilingualprogramming.imports import enable_multilingual_imports
+from multilingualprogramming.exceptions import (
+    RuntimeExecutionError,
+    CodeGenerationError,
+)
+
+
+class ExecutionResult:
+    """Result of executing a multilingual program."""
+
+    def __init__(self, output="", return_value=None, python_source="",
+                 errors=None, success=True):
+        self.output = output
+        self.return_value = return_value
+        self.python_source = python_source
+        self.errors = errors or []
+        self.success = success
+
+    def __repr__(self):
+        status = "OK" if self.success else "FAILED"
+        return (f"ExecutionResult({status}, "
+                f"output={self.output!r}, "
+                f"errors={self.errors!r})")
+
+
+class ProgramExecutor:
+    """
+    Executes multilingual source code through the full pipeline.
+
+    Usage:
+        executor = ProgramExecutor(language="fr")
+        result = executor.execute(french_source)
+        print(result.output)    # captured stdout
+        print(result.success)   # True/False
+    """
+
+    def __init__(self, language=None, check_semantics=True):
+        """
+        Initialize the executor.
+
+        Args:
+            language: Source language code (e.g., "en", "fr", "hi").
+                     If None, auto-detect from keywords.
+            check_semantics: Whether to run semantic analysis before
+                           code generation. Default True.
+        """
+        self.language = language
+        self.check_semantics = check_semantics
+
+    def execute(self, source, capture_output=True, globals_dict=None):
+        """
+        Execute multilingual source code.
+
+        Args:
+            source: Multilingual source code string.
+            capture_output: If True, capture stdout to result.output.
+                          If False, print to actual stdout.
+            globals_dict: Optional dict to merge into execution globals.
+
+        Returns:
+            ExecutionResult with output, generated Python source, and errors.
+        """
+        try:
+            # Step 1-3: Frontend to typed core representation
+            core_program = self.to_core_ir(source)
+            detected_language = core_program.source_language
+
+            # Step 4: Semantic analysis (optional)
+            if self.check_semantics:
+                analyzer = SemanticAnalyzer(
+                    source_language=detected_language
+                )
+                # Pre-seed symbol table with runtime builtins so that
+                # names like print, range, len, etc. are not flagged
+                # as undefined.
+                builtins_ns = RuntimeBuiltins(detected_language).namespace()
+                for name in builtins_ns:
+                    analyzer.symbol_table.define(
+                        name, "variable", line=0, column=0
+                    )
+                semantic_errors = analyzer.analyze(core_program.ast)
+                if semantic_errors:
+                    return ExecutionResult(
+                        errors=[str(e) for e in semantic_errors],
+                        success=False,
+                    )
+
+            # Step 5: Lowered core to Python
+            generator = PythonCodeGenerator()
+            python_source = generator.generate(core_program)
+
+            # Step 6: Execute
+            return self._exec_python(
+                python_source, detected_language,
+                capture_output, globals_dict
+            )
+
+        except (CodeGenerationError, RuntimeExecutionError) as exc:
+            return ExecutionResult(
+                errors=[str(exc)],
+                success=False,
+            )
+        except Exception as exc:
+            return ExecutionResult(
+                errors=[f"{type(exc).__name__}: {exc}"],
+                success=False,
+            )
+
+    def transpile(self, source):
+        """
+        Transpile multilingual source to Python without executing.
+
+        Args:
+            source: Multilingual source code string.
+
+        Returns:
+            Python source code string.
+
+        Raises:
+            Various exceptions on lex/parse/codegen errors.
+        """
+        core_program = self.to_core_ir(source)
+        generator = PythonCodeGenerator()
+        return generator.generate(core_program)
+
+    def to_core_ir(self, source):
+        """Compile source into the typed core representation."""
+        lexer = Lexer(source, language=self.language)
+        tokens = lexer.tokenize()
+        detected_language = lexer.language or self.language or "en"
+
+        parser = Parser(tokens, source_language=detected_language)
+        program = parser.parse()
+        return lower_to_core_ir(
+            program, detected_language, frontend_name="lexer_parser"
+        )
+
+    def _exec_python(self, python_source, language,
+                     capture_output, globals_dict):
+        """Compile and execute generated Python code."""
+        enable_multilingual_imports()
+
+        # Build execution namespace with builtins
+        builtins_ns = RuntimeBuiltins(language).namespace()
+        exec_globals = dict(builtins_ns)
+
+        if globals_dict:
+            exec_globals.update(globals_dict)
+
+        # Compile for better error reporting
+        try:
+            code = compile(python_source, "<multilingual>", "exec")
+        except SyntaxError as exc:
+            return ExecutionResult(
+                python_source=python_source,
+                errors=[f"Generated Python has syntax error: {exc}"],
+                success=False,
+            )
+
+        # Execute with optional output capture
+        output = ""
+        if capture_output:
+            captured = io.StringIO()
+            old_stdout = sys.stdout
+            try:
+                sys.stdout = captured
+                exec(code, exec_globals)  # pylint: disable=exec-used
+                output = captured.getvalue()
+            except Exception as exc:
+                output = captured.getvalue()
+                return ExecutionResult(
+                    output=output,
+                    python_source=python_source,
+                    errors=[f"{type(exc).__name__}: {exc}"],
+                    success=False,
+                )
+            finally:
+                sys.stdout = old_stdout
+        else:
+            try:
+                exec(code, exec_globals)  # pylint: disable=exec-used
+            except Exception as exc:
+                return ExecutionResult(
+                    python_source=python_source,
+                    errors=[f"{type(exc).__name__}: {exc}"],
+                    success=False,
+                )
+
+        return ExecutionResult(
+            output=output,
+            python_source=python_source,
+            success=True,
+        )