nebulara 2.0.0

package/Compiler/neb-semantic.c

@@ -0,0 +1,261 @@
+/*
+ * neb-semantic.c - Semantic Analysis Module for Nebulara
+ * 
+ * Phase 1: Symbol table construction and scope resolution
+ * Phase 2: Type checking and inference
+ * Phase 3: Error reporting with source locations
+ *
+ * Build: gcc -o neb-semantic.exe neb-semantic.c -static -O2
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Types */
+typedef enum {
+    TYPE_UNKNOWN = 0,
+    TYPE_INT,
+    TYPE_STRING,
+    TYPE_BOOL,
+    TYPE_ARRAY,
+    TYPE_NULL,
+    TYPE_FUNC,
+    TYPE_FUNC_REF
+} NebType;
+
+typedef struct {
+    char name[256];
+    NebType type;
+    int line;
+    int col;
+    int is_mutable;
+    int is_initialized;
+} Symbol;
+
+typedef struct Scope {
+    Symbol symbols[256];
+    int count;
+    struct Scope *parent;
+    char scope_name[128];
+} Scope;
+
+/* Global state */
+static Scope *current_scope = NULL;
+static int error_count = 0;
+static int warning_count = 0;
+
+/* Scope management */
+Scope *scope_create(const char *name, Scope *parent) {
+    Scope *s = (Scope *)calloc(1, sizeof(Scope));
+    strncpy(s->scope_name, name, 127);
+    s->parent = parent;
+    s->count = 0;
+    return s;
+}
+
+void scope_push(const char *name) {
+    current_scope = scope_create(name, current_scope);
+}
+
+void scope_pop() {
+    Scope *old = current_scope;
+    if (old && old->parent) {
+        current_scope = old->parent;
+    }
+    free(old);
+}
+
+/* Symbol operations */
+int symbol_define(const char *name, NebType type, int line, int col, int is_mutable) {
+    if (!current_scope) return -1;
+    if (current_scope->count >= 256) return -2;
+    
+    /* Check for duplicate in current scope */
+    for (int i = 0; i < current_scope->count; i++) {
+        if (strcmp(current_scope->symbols[i].name, name) == 0) {
+            fprintf(stderr, "SEMANTIC ERROR [%d:%d]: '%s' already defined in this scope\n",
+                    line, col, name);
+            error_count++;
+            return -3;
+        }
+    }
+    
+    Symbol *s = &current_scope->symbols[current_scope->count];
+    strncpy(s->name, name, 255);
+    s->type = type;
+    s->line = line;
+    s->col = col;
+    s->is_mutable = is_mutable;
+    s->is_initialized = 0;
+    current_scope->count++;
+    return 0;
+}
+
+Symbol *symbol_lookup(const char *name) {
+    Scope *s = current_scope;
+    while (s) {
+        for (int i = 0; i < s->count; i++) {
+            if (strcmp(s->symbols[i].name, name) == 0) {
+                return &s->symbols[i];
+            }
+        }
+        s = s->parent;
+    }
+    return NULL;
+}
+
+int symbol_resolve(const char *name, int line, int col) {
+    Symbol *s = symbol_lookup(name);
+    if (!s) {
+        fprintf(stderr, "SEMANTIC ERROR [%d:%d]: '%s' not defined\n", line, col, name);
+        error_count++;
+        return -1;
+    }
+    return 0;
+}
+
+/* Type checking */
+const char *type_name(NebType t) {
+    switch (t) {
+        case TYPE_INT:     return "int";
+        case TYPE_STRING:  return "string";
+        case TYPE_BOOL:    return "bool";
+        case TYPE_ARRAY:   return "array";
+        case TYPE_NULL:    return "null";
+        case TYPE_FUNC:
+        case TYPE_FUNC_REF: return "func";
+        default:           return "unknown";
+    }
+}
+
+NebType type_check_binary(NebType left, const char *op, NebType right, int line, int col) {
+    /* Arithmetic: int + int = int */
+    if ((strcmp(op, "+") == 0 || strcmp(op, "-") == 0 || 
+         strcmp(op, "*") == 0 || strcmp(op, "/") == 0 || strcmp(op, "%") == 0)) {
+        if (left == TYPE_INT && right == TYPE_INT) return TYPE_INT;
+        /* String concatenation */
+        if (left == TYPE_STRING && right == TYPE_STRING) return TYPE_STRING;
+        fprintf(stderr, "SEMANTIC ERROR [%d:%d]: type mismatch: %s %s %s\n",
+                line, col, type_name(left), op, type_name(right));
+        error_count++;
+        return TYPE_UNKNOWN;
+    }
+    
+    /* Comparison: same-type operands */
+    if (strcmp(op, "==") == 0 || strcmp(op, "!=") == 0 ||
+        strcmp(op, "<") == 0 || strcmp(op, ">") == 0 ||
+        strcmp(op, "<=") == 0 || strcmp(op, ">=") == 0) {
+        if (left == right) return TYPE_BOOL;
+        /* Allow null comparison */
+        if (left == TYPE_NULL || right == TYPE_NULL) return TYPE_BOOL;
+        fprintf(stderr, "SEMANTIC WARNING [%d:%d]: comparing %s with %s\n",
+                line, col, type_name(left), type_name(right));
+        warning_count++;
+        return TYPE_BOOL;
+    }
+    
+    return TYPE_UNKNOWN;
+}
+
+/* Type inference from literal */
+NebType infer_type_from_literal(const char *value) {
+    if (!value) return TYPE_NULL;
+    if (value[0] == '"') return TYPE_STRING;
+    if (value[0] == '[') return TYPE_ARRAY;
+    if (strcmp(value, "TRUE") == 0 || strcmp(value, "FALSE") == 0) return TYPE_BOOL;
+    if (strcmp(value, "NULL") == 0) return TYPE_NULL;
+    /* Check if number */
+    int i = 0;
+    if (value[0] == '-' || value[0] == '+') i = 1;
+    int is_num = 1;
+    for (; value[i]; i++) {
+        if (value[i] < '0' || value[i] > '9') { is_num = 0; break; }
+    }
+    if (is_num && i > 0) return TYPE_INT;
+    return TYPE_UNKNOWN;
+}
+
+/* Built-in function validation */
+NebType check_builtin(const char *name, int arg_count, NebType *arg_types, int line, int col) {
+    if (strcmp(name, "PRINT") == 0) return TYPE_NULL;
+    if (strcmp(name, "LEN") == 0) {
+        if (arg_count != 1) {
+            fprintf(stderr, "SEMANTIC ERROR [%d:%d]: LEN expects 1 argument, got %d\n",
+                    line, col, arg_count);
+            error_count++;
+            return TYPE_UNKNOWN;
+        }
+        if (arg_types[0] != TYPE_STRING && arg_types[0] != TYPE_ARRAY) {
+            fprintf(stderr, "SEMANTIC ERROR [%d:%d]: LEN expects string or array, got %s\n",
+                    line, col, type_name(arg_types[0]));
+            error_count++;
+            return TYPE_UNKNOWN;
+        }
+        return TYPE_INT;
+    }
+    if (strcmp(name, "TYPEOF") == 0) return TYPE_STRING;
+    if (strcmp(name, "TO_STRING") == 0) return TYPE_STRING;
+    if (strcmp(name, "TO_NUMBER") == 0) return TYPE_INT;
+    if (strcmp(name, "RANDOM") == 0) return TYPE_INT;
+    if (strcmp(name, "TIME") == 0) return TYPE_INT;
+    if (strcmp(name, "CONCAT") == 0) return TYPE_STRING;
+    
+    return TYPE_UNKNOWN;
+}
+
+/* Report results */
+void semantic_report(void) {
+    if (error_count == 0 && warning_count == 0) {
+        printf("Semantic analysis: PASS (no errors, no warnings)\n");
+    } else {
+        printf("Semantic analysis: %d error(s), %d warning(s)\n", error_count, warning_count);
+    }
+}
+
+int semantic_errors(void) {
+    return error_count;
+}
+
+/* Demo/test function */
+#ifdef NEB_SEMANTIC_TEST
+int main(void) {
+    printf("=== Nebulara Semantic Analysis Module ===\n\n");
+    
+    /* Create global scope */
+    scope_push("global");
+    
+    /* Define variables */
+    symbol_define("x", TYPE_INT, 1, 5, 1);
+    symbol_define("name", TYPE_STRING, 2, 5, 1);
+    symbol_define("PI", TYPE_INT, 3, 5, 0);
+    
+    /* Create function scope */
+    scope_push("factorial");
+    symbol_define("n", TYPE_INT, 10, 10, 1);
+    
+    /* Test lookup */
+    Symbol *s = symbol_lookup("n");
+    if (s) printf("Found '%s' of type %s (defined at line %d)\n", 
+                  s->name, type_name(s->type), s->line);
+    
+    /* Test undefined variable */
+    symbol_resolve("undefined_var", 15, 5);
+    
+    /* Test type checking */
+    type_check_binary(TYPE_INT, "+", TYPE_INT, 20, 10);
+    type_check_binary(TYPE_INT, "+", TYPE_STRING, 21, 10);
+    type_check_binary(TYPE_STRING, "+", TYPE_STRING, 22, 10);
+    
+    /* Test built-ins */
+    NebType args[] = { TYPE_STRING };
+    check_builtin("LEN", 1, args, 30, 5);
+    check_builtin("PRINT", 1, args, 31, 5);
+    
+    scope_pop();  /* pop factorial scope */
+    scope_pop();  /* pop global scope */
+    
+    semantic_report();
+    return error_count > 0 ? 1 : 0;
+}
+#endif

package/README.md

@@ -0,0 +1,258 @@
+# Nebulara
+
+**Nebulara - The AI-Native Universal Programming Language**
+
+An interpreter and transpiler for .nbs programs, with bytecode compilation, standard library, and npm distribution.
+
+[![License: Proprietary](https://img.shields.io/badge/License-Proprietary-red.svg)]()
+[![Status: Active Development](https://img.shields.io/badge/Status-Active-brightgreen.svg)]()
+
+## Quick Start
+
+```bash
+# Install from npm
+npm install -g @codurra/nebulara
+
+# Run a .nbs file
+neb run hello.nbs
+
+# Transpile to JavaScript
+neb transpile hello.nbs --target js
+
+# Transpile to Python
+neb transpile hello.nbs --target py
+
+# Run the interactive REPL
+neb repl
+```
+
+### Building from source
+
+```bash
+# Using npm
+node scripts/build.js
+
+# Using Make (Linux/macOS/MinGW)
+make all
+
+# Using batch file (Windows)
+build.bat
+```
+
+## Language Syntax (Dialect A)
+
+```
+# Comments start with #
+
+# Variables
+LET name = "Nebulara"
+LET count = 42
+LET flag = TRUE
+LET nothing = NULL
+
+# Constants
+CONST PI = 314
+
+# Arithmetic
+LET result = 10 + 5 * 2 - 3 / 1
+
+# Strings
+LET greeting = "Hello, " + name
+PRINT(TO_UPPER(greeting))
+PRINT(LEN(greeting))
+PRINT(CHAR_AT(greeting, 0))
+PRINT(SUBSTR(greeting, 0, 5))
+PRINT(TRIM("  hello  "))
+
+# Bitwise operations
+PRINT(5 & 3)        # 1 (AND)
+PRINT(5 | 3)        # 7 (OR)
+PRINT(1 << 3)       # 8 (left shift)
+PRINT(16 >> 2)      # 4 (right shift)
+
+# Arrays
+LET arr = [10, 20, 30, 40]
+PRINT(arr[0])           # 10
+arr[1] = 99             # Array mutation
+PUSH(arr, 50)           # Append
+LET last = POP(arr)     # Remove last
+
+# Control flow
+IF? count > 10 THEN:
+    PRINT("big")
+ELSEIF? count > 5 THEN:
+    PRINT("medium")
+ELSE:
+    PRINT("small")
+END!
+
+# Loops
+WHILE? count > 0 THEN:
+    count = count - 1
+END!
+
+FOR! i = 0 TO 10 (STEP 2):
+    PRINT(i)
+END!
+
+# Break and CONTINUE
+FOR! i = 0 TO 100:
+    IF? i == 5 THEN: BREAK END!
+    IF? i % 2 == 0 THEN: CONTINUE END!
+    PRINT(i)
+END!
+
+# Functions
+FUNC! add(a, b):
+    RETURN a + b
+END!
+
+LET sum = add(3, 4)
+
+# Recursive functions
+FUNC! factorial(n):
+    IF? n <= 1 THEN:
+        RETURN 1
+    END!
+    RETURN n * factorial(n - 1)
+END!
+
+# Exception handling
+TRY!:
+    THROW "something went wrong"
+CATCH! err:
+    PRINT("Caught: " + err)
+ENDTRY!
+
+# Type checking
+PRINT(TYPEOF(42))           # int
+PRINT(TYPEOF("hello"))      # string
+PRINT(TYPEOF(TRUE))         # bool
+PRINT(TYPEOF(NULL))         # null
+PRINT(TYPEOF([1, 2, 3]))    # array
+
+# Built-in functions
+PRINT(ABS(-42))             # 42
+PRINT(MIN(10, 20))          # 10
+PRINT(MAX(10, 20))          # 20
+PRINT(SQRT(16))             # 4
+PRINT(POW(2, 10))           # 1024
+PRINT(CHAR(65))             # A
+PRINT(ORD("Z"))             # 90
+PRINT(RANDOM())             # 0-99
+PRINT(TIME())               # Unix timestamp
+```
+
+## Architecture
+
+### Interpreters
+
+| Binary | Source | Description |
+|--------|--------|-------------|
+| `nebulara.exe` | `nbs-bootstrap.c` | Primary interpreter (2200+ lines). Full AST, bytecode compiler, VM with 40+ opcodes. |
+| `neb-cli.exe` | `nbs_cli.c` | Extended CLI interpreter. Additional features: TRY/CATCH, bitwise ops, build-to-bytecode, syntax highlighting. |
+
+### Toolchain Modules
+
+| Binary | Source | Description |
+|--------|--------|-------------|
+| `neb-pipeline.exe` | `neb-pipeline.c` | `.nbs` to JavaScript/Python transpiler (end-to-end) |
+| `neb-semantic.exe` | `neb-semantic.c` | Scope and type checker (standalone demo) |
+| `neb-ir.exe` | `neb-ir.c` | Three-address code IR (standalone demo) |
+| `neb-codegen.exe` | `neb-codegen.c` | x86/x64 instruction encoder (standalone demo) |
+| `neb-transpiler-js.exe` | `neb-transpiler-js.c` | JS transpiler helpers |
+| `neb-transpiler-py.exe` | `neb-transpiler-py.c` | Python transpiler helpers |
+| `neb-ffi.exe` | `neb-ffi.c` | FFI bridge (stub) |
+| `neb-knowledge.exe` | `neb-knowledge.c` | Knowledge graph (standalone demo) |
+
+### Standard Library (`std/`)
+
+| File | Functions |
+|------|-----------|
+| `primitives.nbs` | `IS_INT()`, `IS_STRING()`, `IS_BOOL()`, `IS_NULL()`, `IS_ARRAY()`, `IS_FUNC()`, `IS_NUMBER()` |
+| `math.nbs` | `abs()`, `min()`, `max()`, `clamp()`, `sum_array()`, `average()` |
+| `string.nbs` | `concat()`, `repeat()`, `reverse()`, `contains()`, `to_upper()`, `to_lower()`, `trim()`, `substring()` |
+| `collections.nbs` | `find()`, `contains()`, `reverse_array()`, `sum_array()`, `max_array()`, `min_array()` |
+| `time.nbs` | `now()`, `elapsed()`, `sleep()` (stub) |
+| `json.nbs` | `json_stringify()` (wraps TO_STRING), `json_parse()` (stub) |
+| `net.nbs` | All stubs |
+
+### npm Package
+
+```
+@codurra/nebulara
+  bin/neb.js          - CLI entry point (neb / nebulara commands)
+  dist/index.js       - Programmatic API
+  registry/           - Local package registry
+  build/              - All 10 compiled binaries
+```
+
+**API:**
+```javascript
+const { run, runString, transpileToJS, transpileToPython, check } = require('@codurra/nebulara');
+
+run('./hello.nbs');
+runString('PRINT("Hello!")');
+transpileToJS('./app.nbs');      // Returns JavaScript source
+transpileToPython('./app.nbs');   // Returns Python source
+check('./app.nbs');               // Type checking
+```
+
+### Registry
+
+```bash
+# Publish a package
+neb publish ./my-package
+
+# Install a package
+neb install @username/package-name
+
+# Search packages
+neb search "web framework"
+```
+
+## Built-in Functions (35+)
+
+| Function | Description |
+|----------|-------------|
+| `PRINT(expr)` | Print value with newline |
+| `LEN(x)` | String length or array count |
+| `TYPEOF(x)` | Returns type name as string |
+| `TO_STRING(x)` | Convert to string |
+| `TO_NUMBER(x)` | Convert to integer |
+| `TO_UPPER(s)` | Uppercase string |
+| `TO_LOWER(s)` | Lowercase string |
+| `CHAR_AT(s, i)` | Character at index (returns 1-char string) |
+| `SUBSTR(s, start, len)` | Extract substring |
+| `TRIM(s)` | Remove leading/trailing whitespace |
+| `CHAR(n)` | Integer to ASCII character |
+| `ORD(s)` | First character to integer |
+| `ABS(n)` | Absolute value |
+| `MIN(a, b)` | Minimum of two values |
+| `MAX(a, b)` | Maximum of two values |
+| `SQRT(n)` | Square root |
+| `POW(base, exp)` | Exponentiation |
+| `RANDOM()` | Random integer 0-99 |
+| `TIME()` | Current Unix timestamp |
+| `READ_FILE(path)` | Read file contents as string |
+| `WRITE_FILE(path, content)` | Write string to file |
+| `PUSH(arr, val)` | Append value to array |
+| `POP(arr)` | Remove and return last element |
+
+## Test Suite
+
+```
+test/hello.nbs          - Basic PRINT, LET, arithmetic
+test/test-functions.nbs  - Functions, params, return values
+test/test-loops.nbs     - WHILE, FOR, FOR with STEP
+test/test-control.nbs   - BREAK/CONTINUE
+test/test-recursion.nbs - Factorial, Fibonacci
+test/test-arrays.nbs    - Indexing, length, sum, string arrays
+test/test-strings.nbs   - Concatenation, builtins, type checking
+```
+
+Run all tests: `node scripts/test.js`
+
+## License
+
+Proprietary - CODURRA Labs & Technologies