{"id":23902409,"url":"https://github.com/kelbudiul/lei","last_synced_at":"2026-05-18T00:09:29.873Z","repository":{"id":270911918,"uuid":"891480349","full_name":"kelbudiul/lei","owner":"kelbudiul","description":"Lei is a toy compiler project. Intended to be a tutorial and overall knowledge sharpening.","archived":false,"fork":false,"pushed_at":"2025-01-04T00:30:47.000Z","size":227,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-23T10:29:19.214Z","etag":null,"topics":["compiler-construction","compiler-design","llvm","llvm-backend"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/kelbudiul.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-11-20T12:12:34.000Z","updated_at":"2025-01-04T00:30:50.000Z","dependencies_parsed_at":null,"dependency_job_id":"df7f1ad6-6051-49f7-a83e-06bc3fa7e8c4","html_url":"https://github.com/kelbudiul/lei","commit_stats":null,"previous_names":["kelbudiul/lei"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/kelbudiul/lei","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kelbudiul%2Flei","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kelbudiul%2Flei/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kelbudiul%2Flei/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kelbudiul%2Flei/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/kelbudiul","download_url":"https://codeload.github.com/kelbudiul/lei/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/kelbudiul%2Flei/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33160170,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-17T22:39:12.733Z","status":"ssl_error","status_checked_at":"2026-05-17T22:39:10.741Z","response_time":107,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["compiler-construction","compiler-design","llvm","llvm-backend"],"created_at":"2025-01-04T22:29:29.883Z","updated_at":"2026-05-18T00:09:29.868Z","avatar_url":"https://github.com/kelbudiul.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Lei Programming Language\n\nA statically-typed programming language compiler that generates LLVM IR.\n\n## Features\n- Static typing with support for `int`, `float`, `bool`, `str`, and `void` types\n- Fixed-size and dynamic arrays\n- Functions with proper scoping\n- Memory management (malloc/realloc/free)\n- Control flow statements (if/else, while)\n- Standard I/O operations\n- Compound assignment operators\n\n## Development Environment Setup\n\n### Prerequisites\n- C++ compiler supporting C++17 or later\n- LLVM development libraries (version 15.0 or later)\n- CMake (version 3.13 or later)\n- Git for version control\n\n### Installation\n\n#### Ubuntu/Debian\n```bash\n# Install build essentials and LLVM\nsudo apt-get update\nsudo apt-get install build-essential\nsudo apt-get install llvm-dev\nsudo apt-get install cmake\nsudo apt-get install git\n\n# Clone the repository\ngit clone https://github.com/yourusername/lei.git\ncd lei\n\n# Create build directory\nmkdir build\ncd build\n\n# Configure and build\ncmake ..\nmake\n\n# Run tests\nmake test\n```\n\n#### macOS\n```bash\n# Install prerequisites using Homebrew\nbrew install llvm\nbrew install cmake\n\n# Clone and build (same steps as above)\n```\n\n#### Windows\n1. Install Visual Studio with C++ support\n2. Install LLVM from https://releases.llvm.org/\n3. Install CMake from https://cmake.org/download/\n4. Follow the build steps above using Visual Studio Developer Command Prompt\n\n## Usage\n\n### Command Line Options\n```bash\nleic [input] [-o output] [-e] [--print-ast] [--print-sp] [--print-ir]\n\nOptions:\n    input           Input source file\n    -o, --output    Output path for generated LLVM IR\n    -e, --execute   Directly execute the generated LLVM IR\n    --print-ast     Print the abstract syntax tree\n    --print-sp      Print the symbol table\n    --print-ir      Print the LLVM IR\n```\n\n### Example\n```bash\n# Compile a source file to LLVM IR\nleic example.lei -o example.ll\n\n# Compile and execute\nleic example.lei -e\n\n# Compile with debug output\nleic example.lei --print-ast --print-ir\n```\n\n## Language Syntax Examples\n\n### Basic Program Structure\n```rust\n// Function declaration with return type\nfn int main() {\n    var x: int = 42;        // Variable declaration with type annotation\n    print(x);               // Built-in print function\n    return 0;\n}\n```\n\n### Variable Declarations and Types\n```rust\nfn void examples() {\n    // Basic types\n    var count: int = 0;            // Integer\n    var temp: float = 98.6;        // Floating point\n    var name: str = \"Alice\";       // String\n    var isActive: bool = true;     // Boolean\n\n    // Arrays\n    var fixed: int[3] = {1, 2, 3}; // Fixed-size array\n    var size: int = 5;\n    var dynamic: int[] = malloc(size * sizeof(int)); // Dynamic array\n\n    // Don't forget to free dynamic memory\n    free(dynamic);\n}\n```\n\n### Control Flow\n```rust\nfn int checkValue(x: int) {\n    // If-else statement\n    if x \u003e 10 {\n        print(\"Greater than 10\");\n    } else if x \u003c 0 {\n        print(\"Negative number\");\n    } else {\n        print(\"Between 0 and 10\");\n    }\n\n    // While loop\n    var i: int = 0;\n    while i \u003c x {\n        print(i);\n        i = i + 1;\n    }\n\n    return x;\n}\n```\n\n### Array Operations\n```rust\n// Function to sum array elements\nfn int sum(arr: int[], size: int) {\n    var total: int = 0;\n    var i: int = 0;\n    \n    while i \u003c size {\n        total = total + arr[i];\n        i = i + 1;\n    }\n    \n    return total;\n}\n\nfn void arrayExample() {\n    // Fixed array initialization\n    var nums: int[5] = {1, 2, 3, 4, 5};\n    \n    // Dynamic array\n    var dynamic: int[] = malloc(3 * sizeof(int));\n    dynamic[0] = 10;\n    dynamic[1] = 20;\n    dynamic[2] = 30;\n    \n    // Resize dynamic array\n    dynamic = realloc(dynamic, 4 * sizeof(int));\n    dynamic[3] = 40;\n    \n    // Don't forget to free\n    free(dynamic);\n}\n```\n\n### String Operations\n```rust\nfn void stringExample() {\n    var name: str = \"John\";\n    var greeting: str = \"Hello, \";\n    \n    // String input\n    var input: str = input(\"Enter your name: \");\n    \n    // Print with string concatenation\n    print(greeting + input);\n}\n```\n\n### Compound Assignment Operators\n```rust\nfn void operatorExample() {\n    var x: int = 5;\n    x += 3;      // x = x + 3\n    x -= 2;      // x = x - 2\n    x *= 4;      // x = x * 4\n    x /= 2;      // x = x / 2\n}\n```\n\n### Memory Management Example\n```rust\nfn int[] createAndFillArray(size: int, value: int) {\n    // Allocate memory\n    var arr: int[] = malloc(size * sizeof(int));\n    \n    // Fill array\n    var i: int = 0;\n    while i \u003c size {\n        arr[i] = value;\n        i = i + 1;\n    }\n    \n    return arr;  // Caller is responsible for freeing memory\n}\n\nfn void memoryExample() {\n    var arr: int[] = createAndFillArray(5, 42);\n    \n    // Use array\n    print(arr[0]);\n    \n    // Clean up\n    free(arr);\n}\n```\n\n## Current Limitations\n\n- Basic type system\n- Single-file compilation only\n- Basic error recovery\n\n## Future Enhancements\n\nPlanned features include:\n- Enhanced type system\n- Function overloading\n- Multi-file preprocessing and compilation support\n- Optimization passes\n- Basic OOP support\n\n\n## Language Grammar\n\n### Program Structure\n```ebnf\nprogram        → function*\nfunction       → \"fn\" type IDENTIFIER \"(\" parameters? \")\" block\nparameters     → parameter (\",\" parameter)*\nparameter      → IDENTIFIER \":\" type\n\n### Types\ntype           → basicType | arrayType\nbasicType      → \"int\" | \"float\" | \"bool\" | \"str\"\narrayType      → basicType \"[\" (NUMBER | \"dynamic\")? \"]\"  # Fixed size or dynamic arrays\n\n### Statements\nblock          → \"{\" statement* \"}\"\nstatement      → varDecl \n               | ifStmt \n               | whileStmt \n               | returnStmt \n               | printStmt\n               | exprStmt\n\nvarDecl        → \"var\" IDENTIFIER \":\" type (\"=\" initializer)? \";\"\ninitializer    → expression \n               | arrayInitializer\n               | \"new\" basicType \"[\" expression \"]\"  # Dynamic array allocation\n\narrayInitializer → \"{\" (expression (\",\" expression)*)? \"}\"  # Can be empty\nifStmt         → \"if\" expression block (\"else\" block)?\nwhileStmt      → \"while\" expression block\nreturnStmt     → \"return\" expression? \";\"\nprintStmt      → \"print\" \"(\" expression \")\" \";\"\nexprStmt       → expression \";\"\n\n### Expressions\nexpression     → assignment\nassignment     → (call \".\")? IDENTIFIER assignOp expression\n               | logicalOr\nassignOp       → \"=\" | \"+=\" | \"-=\" | \"*=\" | \"/=\"\n\nlogicalOr      → logicalAnd (\"||\" logicalAnd)*\nlogicalAnd     → equality (\"\u0026\u0026\" equality)*\nequality       → comparison ((\"==\" | \"!=\") comparison)*\ncomparison     → term ((\"\u003c\" | \"\u003c=\" | \"\u003e\" | \"\u003e=\") term)*\nterm           → factor ((\"+\" | \"-\") factor)*\nfactor         → unary ((\"*\" | \"/\") unary)*\nunary          → (\"!\" | \"-\") unary | call\ncall           → primary (\"(\" arguments? \")\" | \"[\" expression \"]\")*\nprimary        → NUMBER | STRING | \"true\" | \"false\" | \"(\" expression \")\"\n               | IDENTIFIER | arrayInitializer\n               | arrayAllocation\n\narrayAllocation → \"new\" basicType \"[\" expression \"]\"\narguments      → expression (\",\" expression)*\n\n### Lexical Rules\nNUMBER         → DIGIT+ (\".\" DIGIT+)?\nSTRING         → \"\\\"\" \u003cany char except \"\\\"\"\u003e* \"\\\"\"\nIDENTIFIER     → ALPHA (ALPHA | DIGIT)*\nALPHA          → \"a\"...\"z\" | \"A\"...\"Z\" | \"_\"\nDIGIT          → \"0\"...\"9\"\n```\n\n### Variable Initialization Rules\n\n1. **Basic Types Default Values**\n   ```lei\n   var i: int;           // Defaults to 0\n   var f: float;         // Defaults to 0.0\n   var b: bool;          // Defaults to false\n   var s: str;           // Defaults to \"\"\n   ```\n\n2. **Fixed-Size Arrays**\n   ```lei\n   var arr1: int[5];               // Array of 5 ints, initialized to [0,0,0,0,0]\n   var arr2: float[3] = {1.0};     // Partially initialized to [1.0,0.0,0.0]\n   var arr3: bool[2] = {};         // Empty initialization [false,false]\n   ```\n\n3. **Dynamic Arrays**\n   ```lei\n   var arr4: int[];                // Dynamic array, initially empty\n   arr4 = new int[10];            // Allocate 10 elements\n   \n   var size: int = input();\n   var arr5: float[] = new float[size];  // Runtime size determination\n   ```\n\n### Example Code\n```lei\nfn int main() {\n    // Uninitialized variables with default values\n    var count: int;            // 0\n    var temperature: float;    // 0.0\n    \n    // Fixed size array\n    var fixed: int[3];         // [0,0,0]\n    \n    // Dynamic array allocation\n    var size: int = 5;\n    var dynamic: int[] = new int[size];\n    \n    // Partial array initialization\n    var grades: float[5] = {90.5, 85.0};  // [90.5, 85.0, 0.0, 0.0, 0.0]\n    \n    return 0;\n}\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkelbudiul%2Flei","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fkelbudiul%2Flei","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkelbudiul%2Flei/lists"}