indlan 0.1.0__tar.gz

indlan-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bhavya S Solanki
+
+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 NONINFRINGEMENT. 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.

indlan-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: indlan
+Version: 0.1.0
+Summary: IndLan - a Hindi-inspired programming language implemented in Python
+Author: Bhavya S Solanki
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/indlan
+Project-URL: Bug Tracker, https://github.com/yourusername/indlan/issues
+Keywords: indlan,programming-language,interpreter,hindi,hinglish,education
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Topic :: Education
+Classifier: Natural Language :: Hindi
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# IndLan
+
+IndLan is a small Hindi-inspired programming language, implemented as a
+tree-walking interpreter in pure Python. It supports familiar constructs
+(variables, functions, conditionals, loops, classes) using either
+English keywords or their Hindi-style aliases (e.g. `maano` for `let`,
+`agar` for `if`, `jabtak` for `while`).
+
+Made by Bhavya S Solanki.
+
+## Install
+
+```bash
+pip install indlan
+```
+
+## Usage
+
+Run a `.ind` file:
+
+```bash
+indlan myprogram.ind
+```
+
+Start an interactive REPL:
+
+```bash
+indlan
+```
+
+Launch the desktop IDE (Tkinter-based code editor):
+
+```bash
+indlan-ide
+```
+
+Check the version:
+
+```bash
+indlan --version
+```
+
+## Example
+
+```
+maano naam = "Duniya"
+kaam namaste(naam) {
+    vapas "Namaste, " + naam + "!"
+}
+print(namaste(naam))
+```
+
+## License
+
+MIT

indlan-0.1.0/README.md

@@ -0,0 +1,55 @@
+# IndLan
+
+IndLan is a small Hindi-inspired programming language, implemented as a
+tree-walking interpreter in pure Python. It supports familiar constructs
+(variables, functions, conditionals, loops, classes) using either
+English keywords or their Hindi-style aliases (e.g. `maano` for `let`,
+`agar` for `if`, `jabtak` for `while`).
+
+Made by Bhavya S Solanki.
+
+## Install
+
+```bash
+pip install indlan
+```
+
+## Usage
+
+Run a `.ind` file:
+
+```bash
+indlan myprogram.ind
+```
+
+Start an interactive REPL:
+
+```bash
+indlan
+```
+
+Launch the desktop IDE (Tkinter-based code editor):
+
+```bash
+indlan-ide
+```
+
+Check the version:
+
+```bash
+indlan --version
+```
+
+## Example
+
+```
+maano naam = "Duniya"
+kaam namaste(naam) {
+    vapas "Namaste, " + naam + "!"
+}
+print(namaste(naam))
+```
+
+## License
+
+MIT

indlan-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "indlan"
+version = "0.1.0"
+description = "IndLan - a Hindi-inspired programming language implemented in Python"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Bhavya S Solanki" }
+]
+keywords = ["indlan", "programming-language", "interpreter", "hindi", "hinglish", "education"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Interpreters",
+    "Topic :: Education",
+    "Natural Language :: Hindi",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/indlan"
+"Bug Tracker" = "https://github.com/yourusername/indlan/issues"
+
+[project.scripts]
+indlan = "indlan.cli:main"
+indlan-ide = "indlan.ide:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+indlan = ["examples/*.ind", "*.png", "*.ico"]

indlan-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

indlan-0.1.0/src/indlan/__init__.py

@@ -0,0 +1,21 @@
+"""
+IndLan - A Hindi-inspired programming language, implemented in Python.
+
+Made by Bhavya S Solanki.
+"""
+
+__version__ = "0.1.0"
+
+from .lexer import tokenize, LexError
+from .ind_parser import parse, ParseError
+from .interpreter import Interpreter, IndLanRuntimeError
+
+__all__ = [
+    "tokenize",
+    "LexError",
+    "parse",
+    "ParseError",
+    "Interpreter",
+    "IndLanRuntimeError",
+    "__version__",
+]

indlan-0.1.0/src/indlan/ast_nodes.py

@@ -0,0 +1,181 @@
+class Node:
+    pass
+
+
+# ---------- Expressions ----------
+
+class NumberLit(Node):
+    def __init__(self, value, line):
+        self.value = value
+        self.line = line
+
+class StringLit(Node):
+    def __init__(self, value, line):
+        self.value = value
+        self.line = line
+
+class FStringLit(Node):
+    """f"hello {name}" — parts is list of ("str", text) | ("expr", expr_source)"""
+    def __init__(self, parts, line):
+        self.parts = parts
+        self.line = line
+
+class BoolLit(Node):
+    def __init__(self, value, line):
+        self.value = value
+        self.line = line
+
+class NullLit(Node):
+    def __init__(self, line):
+        self.line = line
+
+class ListLit(Node):
+    def __init__(self, elements, line):
+        self.elements = elements
+        self.line = line
+
+class DictLit(Node):
+    def __init__(self, pairs, line):
+        self.pairs = pairs  # list of (key_node, value_node)
+        self.line = line
+
+class Identifier(Node):
+    def __init__(self, name, line):
+        self.name = name
+        self.line = line
+
+class BinOp(Node):
+    def __init__(self, op, left, right, line):
+        self.op = op
+        self.left = left
+        self.right = right
+        self.line = line
+
+class UnaryOp(Node):
+    def __init__(self, op, operand, line):
+        self.op = op
+        self.operand = operand
+        self.line = line
+
+class LogicalOp(Node):
+    def __init__(self, op, left, right, line):
+        self.op = op
+        self.left = left
+        self.right = right
+        self.line = line
+
+class Assign(Node):
+    def __init__(self, target, value, line, op="="):
+        self.target = target
+        self.value = value
+        self.op = op
+        self.line = line
+
+class Call(Node):
+    def __init__(self, callee, args, line):
+        self.callee = callee
+        self.args = args
+        self.line = line
+
+class Index(Node):
+    def __init__(self, obj, index, line):
+        self.obj = obj
+        self.index = index
+        self.line = line
+
+class GetAttr(Node):
+    def __init__(self, obj, name, line):
+        self.obj = obj
+        self.name = name
+        self.line = line
+
+class FunctionExpr(Node):
+    """Anonymous function (used internally for fun declarations too)."""
+    def __init__(self, params, body, line, name=None):
+        self.params = params
+        self.body = body
+        self.line = line
+        self.name = name
+
+
+# ---------- Statements ----------
+
+class LetStmt(Node):
+    def __init__(self, name, value, line):
+        self.name = name
+        self.value = value
+        self.line = line
+
+class ExprStmt(Node):
+    def __init__(self, expr, line):
+        self.expr = expr
+        self.line = line
+
+class Block(Node):
+    def __init__(self, statements, line):
+        self.statements = statements
+        self.line = line
+
+class IfStmt(Node):
+    def __init__(self, branches, else_block, line):
+        # branches: list of (condition, block)
+        self.branches = branches
+        self.else_block = else_block
+        self.line = line
+
+class WhileStmt(Node):
+    def __init__(self, condition, body, line):
+        self.condition = condition
+        self.body = body
+        self.line = line
+
+class DoWhileStmt(Node):
+    def __init__(self, body, condition, line):
+        self.body = body
+        self.condition = condition
+        self.line = line
+
+class SwitchStmt(Node):
+    def __init__(self, subject, cases, default_block, line):
+        # cases: list of (value_expr, block)
+        self.subject = subject
+        self.cases = cases
+        self.default_block = default_block
+        self.line = line
+
+class ForStmt(Node):
+    def __init__(self, var_name, iterable, body, line):
+        self.var_name = var_name
+        self.iterable = iterable
+        self.body = body
+        self.line = line
+
+class FunDecl(Node):
+    def __init__(self, name, params, body, line):
+        self.name = name
+        self.params = params
+        self.body = body
+        self.line = line
+
+class ReturnStmt(Node):
+    def __init__(self, value, line):
+        self.value = value
+        self.line = line
+
+class BreakStmt(Node):
+    def __init__(self, line):
+        self.line = line
+
+class ContinueStmt(Node):
+    def __init__(self, line):
+        self.line = line
+
+class ClassDecl(Node):
+    def __init__(self, name, methods, line):
+        self.name = name
+        self.methods = methods  # list of FunDecl
+        self.line = line
+
+class Program(Node):
+    def __init__(self, statements):
+        self.statements = statements

indlan-0.1.0/src/indlan/cli.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+IndLan - A programming language implemented in Python.
+
+Usage:
+    indlan myprogram.ind     # run a file
+    indlan                   # start REPL
+    indlan --version         # show version
+"""
+
+import sys
+import os
+
+from . import __version__
+from .lexer import tokenize, LexError
+from .ind_parser import parse, ParseError
+from .interpreter import Interpreter, IndLanRuntimeError
+
+
+def print_banner():
+    lines = [
+        "Welcome to IndLan",
+        "Made by Bhavya S Solanki",
+    ]
+    width = max(len(line) for line in lines) + 4
+    top = "+" + "-" * (width - 2) + "+"
+    print(top)
+    for line in lines:
+        padding = width - 2 - len(line)
+        left = padding // 2
+        right = padding - left
+        print("|" + " " * left + line + " " * right + "|")
+    print(top)
+
+
+def run_source(source, interpreter):
+    try:
+        tokens = tokenize(source)
+        program = parse(tokens)
+        interpreter.run(program)
+    except LexError as e:
+        print(e, file=sys.stderr)
+    except ParseError as e:
+        print(e, file=sys.stderr)
+    except IndLanRuntimeError as e:
+        print(e, file=sys.stderr)
+
+
+def run_file(path):
+    if not os.path.exists(path):
+        print(f"IndLan: file not found: {path}", file=sys.stderr)
+        sys.exit(1)
+    print_banner()
+    with open(path, "r", encoding="utf-8") as f:
+        source = f.read()
+    interpreter = Interpreter()
+    run_source(source, interpreter)
+
+
+def repl():
+    print_banner()
+    print("IndLan REPL (type 'exit' to quit)")
+    interpreter = Interpreter()
+    while True:
+        try:
+            line = input("indlan> ")
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if line.strip() in ("exit", "quit"):
+            break
+        if not line.strip():
+            continue
+        run_source(line, interpreter)
+
+
+def main():
+    args = sys.argv[1:]
+    if args and args[0] in ("-v", "--version"):
+        print(f"IndLan {__version__}")
+        return
+    if args and args[0] in ("-h", "--help"):
+        print(__doc__)
+        return
+    if args:
+        run_file(args[0])
+    else:
+        repl()
+
+
+if __name__ == "__main__":
+    main()

indlan-0.1.0/src/indlan/examples/examples_hindi.ind

@@ -0,0 +1,70 @@
+// IndLan Hindi keyword test - agar/nahito, jabtak, pratyek, karo-jabtak, vibhag
+
+maano umar = 20
+
+agar umar < 13 {
+    chhap("Bachha ho")
+} nahito_agar umar < 20 {
+    chhap("Teenager ho")
+} nahito {
+    chhap("Adult ho")
+}
+
+chhap("== jabtak loop ==")
+maano i = 0
+jabtak i < 5 {
+    chhap("i =", i)
+    i += 1
+}
+
+chhap("== pratyek loop ==")
+pratyek n mein range(5) {
+    agar n == 3 {
+        jaari
+    }
+    chhap("n =", n)
+}
+
+chhap("== karo-jabtak (do-while) ==")
+maano j = 0
+karo {
+    chhap("j =", j)
+    j += 1
+} jabtak j < 3
+
+chhap("== vibhag (switch) ==")
+maano din = 3
+vibhag din {
+    sthiti 1 {
+        chhap("Somvaar")
+    }
+    sthiti 2 {
+        chhap("Mangalvaar")
+    }
+    sthiti 3 {
+        chhap("Budhvaar")
+    }
+    anyatha {
+        chhap("Pata nahi")
+    }
+}
+
+chhap("== function aur class ==")
+kaam jodo(a, b) {
+    vapas a + b
+}
+chhap("jodo(4, 5) =", jodo(4, 5))
+
+varg Animal {
+    kaam init(naam, awaaz) {
+        yeh.naam = naam
+        yeh.awaaz = awaaz
+    }
+    kaam bolo() {
+        chhap(yeh.naam, "bolta hai", yeh.awaaz)
+    }
+}
+maano kutta = naya Animal("Kutta", "Bhow")
+kutta.bolo()
+
+chhap("Sab kaam ho gaya!")

indlan-0.1.0/src/indlan/examples/examples_ifelse.ind

@@ -0,0 +1,24 @@
+// if / elif / else example in IndLan
+
+let age = 20
+
+if age < 13 {
+    print("You are a child")
+} elif age < 20 {
+    print("You are a teenager")
+} else {
+    print("You are an adult")
+}
+
+// another example with score grading
+let score = 75
+
+if score >= 90 {
+    print("Grade: A")
+} elif score >= 75 {
+    print("Grade: B")
+} elif score >= 50 {
+    print("Grade: C")
+} else {
+    print("Grade: F")
+}

indlan-0.1.0/src/indlan/examples/examples_new_features.ind

@@ -0,0 +1,97 @@
+// IndLan - New Features Showcase
+// ================================
+
+// 1. Exponentiation (**)
+print("== Exponentiation ==")
+let base = 2
+let power = 10
+print(f"{base} ** {power} = {base ** power}")
+print("3 ** 3 =", 3 ** 3)
+
+// 2. F-strings
+print("\n== F-strings ==")
+let name = "Bhavya"
+let age = 17
+print(f"Hello {name}, you are {age} years old!")
+print(f"Next year you will be {age + 1}.")
+maano dost = "Rahul"
+chhap(f"Namaste {dost}! Kya haal hai?")
+
+// 3. input_int / input_float / input_bool / char
+// (uncomment to test interactively)
+// let n = input_int("Enter a number: ")
+// print(f"You entered: {n}, doubled: {n * 2}")
+// let b = input_bool("Are you happy? (true/false): ")
+// print(f"Happy: {b}")
+
+// 4. bool() and char()
+print("\n== bool() and char() ==")
+print("bool(0) =", bool(0))
+print("bool(42) =", bool(42))
+print("bool(\"\") =", bool(""))
+print("bool(\"hi\") =", bool("hi"))
+print("char(65) =", char(65))
+print("char(97) =", char(97))
+print("char('Z') =", char("Z"))
+
+// 5. Math builtins
+print("\n== Math ==")
+print("abs(-42) =", abs(-42))
+print("sqrt(144) =", sqrt(144))
+print("floor(3.9) =", floor(3.9))
+print("ceil(3.1) =", ceil(3.1))
+print("round(3.567, 2) =", round(3.567, 2))
+print("max(1, 9, 3) =", max(1, 9, 3))
+print("min([5, 2, 8]) =", min([5, 2, 8]))
+
+// 6. String methods
+print("\n== String Methods ==")
+let s = "  Hello, IndLan World!  "
+print(s.strip())
+print(s.strip().lower())
+print(s.strip().upper())
+print(s.strip().replace("World", "India"))
+print(s.strip().startswith("Hello"))
+print(s.strip().endswith("!"))
+let words = "apple,banana,cherry"
+let parts = words.split(",")
+print("split:", parts)
+print("find 'banana':", words.find("banana"))
+
+// 7. List methods
+print("\n== List Methods ==")
+let nums = [5, 3, 8, 1, 4]
+sort(nums)
+print("sorted:", nums)
+reverse(nums)
+print("reversed:", nums)
+insert(nums, 0, 100)
+print("after insert(0, 100):", nums)
+remove(nums, 100)
+print("after remove(100):", nums)
+print("has(nums, 8):", has(nums, 8))
+print("has(nums, 99):", has(nums, 99))
+
+// 8. String repetition and negative index
+print("\n== String repeat & negative index ==")
+print("ha" * 4)
+let arr = [10, 20, 30, 40, 50]
+print("arr[-1] =", arr[-1])
+print("arr[-2] =", arr[-2])
+
+// 9. type()
+print("\n== type() ==")
+print(type(42))
+print(type(3.14))
+print(type("hello"))
+print(type(true))
+print(type([1, 2]))
+print(type({"a": 1}))
+print(type(null))
+
+// 10. has() on dict and string
+print("\n== has() on dicts and strings ==")
+let d = {"x": 1, "y": 2}
+print("has(d, 'x'):", has(d, "x"))
+print("has(d, 'z'):", has(d, "z"))
+print("has('IndLan', 'Lan'):", has("IndLan", "Lan"))