indonesian_script 0.1.10__py3-none-any.whl

indonesian_script/Interpreter/AST_node/__init__.py

@@ -0,0 +1,2 @@
+# AST Node module
+from .ast_nodes import *

indonesian_script/Interpreter/AST_node/ast_nodes.py

@@ -0,0 +1,267 @@
+# ast_nodes.py
+from dataclasses import dataclass, field
+from typing import Any, Dict, Tuple, List, Optional, Union
+
+class Node:
+    """Base class for all AST nodes."""
+    pass
+
+# --- Program & Blocks ---
+@dataclass
+class Program(Node):
+    statements: Optional[List['Statement']]
+
+@dataclass
+class Block(Node):
+    statements: Optional[List['Statement']]
+
+# --- Statements ---
+class Statement(Node):
+    pass
+
+@dataclass
+class VarDecl(Statement):
+    type_ann: 'Type'
+    name: str
+    value: Optional['Expression']
+
+@dataclass
+class FinalDecl(Statement):
+    type_ann: 'Type'
+    name: str
+    value: 'Expression'
+
+@dataclass
+class DefDecl(Statement):
+    type_ann: 'Type'
+    name: str
+
+@dataclass
+class AliasDecl(Statement):
+    alias: str
+    target: str
+
+@dataclass
+class Redecl(Statement):
+    name: str
+    value: 'Expression'
+
+@dataclass
+class PointerDecl(Statement):
+    name: str
+    target: str
+
+@dataclass
+class UnpointerDecl(Statement):
+    name: str
+    target: str
+
+@dataclass
+class WriteStmt(Statement):
+    target: str
+
+@dataclass
+class ReadStmt(Statement):
+    expr: 'Expression'
+
+@dataclass
+class CtrlFlow(Statement):
+    pass
+
+@dataclass
+class IfCtrl(CtrlFlow):
+    if_stmt: 'IfStmt'
+    elif_stmt: Optional[List['ElifStmt']]
+    else_stmt: Optional['ElseStmt']
+
+@dataclass
+class IfStmt(CtrlFlow):
+    condition: 'Expression'
+    body: Block
+    
+@dataclass
+class ElifStmt(CtrlFlow):
+    condition: 'Expression'
+    body: Block
+
+@dataclass
+class ElseStmt(CtrlFlow):
+    body: Block
+
+@dataclass
+class WhileStmt(CtrlFlow):
+    condition: 'Expression'
+    body: Block
+
+@dataclass
+class ForStmt(CtrlFlow):
+    expr: 'ForExpr'
+    body: Block
+
+@dataclass
+class ForExpr(CtrlFlow):
+    name: str
+    target: List[Any]
+
+@dataclass
+class TryCtrl(CtrlFlow):
+    try_stmt: 'TryStmt'
+    catch_stmt: 'CatchStmt'
+    finnaly_stmt: Optional['FinnalyStmt']
+
+@dataclass
+class TryStmt(CtrlFlow):
+    body: Block
+
+@dataclass
+class CatchStmt(CtrlFlow):
+    name: str
+    body: Block
+
+@dataclass
+class FinallyStmt(CtrlFlow):
+    body: Block
+
+# --- Expressions ---
+class Expression(Node):
+    pass
+
+@dataclass
+class BinaryOp(Expression):
+    op: str  # '+', '-', '*', '/', '%', '==', '!=', '>=', '>', '<=', '<', 'dan', 'atau', 'dalam', 'tidak dalam'
+    left: Expression
+    right: Expression
+
+@dataclass
+class UnaryOp(Expression):
+    op: str  # 'tidak'
+    expr: Expression
+
+@dataclass
+class Literal(Expression):
+    value: Any
+
+@dataclass
+class Variable(Expression):
+    name: str
+    value: Any = None
+
+@dataclass
+class GetAttr(Expression):
+    obj: Expression
+    attr: str
+
+@dataclass
+class GetIndex(Expression):
+    obj: Expression
+    index: Expression
+
+@dataclass
+class CallFunc(Expression):
+    func: Expression
+    params: 'CallParameter'
+
+@dataclass
+class CallParameter(Expression):
+    args: List['CallArgument']
+
+@dataclass
+class CallArgument(Expression):
+    name: Optional[str]
+    value: Expression
+
+@dataclass
+class LambdaFunc(Expression):
+    params: 'Parameter'
+    expr: Expression
+
+@dataclass
+class TypeOf(Expression):
+    var: Variable
+
+@dataclass
+class IsStmt(Expression):  # sebenarnya ini expression boolean
+    left: str
+    right: str
+    negated: bool = False
+
+
+# --- Functions ---
+class FunctionNode(Node):
+    "Untuk attribute dan kerangka function"
+    pass
+
+@dataclass
+class Function(FunctionNode):
+    type_ann: 'Type'
+    name: str
+    params: 'Parameter'
+    inner: 'Block'
+
+@dataclass
+class Parameter(FunctionNode):
+    args: List['Argument']
+
+@dataclass
+class Generic(FunctionNode):
+    args: Optional[List['Argument']]
+
+@dataclass
+class Argument(FunctionNode):
+    type_ann: 'Type'
+    name: str
+    value: Optional[Expression] = None
+
+@dataclass
+class Return(Expression):
+    expr: Expression
+
+@dataclass
+class Throw(Expression):
+    name: str
+    expr: Expression
+
+# --- Module ---
+class Module(Node):
+    """Dataclass terkait module"""
+    pass
+
+@dataclass
+class Export(Module):
+    exports: List['ExportArgument']
+
+@dataclass
+class ExportArgument(Module):
+    name: Variable
+    alias: Optional[str]
+
+@dataclass
+class Import(Module):
+    imports: List['ImportArgument']
+    from_path: 'PathID'
+
+@dataclass
+class ImportArgument(Module):
+    name: str
+    alias: Optional[str]
+
+@dataclass
+class PathID(Module):
+    path: List['PathArg']
+
+@dataclass
+class PathArg(Module):
+    arg: str
+
+# --- Types ---
+class Type(Node):
+    pass
+
+@dataclass
+class BasicType(Type):
+    name: str  # 'teks', 'angka', dll.
+
+@dataclass
+class ArrayType(Type):
+    length: int  # 0 untuk dinamis
+    element_type: Type

indonesian_script/Interpreter/Builtins/KEYWORD.py

@@ -0,0 +1,96 @@
+from decimal import Decimal
+
+class kekosongan(object):
+    def __call__(cls, isi=''):
+        return not bool(isi)
+    def __repr__(self):
+        return '<tipe \'kekosongan\'>'
+    
+    @staticmethod
+    def __instancecheck__(instance, /):
+        return isinstance(instance, kekosongan)
+
+class kosong(kekosongan):
+    def __init__(self):
+        pass
+    def __repr__(self):
+        return 'kosong'
+    def __str__(self):
+        return ''
+    def __int__(self):
+        return 0
+    def __float__(self):
+        return 0.0
+    def __bool__(self):
+        return False
+    def __eq__(self, value, /):
+        return bool(kosong == value) or bool(None == value)
+    def __ne__(self, value, /):
+        return not self.__eq__(value)
+
+class tipe(type):
+    "tipe utama"
+    pass
+
+class teks(tipe, str):
+    "string"
+    pass
+
+class desimal(tipe, Decimal):
+    pass
+
+class angka(tipe, int):
+    pass
+
+class kondisi(tipe):
+    "boolean"
+    __value__ = benar
+    def __call__(cls, value=benar):
+        if value:
+            return benar
+        else:
+            return salah
+    
+    @staticmethod
+    def __instancecheck__(instance, /):
+        return isinstance(kondisi, instance)
+    
+    def __repr__(self):
+        return "<tipe 'kondisi'>"
+
+class salah:
+    def __init__(self):
+        pass
+    def __repr__(self):
+        return 'salah'
+    def __str__(self):
+        return 'benar'
+    def __int__(self):
+        return 0
+    def __float__(self):
+        return 0.0
+    def __bool__(self):
+        return False
+    def __eq__(self, value, /):
+        return bool(salah == value) or bool(False == value)
+    def __ne__(self, value, /):
+        return not self.__eq__(value)
+
+class benar:
+    def __init__(self):
+        pass
+    def __repr__(self):
+        return 'benar'
+    def __str__(self):
+        return 'benar'
+    def __int__(self):
+        return 1
+    def __float__(self):
+        return 1.0
+    def __bool__(self):
+        return True
+    def __eq__(self, value, /):
+        return bool(benar == value) or bool(True == value)
+    def __ne__(self, value, /):
+        return not self.__eq__(value)
+

indonesian_script/Interpreter/Builtins/TYPES.py

@@ -0,0 +1,28 @@
+
+class teks(str):
+    def __init__(self, chrs='', /):
+        self._chrs = str(chrs)
+    
+    def kapitalkan(self, /):
+        return self._chrs.capitalize()
+    
+    def simpul(self, /):
+        return self._chrs.casefold()
+    
+    def ditengah(self, panjang, pengisi=' ', /):
+        return self._chrs.center(panjang, pengisi)
+    
+    def hitung(self, args, /):
+        if isinstance(args, str):
+            return self._chrs.count(args)
+        elif isinstance(args, (list, set, tuple)):
+            result = []
+            for arg in args:
+                if not isinstance(arg, str):
+                    raise TypeError(f"must be str, not {type(arg).__name__}")
+                result.append(self._chrs(arg))
+            return result
+        else:
+            raise TypeError(f"must be str, not {type(arg).__name__}")
+    
+    def diakhiri(self, )

indonesian_script/Interpreter/Builtins/__init__.py

@@ -0,0 +1,2 @@
+# Builtins module
+from .builtins import BUILTINS, TYPES, get_builtin_type

indonesian_script/Interpreter/Builtins/builtins.py

@@ -0,0 +1,140 @@
+# builtins.py
+from ..Exceptions.Exceptions import VariabelGalat, FinalGalat, TipeGalat
+from ..AST_node.ast_nodes import BasicType
+from decimal import Decimal
+TYPES = {
+    'teks': str,
+    'angka': int,
+    'desimal': Decimal,
+    'boolean': bool,
+    'kekosongan': type(None),
+    'apapun': object,
+    'daftar': list,
+    'kamus': dict,
+    'fungsi': callable,
+    'pointer': str,
+    'tipe': type,
+}
+
+BUILTINS = {
+    'benar': True,
+    'salah': False,
+    'kosong': None,
+    'enter': '\n',
+    'tab': '\t',
+    'format': lambda val, **kwargs: str(val).format(**kwargs),
+    'tampilkan': print,
+    **TYPES
+}
+
+def get_builtin_type(name):
+    return TYPES.get(name, object)
+
+def builtins_fungsi(self, function_name=None, /, *, type_ann=None, body=None):
+    """
+    builtins_fungsi: untuk manipulasi fungsi
+    - Jika hanya function_name: return apakah itu fungsi
+    - Jika dengan type_ann dan body: buat fungsi baru
+    """
+    if function_name is None:
+        # Return semua fungsi yang ada
+        return {name: info for name, info in self.current_scope.vars.items() 
+                if info['type'].name == 'fungsi'}
+    
+    try:
+        obj = self.current_scope.get(function_name)
+        is_func = callable(obj['value'])
+        
+        if type_ann is not None and body is not None:
+            # Buat fungsi baru
+            def new_func(*args, **kwargs):
+                result = body(*args, **kwargs)
+                if type_ann != 'apapun':
+                    expected = TYPES.get(type_ann, object)
+                    if not isinstance(result, expected):
+                        raise TipeGalat(f"Fungsi harus mengembalikan tipe {type_ann}")
+                return result
+            
+            self.current_scope.declare(
+                function_name,
+                new_func,
+                BasicType('fungsi'),
+                hex(id(new_func)),
+                True
+            )
+            return True
+        
+        return is_func
+        
+    except VariabelGalat:
+        return False
+
+def builtins_vars(self, name=None, /, *, value=None, type_ann=None, constant=False):
+    """
+    builtins_vars: untuk manipulasi variabel
+    - Tanpa argumen: return semua variabel
+    - Dengan name saja: return apakah variabel ada
+    - Dengan name dan value: buat/ubah variabel
+    """
+    if name is None:
+        # Return semua variabel
+        return {n: {
+            'value': info['value'],
+            'type': info['type'].name if isinstance(info['type'], BasicType) else str(info['type']),
+            'constant': info['constant']
+        } for n, info in self.current_scope.vars.items()}
+    
+    if value is None:
+        # Cek apakah variabel ada
+        ada = self.current_scope.has(name)
+        return ada
+    
+    # Buat atau ubah variabel
+    try:
+        # Cek apakah sudah ada
+        obj = self.current_scope.get(name)
+        
+        # Validasi konstanta
+        if obj['constant'] and not constant:
+            raise FinalGalat(f"Variabel '{name}' adalah final")
+        
+        # Validasi tipe
+        if type_ann:
+            expected = TYPES.get(type_ann, object)
+            if not isinstance(value, expected):
+                raise TipeGalat(f"Nilai tidak sesuai tipe {type_ann}")
+        else:
+            type_ann = obj['type'].name if isinstance(obj['type'], BasicType) else 'apapun'
+        
+        # Update
+        self.current_scope.set(
+            name,
+            value,
+            BasicType(type_ann),
+            hex(id(value)),
+            constant or obj['constant']
+        )
+        
+    except VariabelGalat:
+        # Buat baru
+        if type_ann is None:
+            type_ann = 'apapun'
+        else:
+            expected = TYPES.get(type_ann, object)
+            if not isinstance(value, expected):
+                raise TipeGalat(f"Nilai tidak sesuai tipe {type_ann}")
+        
+        self.current_scope.declare(
+            name,
+            value,
+            BasicType(type_ann),
+            hex(id(value)),
+            constant
+        )
+    
+    return True
+
+BUILTINS_FUNCTIONS = {
+    'Fungsi': builtins_fungsi,
+    'Variabel': builtins_vars
+}

indonesian_script/Interpreter/__init__.py

@@ -0,0 +1,4 @@
+# Interpreter module
+from .interpreter import Interpreter
+from .transformer import ASTBuilder as Loader
+from .AST_node import ast_nodes as AST