neuron-lang 1.0.0__tar.gz

neuron_lang-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: neuron-lang
+Version: 1.0.0
+Summary: AI-First Programming Language
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21.0
+Provides-Extra: full
+Requires-Dist: matplotlib>=3.5.0; extra == "full"
+Requires-Dist: Pillow>=9.0.0; extra == "full"

neuron_lang-1.0.0/neuron/__init__.py

@@ -0,0 +1,18 @@
+"""
+Neuron Programming Language
+===========================
+A Python-like, OOP-based programming language purpose-built for
+Artificial Intelligence development.
+
+File extension: .nl
+Website: https://neuron-lang.org (coming soon)
+
+Keywords: do, give, show, ask, when, orwhen, otherwise, each,
+          repeat, grab, entity, brain, me, create, yes, no,
+          nothing, also, either, nah, safe, rescue, stop, skip,
+          quick, within, drop, ensure, emit, shared, from, upto
+"""
+
+__version__ = "1.0.0"
+__author__ = "Neuron Language Team"
+__license__ = "MIT"

neuron_lang-1.0.0/neuron/ast_nodes.py

@@ -0,0 +1,414 @@
+"""
+Neuron AST Node Definitions
+============================
+All Abstract Syntax Tree node types for the Neuron language.
+Each node carries source location info for error reporting.
+"""
+
+
+class ASTNode:
+    """Base class for all AST nodes."""
+
+    def __init__(self, line=None, column=None):
+        self.line = line
+        self.column = column
+
+    def accept(self, visitor):
+        method_name = f"visit_{type(self).__name__}"
+        visitor_method = getattr(visitor, method_name, None)
+        if visitor_method:
+            return visitor_method(self)
+        return visitor.generic_visit(self)
+
+
+# ===== PROGRAM =====
+
+class Program(ASTNode):
+    """Root node: a list of statements."""
+
+    def __init__(self, statements, line=None, column=None):
+        super().__init__(line, column)
+        self.statements = statements
+
+
+# ===== STATEMENTS =====
+
+class ExpressionStatement(ASTNode):
+    """A standalone expression used as a statement."""
+
+    def __init__(self, expression, line=None, column=None):
+        super().__init__(line, column)
+        self.expression = expression
+
+
+class Assignment(ASTNode):
+    """Variable assignment: x = expr"""
+
+    def __init__(self, target, value, line=None, column=None):
+        super().__init__(line, column)
+        self.target = target
+        self.value = value
+
+
+class AugmentedAssignment(ASTNode):
+    """Augmented assignment: x += expr, x -= expr, etc."""
+
+    def __init__(self, target, op, value, line=None, column=None):
+        super().__init__(line, column)
+        self.target = target
+        self.op = op  # '+', '-', '*', '/'
+        self.value = value
+
+
+class MultiAssignment(ASTNode):
+    """Multiple assignment: a, b = expr1, expr2"""
+
+    def __init__(self, targets, values, line=None, column=None):
+        super().__init__(line, column)
+        self.targets = targets
+        self.values = values
+
+
+class FunctionDef(ASTNode):
+    """Function definition: do name(params): body"""
+
+    def __init__(self, name, params, defaults, body, line=None, column=None):
+        super().__init__(line, column)
+        self.name = name
+        self.params = params        # List of parameter names
+        self.defaults = defaults    # Dict of param_name -> default_value_expr
+        self.body = body            # List of statements
+
+
+class EntityDef(ASTNode):
+    """Entity (class) definition: entity Name [from Parent]: body"""
+
+    def __init__(self, name, parent, body, line=None, column=None):
+        super().__init__(line, column)
+        self.name = name
+        self.parent = parent   # Parent class name (string) or None
+        self.body = body       # List of statements (methods, assignments)
+
+
+class BrainDef(ASTNode):
+    """Brain (AI model) definition: brain Name [from Parent]: body"""
+
+    def __init__(self, name, parent, body, line=None, column=None):
+        super().__init__(line, column)
+        self.name = name
+        self.parent = parent
+        self.body = body
+
+
+class ReturnStatement(ASTNode):
+    """Return statement: give expr"""
+
+    def __init__(self, value=None, line=None, column=None):
+        super().__init__(line, column)
+        self.value = value
+
+
+class IfStatement(ASTNode):
+    """If statement: when condition: body [orwhen: ...] [otherwise: ...]"""
+
+    def __init__(self, condition, body, elif_clauses=None, else_body=None, line=None, column=None):
+        super().__init__(line, column)
+        self.condition = condition
+        self.body = body
+        self.elif_clauses = elif_clauses or []  # List of (condition, body) tuples
+        self.else_body = else_body              # List of statements or None
+
+
+class WhileLoop(ASTNode):
+    """While loop: repeat condition: body"""
+
+    def __init__(self, condition, body, line=None, column=None):
+        super().__init__(line, column)
+        self.condition = condition
+        self.body = body
+
+
+class ForLoop(ASTNode):
+    """For loop: each var within iterable: body"""
+
+    def __init__(self, variable, iterable, body, line=None, column=None):
+        super().__init__(line, column)
+        self.variable = variable   # Variable name (string)
+        self.iterable = iterable   # Expression
+        self.body = body
+
+
+class BreakStatement(ASTNode):
+    """Break: stop"""
+    pass
+
+
+class ContinueStatement(ASTNode):
+    """Continue: skip"""
+    pass
+
+
+class PassStatement(ASTNode):
+    """Pass/no-op: ..."""
+    pass
+
+
+class TryCatch(ASTNode):
+    """Try/catch: safe: body rescue ErrorType as name: handler"""
+
+    def __init__(self, body, rescue_clauses=None, line=None, column=None):
+        super().__init__(line, column)
+        self.body = body
+        self.rescue_clauses = rescue_clauses or []
+        # Each clause: (error_type_name, alias_name, handler_body)
+
+
+class GrabStatement(ASTNode):
+    """Import: grab module_name"""
+
+    def __init__(self, module_name, alias=None, items=None, line=None, column=None):
+        super().__init__(line, column)
+        self.module_name = module_name
+        self.alias = alias      # grab module as alias
+        self.items = items       # grab item from module
+
+
+class DropStatement(ASTNode):
+    """Delete: drop variable"""
+
+    def __init__(self, target, line=None, column=None):
+        super().__init__(line, column)
+        self.target = target
+
+
+class EnsureStatement(ASTNode):
+    """Assert: ensure condition, message"""
+
+    def __init__(self, condition, message=None, line=None, column=None):
+        super().__init__(line, column)
+        self.condition = condition
+        self.message = message
+
+
+class EmitStatement(ASTNode):
+    """Yield: emit value"""
+
+    def __init__(self, value=None, line=None, column=None):
+        super().__init__(line, column)
+        self.value = value
+
+
+class SharedStatement(ASTNode):
+    """Global: shared var_name"""
+
+    def __init__(self, names, line=None, column=None):
+        super().__init__(line, column)
+        self.names = names  # List of variable names
+
+
+# ===== EXPRESSIONS =====
+
+class NumberLiteral(ASTNode):
+    """Numeric literal: 42, 3.14"""
+
+    def __init__(self, value, line=None, column=None):
+        super().__init__(line, column)
+        self.value = value
+
+
+class StringLiteral(ASTNode):
+    """String literal: "hello" """
+
+    def __init__(self, value, line=None, column=None):
+        super().__init__(line, column)
+        self.value = value
+
+
+class FStringLiteral(ASTNode):
+    """Interpolated string: "hello {name}" """
+
+    def __init__(self, parts, line=None, column=None):
+        super().__init__(line, column)
+        self.parts = parts  # List of (type, value) where type is 'text' or 'expr'
+
+
+class BooleanLiteral(ASTNode):
+    """Boolean literal: yes, no"""
+
+    def __init__(self, value, line=None, column=None):
+        super().__init__(line, column)
+        self.value = value
+
+
+class NothingLiteral(ASTNode):
+    """Nothing literal: nothing"""
+
+    def __init__(self, line=None, column=None):
+        super().__init__(line, column)
+        self.value = None
+
+
+class ListLiteral(ASTNode):
+    """List literal: [1, 2, 3]"""
+
+    def __init__(self, elements, line=None, column=None):
+        super().__init__(line, column)
+        self.elements = elements
+
+
+class DictLiteral(ASTNode):
+    """Dict literal: {key: value, ...}"""
+
+    def __init__(self, pairs, line=None, column=None):
+        super().__init__(line, column)
+        self.pairs = pairs  # List of (key_expr, value_expr)
+
+
+class TupleLiteral(ASTNode):
+    """Tuple literal: (1, 2, 3)"""
+
+    def __init__(self, elements, line=None, column=None):
+        super().__init__(line, column)
+        self.elements = elements
+
+
+class Identifier(ASTNode):
+    """Variable reference: x"""
+
+    def __init__(self, name, line=None, column=None):
+        super().__init__(line, column)
+        self.name = name
+
+
+class MeExpression(ASTNode):
+    """Self reference: me"""
+
+    def __init__(self, line=None, column=None):
+        super().__init__(line, column)
+
+
+class BinaryOp(ASTNode):
+    """Binary operation: a + b, a * b, etc."""
+
+    def __init__(self, left, op, right, line=None, column=None):
+        super().__init__(line, column)
+        self.left = left
+        self.op = op      # '+', '-', '*', '/', '//', '%', '**'
+        self.right = right
+
+
+class UnaryOp(ASTNode):
+    """Unary operation: -x, nah x"""
+
+    def __init__(self, op, operand, line=None, column=None):
+        super().__init__(line, column)
+        self.op = op        # '-', 'nah'
+        self.operand = operand
+
+
+class ComparisonOp(ASTNode):
+    """Comparison: a == b, a < b, etc."""
+
+    def __init__(self, left, op, right, line=None, column=None):
+        super().__init__(line, column)
+        self.left = left
+        self.op = op     # '==', '!=', '<', '>', '<=', '>='
+        self.right = right
+
+
+class LogicalOp(ASTNode):
+    """Logical operation: a also b, a either b"""
+
+    def __init__(self, left, op, right, line=None, column=None):
+        super().__init__(line, column)
+        self.left = left
+        self.op = op      # 'also', 'either'
+        self.right = right
+
+
+class FunctionCall(ASTNode):
+    """Function call: name(args)"""
+
+    def __init__(self, callee, args, kwargs=None, line=None, column=None):
+        super().__init__(line, column)
+        self.callee = callee    # Expression (Identifier, PropertyAccess, etc.)
+        self.args = args        # List of expressions
+        self.kwargs = kwargs or {}  # Dict of name -> expression
+
+
+class PropertyAccess(ASTNode):
+    """Property/method access: obj.prop"""
+
+    def __init__(self, object, property, line=None, column=None):
+        super().__init__(line, column)
+        self.object = object
+        self.property = property  # String
+
+
+class IndexAccess(ASTNode):
+    """Index access: obj[index]"""
+
+    def __init__(self, object, index, line=None, column=None):
+        super().__init__(line, column)
+        self.object = object
+        self.index = index
+
+
+class SliceAccess(ASTNode):
+    """Slice access: obj[start:end:step]"""
+
+    def __init__(self, object, start, end, step=None, line=None, column=None):
+        super().__init__(line, column)
+        self.object = object
+        self.start = start
+        self.end = end
+        self.step = step
+
+
+class PipelineOp(ASTNode):
+    """Pipeline: expr |> func"""
+
+    def __init__(self, left, right, line=None, column=None):
+        super().__init__(line, column)
+        self.left = left
+        self.right = right    # Function call or identifier
+
+
+class QuickFunction(ASTNode):
+    """Lambda: quick(params): expr"""
+
+    def __init__(self, params, body, line=None, column=None):
+        super().__init__(line, column)
+        self.params = params
+        self.body = body  # Single expression
+
+
+class ListComprehension(ASTNode):
+    """List comprehension: [expr each var within iterable when condition]"""
+
+    def __init__(self, expression, variable, iterable, condition=None, line=None, column=None):
+        super().__init__(line, column)
+        self.expression = expression
+        self.variable = variable
+        self.iterable = iterable
+        self.condition = condition
+
+
+class AttributeAssignment(ASTNode):
+    """Attribute assignment: obj.attr = value"""
+
+    def __init__(self, object, attribute, value, line=None, column=None):
+        super().__init__(line, column)
+        self.object = object
+        self.attribute = attribute
+        self.value = value
+
+
+class IndexAssignment(ASTNode):
+    """Index assignment: obj[idx] = value"""
+
+    def __init__(self, object, index, value, line=None, column=None):
+        super().__init__(line, column)
+        self.object = object
+        self.index = index
+        self.value = value

neuron_lang-1.0.0/neuron/compiler.py

@@ -0,0 +1,191 @@
+"""
+Neuron Bytecode Compiler
+========================
+Compiles AST to bytecode and provides a VM for execution.
+"""
+
+import struct
+import pickle
+import os
+from enum import IntEnum, auto
+
+from neuron import ast_nodes as ast
+from neuron.lexer import Lexer
+from neuron.parser import Parser
+
+
+class OpCode(IntEnum):
+    LOAD_CONST = 0
+    LOAD_VAR = 1
+    STORE_VAR = 2
+    LOAD_ATTR = 3
+    STORE_ATTR = 4
+    BINARY_ADD = 10
+    BINARY_SUB = 11
+    BINARY_MUL = 12
+    BINARY_DIV = 13
+    BINARY_MOD = 14
+    BINARY_POW = 15
+    BINARY_FLOORDIV = 16
+    COMPARE_EQ = 20
+    COMPARE_NE = 21
+    COMPARE_LT = 22
+    COMPARE_GT = 23
+    COMPARE_LE = 24
+    COMPARE_GE = 25
+    COMPARE_IN = 26
+    UNARY_NEG = 30
+    UNARY_NOT = 31
+    JUMP = 40
+    JUMP_IF_FALSE = 41
+    JUMP_IF_TRUE = 42
+    CALL_FUNCTION = 50
+    RETURN_VALUE = 51
+    MAKE_FUNCTION = 52
+    MAKE_LIST = 53
+    MAKE_DICT = 54
+    GET_INDEX = 55
+    SET_INDEX = 56
+    POP_TOP = 60
+    DUP_TOP = 61
+    BUILD_CLASS = 62
+    PIPE = 63
+    IMPORT = 64
+    PRINT = 65
+    NOP = 99
+    HALT = 100
+
+
+class BytecodeChunk:
+    """A compiled chunk of bytecode."""
+    def __init__(self, name="<module>"):
+        self.name = name
+        self.code = []       # List of (opcode, operand) tuples
+        self.constants = []  # Constant pool
+        self.names = []      # Variable name pool
+        self.line_map = {}   # instruction_index -> source_line
+
+    def emit(self, opcode, operand=0, line=0):
+        idx = len(self.code)
+        self.code.append((opcode, operand))
+        self.line_map[idx] = line
+        return idx
+
+    def add_constant(self, value):
+        if value in self.constants:
+            return self.constants.index(value)
+        self.constants.append(value)
+        return len(self.constants) - 1
+
+    def add_name(self, name):
+        if name in self.names:
+            return self.names.index(name)
+        self.names.append(name)
+        return len(self.names) - 1
+
+    def patch_jump(self, offset, target=None):
+        """Patch a jump instruction's target."""
+        if target is None:
+            target = len(self.code)
+        opcode, _ = self.code[offset]
+        self.code[offset] = (opcode, target)
+
+
+class Compiler:
+    """Compiles Neuron AST to bytecode."""
+
+    def compile_file(self, input_path, output_path=None):
+        with open(input_path, 'r', encoding='utf-8') as f:
+            source = f.read()
+
+        chunk = self.compile_source(source, input_path)
+
+        if output_path is None:
+            output_path = input_path.replace('.nl', '.nlc')
+
+        with open(output_path, 'wb') as f:
+            pickle.dump(chunk, f)
+
+        return chunk
+
+    def compile_source(self, source, filename="<stdin>"):
+        lexer = Lexer(source, filename)
+        tokens = lexer.tokenize()
+        parser = Parser(tokens, source, filename)
+        program = parser.parse()
+
+        chunk = BytecodeChunk(filename)
+        self._compile_node(program, chunk)
+        chunk.emit(OpCode.HALT)
+        return chunk
+
+    def _compile_node(self, node, chunk):
+        method = f"_compile_{type(node).__name__}"
+        compiler = getattr(self, method, None)
+        if compiler:
+            return compiler(node, chunk)
+        # Fallback: skip unknown nodes
+        return
+
+    def _compile_Program(self, node, chunk):
+        for stmt in node.statements:
+            self._compile_node(stmt, chunk)
+
+    def _compile_NumberLiteral(self, node, chunk):
+        idx = chunk.add_constant(node.value)
+        chunk.emit(OpCode.LOAD_CONST, idx, node.line)
+
+    def _compile_StringLiteral(self, node, chunk):
+        idx = chunk.add_constant(node.value)
+        chunk.emit(OpCode.LOAD_CONST, idx, node.line)
+
+    def _compile_BooleanLiteral(self, node, chunk):
+        idx = chunk.add_constant(node.value)
+        chunk.emit(OpCode.LOAD_CONST, idx, node.line)
+
+    def _compile_NothingLiteral(self, node, chunk):
+        idx = chunk.add_constant(None)
+        chunk.emit(OpCode.LOAD_CONST, idx, node.line)
+
+    def _compile_Identifier(self, node, chunk):
+        idx = chunk.add_name(node.name)
+        chunk.emit(OpCode.LOAD_VAR, idx, node.line)
+
+    def _compile_Assignment(self, node, chunk):
+        self._compile_node(node.value, chunk)
+        idx = chunk.add_name(node.target)
+        chunk.emit(OpCode.STORE_VAR, idx, node.line)
+
+    def _compile_ExpressionStatement(self, node, chunk):
+        self._compile_node(node.expression, chunk)
+        chunk.emit(OpCode.POP_TOP)
+
+    def _compile_BinaryOp(self, node, chunk):
+        self._compile_node(node.left, chunk)
+        self._compile_node(node.right, chunk)
+        op_map = {
+            '+': OpCode.BINARY_ADD, '-': OpCode.BINARY_SUB,
+            '*': OpCode.BINARY_MUL, '/': OpCode.BINARY_DIV,
+            '%': OpCode.BINARY_MOD, '**': OpCode.BINARY_POW,
+            '//': OpCode.BINARY_FLOORDIV,
+        }
+        chunk.emit(op_map[node.op], 0, node.line)
+
+    def _compile_ComparisonOp(self, node, chunk):
+        self._compile_node(node.left, chunk)
+        self._compile_node(node.right, chunk)
+        op_map = {
+            '==': OpCode.COMPARE_EQ, '!=': OpCode.COMPARE_NE,
+            '<': OpCode.COMPARE_LT, '>': OpCode.COMPARE_GT,
+            '<=': OpCode.COMPARE_LE, '>=': OpCode.COMPARE_GE,
+            'within': OpCode.COMPARE_IN,
+        }
+        chunk.emit(op_map[node.op], 0, node.line)
+
+    def _compile_ReturnStatement(self, node, chunk):
+        if node.value:
+            self._compile_node(node.value, chunk)
+        else:
+            idx = chunk.add_constant(None)
+            chunk.emit(OpCode.LOAD_CONST, idx)
+        chunk.emit(OpCode.RETURN_VALUE, 0, node.line)