multilingualprogramming 0.2.0__py3-none-any.whl

multilingualprogramming/numeral/unicode_numeral.py

@@ -0,0 +1,292 @@
+#
+# SPDX-FileCopyrightText: 2022 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Functions to handle numbers of multiple languages
+"""
+
+import unicodedata
+import re
+import locale
+from operator import invert, neg
+from multilingualprogramming.exceptions import (
+    InvalidNumeralCharacterError,
+    MultipleLanguageCharacterMixError,
+)
+from multilingualprogramming.unicode_string import (
+    get_unicode_character_string,
+    convert_numeral_string,
+)
+from multilingualprogramming.numeral.abstract_numeral import AbstractNumeral
+
+
+class UnicodeNumeral(AbstractNumeral):
+    """
+    Handling numerals in unicode-supported languages
+    """
+
+    @classmethod
+    def __verify_unicode_category__(cls, self, numstr: str):
+        """
+        Verify the unicode category of each character
+        """
+        running_character_name = None
+        for character in numstr:
+            if unicodedata.category(character) != "Nd":
+                # Handle decimal separators of all locales
+                decimal_separator = locale.localeconv()["decimal_point"]
+                if character in decimal_separator or character in ["-"]:
+                    continue
+
+                raise InvalidNumeralCharacterError(
+                    "Not a valid number, contains the character: " + character
+                )
+            current_character_name = unicodedata.name(character)
+            current_character_name = re.sub(r" .*$", "", current_character_name)
+
+            if running_character_name is not None:
+                if running_character_name != current_character_name:
+                    self.language_name = None
+                    raise MultipleLanguageCharacterMixError(
+                        "Not a valid number, mix of characters from multiple scripts, found "
+                        + character
+                    )
+            else:
+                self.language_name = current_character_name
+                running_character_name = current_character_name
+
+    def __init__(self, numstr: str):
+        super().__init__(numstr)
+        self.numstr = numstr
+        self.language_name = None
+        self.__verify_unicode_category__(self, numstr)
+
+    def to_decimal(self):
+        """
+        Returns the number associated with the number string
+        given by the user
+
+        return:
+           number: number associated with the number string
+        """
+        decimal_separator = locale.localeconv()["decimal_point"]
+        self.numstr = self.numstr.replace(decimal_separator, ".")
+        try:
+            if "." in self.numstr:
+                return float(self.numstr)
+            return int(self.numstr)
+        except ValueError:
+            return None
+
+    def __str__(self):
+        """
+        Returns the original number string
+
+        return:
+           numstr: original number string
+        """
+        return self.numstr
+
+    def __repr__(self):
+        """
+        Returns the representation of an instance
+
+        return:
+           reprstr: representation of an instance
+        """
+        return f'UnicodeNumeral("{self.numstr}")'
+
+    def __add__(self, numeral):
+        """
+        Add a UnicodeNumeral with a numeral or another UnicodeNumeral
+
+        return:
+           UnicodeNumeral: returns the sum of a UnicodeNumeral
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() + numeral.to_decimal()
+            )
+        )
+
+    def __mul__(self, numeral):
+        """
+        Multiply a UnicodeNumeral with a numeral or another UnicodeNumeral
+
+        return:
+           UnicodeNumeral: multiplication of the two UnicodeNumeral values
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() * numeral.to_decimal()
+            )
+        )
+
+    def __lshift__(self, numeral):
+        """
+        Left-shifting of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the left shifted value
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() << numeral.to_decimal()
+            )
+        )
+
+    def __rshift__(self, numeral):
+        """
+        Right-shifting of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the right shifted value
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() >> numeral.to_decimal()
+            )
+        )
+
+    def __sub__(self, numeral):
+        """
+        Substraction of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the difference
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() - numeral.to_decimal()
+            )
+        )
+
+    def __truediv__(self, numeral):
+        """
+        True division of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the value after true division
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() / numeral.to_decimal()
+            )
+        )
+
+    def __floordiv__(self, numeral):
+        """
+        Floor division of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the value after floor division
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() // numeral.to_decimal()
+            )
+        )
+
+    def __neg__(self):
+        """
+        Negation of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the negation
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(self.language_name, neg(self.to_decimal()))
+        )
+
+    def __pow__(self, numeral):
+        """
+        Power of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the power
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() ** numeral.to_decimal()
+            )
+        )
+
+    def __mod__(self, numeral):
+        """
+        Modulus of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the modulus value
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() % numeral.to_decimal()
+            )
+        )
+
+    def __xor__(self, numeral):
+        """
+        XOR value of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the XOR value
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() ^ numeral.to_decimal()
+            )
+        )
+
+    def __invert__(self):
+        """
+        Bitwise inversion value of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the bitwise-inverted value
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(self.language_name, invert(self.to_decimal()))
+        )
+
+    def __or__(self, numeral):
+        """
+        OR value of Unicode Numerals
+
+        return:
+           AbstractNumeral: returns the OR value
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, self.to_decimal() | numeral.to_decimal()
+            )
+        )
+
+    def __abs__(self):
+        """
+        Absolute value of Unicode Numerals
+
+        return:
+           UnicodeNumeral: returns the absolute value
+        """
+        return UnicodeNumeral(
+            get_unicode_character_string(
+                self.language_name, abs(self.to_decimal())
+            )
+        )
+
+    def convert_to(self, target_language):
+        """
+        Convert this numeral to a different Unicode script.
+
+        Parameters:
+            target_language (str): Target language name (e.g., "ARABIC-INDIC")
+
+        Returns:
+            UnicodeNumeral: A new numeral in the target script
+        """
+        converted = convert_numeral_string(
+            self.numstr, self.language_name, target_language
+        )
+        return UnicodeNumeral(converted)

multilingualprogramming/parser/__init__.py

@@ -0,0 +1,28 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Parser subpackage for the multilingual programming language."""
+
+from multilingualprogramming.parser.ast_nodes import (
+    ASTNode, Program,
+    NumeralLiteral, StringLiteral, DateLiteral, BooleanLiteral,
+    NoneLiteral, ListLiteral, DictLiteral, SetLiteral, DictUnpackEntry,
+    Identifier, BinaryOp, UnaryOp, BooleanOp, CompareOp,
+    CallExpr, AttributeAccess, IndexAccess,
+    LambdaExpr, YieldExpr, AwaitExpr, NamedExpr, ConditionalExpr,
+    VariableDeclaration, Assignment, AnnAssignment, ExpressionStatement,
+    PassStatement, ReturnStatement, BreakStatement, ContinueStatement,
+    RaiseStatement, GlobalStatement, LocalStatement, YieldStatement,
+    IfStatement, WhileLoop, ForLoop, FunctionDef, ClassDef,
+    TryStatement, ExceptHandler, MatchStatement, CaseClause,
+    WithStatement, ImportStatement, FromImportStatement,
+)
+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