{"id":28944881,"url":"https://github.com/mansafreo/pie-compiler","last_synced_at":"2026-04-29T10:07:59.429Z","repository":{"id":300470210,"uuid":"977598692","full_name":"Mansafreo/PIE-Compiler","owner":"Mansafreo","description":"A Proof of concept compiler for a custom programming language","archived":false,"fork":false,"pushed_at":"2025-06-21T21:24:14.000Z","size":349,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-06-21T22:25:35.875Z","etag":null,"topics":["automata-theory","code-generation","compiler-design","compilers","intermediate-representation","llvm","programming-language-development","static-types"],"latest_commit_sha":null,"homepage":"","language":"Python","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/Mansafreo.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,"zenodo":null}},"created_at":"2025-05-04T15:17:15.000Z","updated_at":"2025-06-21T21:24:17.000Z","dependencies_parsed_at":"2025-06-21T22:35:57.359Z","dependency_job_id":null,"html_url":"https://github.com/Mansafreo/PIE-Compiler","commit_stats":null,"previous_names":["mansafreo/pie-compiler"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/Mansafreo/PIE-Compiler","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mansafreo%2FPIE-Compiler","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mansafreo%2FPIE-Compiler/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mansafreo%2FPIE-Compiler/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mansafreo%2FPIE-Compiler/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Mansafreo","download_url":"https://codeload.github.com/Mansafreo/PIE-Compiler/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Mansafreo%2FPIE-Compiler/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":261433936,"owners_count":23157196,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","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":["automata-theory","code-generation","compiler-design","compilers","intermediate-representation","llvm","programming-language-development","static-types"],"created_at":"2025-06-23T07:00:44.901Z","updated_at":"2026-04-29T10:07:59.423Z","avatar_url":"https://github.com/Mansafreo.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# PIE Programming Language\n\n\u003cdiv align=\"center\"\u003e\n\n**A Modern, C-like Programming Language with Advanced Features**\n\n[Quick Start](#quick-start) • [Documentation](#documentation) • [Examples](#examples) • [Features](#features)\n\n\u003c/div\u003e\n\n---\n\n## Overview\n\nPIE is a statically-typed, compiled programming language that combines the simplicity of C-style syntax with modern programming features. Built with LLVM, PIE offers excellent performance while providing high-level abstractions for common programming tasks.\n\n### Key Features\n\n- 🚀 **LLVM-Based Compilation** - Fast, optimized native code generation\n- 📝 **C-Like Syntax** - Familiar and easy to learn for C/C++ programmers\n- 🎯 **Static Typing** - Catch errors at compile-time with type safety\n- 📚 **Rich Standard Library** - Math, strings, file I/O, networking, and more\n- 🔄 **Dynamic Arrays** - Built-in support for growable arrays\n- 📖 **Dictionaries** - Hash maps with automatic type inference\n- 🔍 **Regular Expressions** - Pattern matching with Kleene syntax\n- 🌐 **Network Support** - TCP sockets for network programming\n- 📁 **File I/O** - Comprehensive file handling capabilities\n\n## Quick Start\n\n### Prerequisites\n\n- **Python 3.x** (3.7 or higher recommended)\n- **LLVM Tools** (llvm-as, llc, clang)\n- **Python Packages**: \n  - `llvmlite` (0.45.1 or higher)\n  - `ply` (3.11 or higher)\n\n### Installation\n\n1. **Clone the repository:**\n```bash\ngit clone https://github.com/Pie-Compiler/PIE-Compiler-V1-Python.git\ncd PIE-Compiler-V1-Python\n```\n\n2. **Set up Python virtual environment (recommended):**\n```bash\npython3 -m venv venv\nsource venv/bin/activate  # On Windows: venv\\Scripts\\activate\n```\n\n3. **Install dependencies:**\n```bash\npip install llvmlite ply\n```\n\n4. **Verify LLVM installation:**\n```bash\nllc --version\nclang --version\n```\n\n### Your First PIE Program\n\nCreate a file named `hello.pie`:\n\n```pie\n// Simple hello world program\noutput(\"Hello, PIE!\", string);\n\n// Variables and arithmetic\nint x = 10;\nint y = 20;\nint sum = x + y;\noutput(\"Sum: \", string);\noutput(sum, int);\n```\n\n### Compile and Run\n\n```bash\n# Compile the PIE source code\npython3 src/main.py hello.pie\n\n# Run the compiled program\n./program\n```\n\n**Output:**\n```\nHello, PIE!\nSum: \n30\n```\n\n## Documentation\n\nComprehensive documentation is available in the `docs/` directory:\n\n- **[Language Reference](docs/language-reference.md)** - Complete language syntax and features\n- **[Standard Library](docs/standard-library.md)** - All built-in functions and their usage\n- **[Examples \u0026 Tutorials](docs/examples.md)** - Practical examples and sample programs\n- **[Advanced Features](docs/advanced-features.md)** - Dictionaries, regex, networking, and more\n\n### Quick Language Overview\n\n#### Data Types\n```pie\nint x = 42;                    // 32-bit signed integer\nfloat pi = 3.14159;            // Double-precision floating point\nchar letter = 'A';             // Single character\nstring name = \"Alice\";         // String (null-terminated)\nbool isValid = true;           // Boolean (true/false)\ndict person = {};              // Dictionary (hash map)\nregex pattern = regex_compile(\"a+\"); // Regular expression\nfile f = file_open(\"data.txt\", \"r\"); // File handle\n```\n\n#### Control Flow\n```pie\n// If-else statements\nif (x \u003e 10) {\n    output(\"Greater than 10\", string);\n} else {\n    output(\"Less than or equal to 10\", string);\n}\n\n// For loops with increment/decrement operators\nfor (int i = 0; i \u003c 10; i++) {\n    output(i, int);\n}\n\n// While loops\nwhile (x \u003e 0) {\n    x--;\n}\n\n// Do-while loops\ndo {\n    output(x, int);\n    x++;\n} while (x \u003c 5);\n```\n\n#### Arrays\n```pie\n// Static arrays\nint numbers[5] = [1, 2, 3, 4, 5];\n\n// Dynamic arrays\nint[] dynamic = [1, 2, 3];\narr_push(dynamic, 4);          // Add element\nint size = arr_size(dynamic);  // Get size\nint last = arr_pop(dynamic);   // Remove and return last element\n```\n\n#### Functions\n```pie\nint fibonacci(int n) {\n    if (n \u003c= 1) {\n        return n;\n    }\n    return fibonacci(n - 1) + fibonacci(n - 2);\n}\n\nint result = fibonacci(10);\noutput(result, int);\n```\n\n## Examples\n\n### Example 1: Temperature Converter\n```pie\nfloat celsius = 25.0;\nfloat fahrenheit = (celsius * 9.0 / 5.0) + 32.0;\noutput(\"Celsius: \", string);\noutput(celsius, float, 2);\noutput(\"Fahrenheit: \", string);\noutput(fahrenheit, float, 2);\n```\n\n### Example 2: Working with Dictionaries\n```pie\ndict student = {\n    \"name\": \"Alice\",\n    \"age\": 20,\n    \"grade\": 95.5\n};\n\nstring name = dict_get(student, \"name\");\nint age = dict_get(student, \"age\");\nfloat grade = dict_get(student, \"grade\");\n\noutput(name, string);\noutput(age, int);\noutput(grade, float, 2);\n```\n\n### Example 3: String Manipulation\n```pie\nstring text = \"  Hello World  \";\nstring trimmed = string_trim(text);\nstring upper = string_to_upper(trimmed);\nstring reversed = string_reverse(upper);\n\noutput(reversed, string);  // Outputs: DLROW OLLEH\n```\n\nSee [docs/examples.md](docs/examples.md) for more comprehensive examples.\n\n## Features\n\n### Operators\n\n- **Arithmetic**: `+`, `-`, `*`, `/`, `%`\n- **Comparison**: `==`, `!=`, `\u003c`, `\u003e`, `\u003c=`, `\u003e=`\n- **Logical**: `\u0026\u0026` (AND), `||` (OR)\n- **Assignment**: `=`\n- **Increment/Decrement**: `++`, `--`\n- **String Concatenation**: `+`\n\n### Standard Library Highlights\n\n#### Math Functions\n```pie\nfloat result = sqrt(16.0);      // Square root\nfloat power = pow(2.0, 8.0);    // Power function\nfloat angle = sin(1.57);        // Trigonometric functions\nint random = rand();            // Random number\n```\n\n#### String Functions\n```pie\nint len = strlen(\"Hello\");                          // String length\nstring upper = string_to_upper(\"hello\");            // Convert to uppercase\nstring sub = string_substring(\"Hello\", 0, 4);       // Extract substring\nint idx = string_index_of(\"Hello World\", \"World\");  // Find substring\n```\n\n#### Type Conversions\n```pie\nint num = string_to_int(\"42\");              // String to integer\nfloat pi = string_to_float(\"3.14\");         // String to float\nchar first = string_to_char(\"Hello\");       // First char of string\nint ascii = char_to_int('A');               // Get ASCII value (65)\nchar letter = int_to_char(65);              // ASCII to char ('A')\nfloat f = int_to_float(42);                 // Int to float\nint i = float_to_int(3.99);                 // Float to int (truncates to 3)\n```\n\n#### Cryptography \u0026 Encoding (Educational)\n```pie\n// Caesar cipher - shifts letters only\nstring encrypted = caesar_cipher(\"HELLO\", 3);      // \"KHOOR\"\nstring decrypted = caesar_decipher(\"KHOOR\", 3);    // \"HELLO\"\n\n// ROT13 - symmetric encoding\nstring encoded = rot13(\"SECRET\");                   // \"FRPERG\"\nstring decoded = rot13(encoded);                    // \"SECRET\"\n\n// Character shift - shifts all characters\nstring alien = char_shift(\"Hello!\", 5);            // \"Mjqqt\u0026\"\nstring earth = char_shift(alien, -5);              // \"Hello!\"\n\n// String manipulation\nstring reversed = reverse_string(\"HELLO\");          // \"OLLEH\"\nstring xor_enc = xor_cipher(\"text\", \"key\");        // XOR encryption\n```\n\n**Note:** Crypto functions are for education and simple obfuscation only, not secure encryption.\n\n#### Array Functions\n```pie\narr_push(array, value);         // Add element to dynamic array\nint val = arr_pop(array);       // Remove and return last element\nint size = arr_size(array);     // Get array size\nint exists = arr_contains(array, value);  // Check if value exists\nint index = arr_indexof(array, value);    // Find index of value\nfloat avg = arr_avg(array);     // Calculate average\n```\n\n#### Regular Expressions\n```pie\n// Compile pattern with explicit OR operators for each character\nregex email_pattern = regex_compile(\"(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)+.@.(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)+\");\nint is_match = regex_match(email_pattern, \"user@example\");\n```\n\n#### File I/O\n```pie\nfile f = file_open(\"data.txt\", \"w\");\nfile_write(f, \"Hello, File!\");\nfile_close(f);\n\nfile r = file_open(\"data.txt\", \"r\");\nstring content = file_read_all(r);\nfile_close(r);\n```\n\n## Project Structure\n\n```\nPIE-Compiler-V1-Python/\n├── src/\n│   ├── main.py                 # Compiler entry point\n│   ├── frontend/               # Lexer, parser, semantic analysis\n│   │   ├── lexer.py           # NFA/DFA-based tokenization\n│   │   ├── parser.py          # PLY-based parser\n│   │   ├── semanticAnalysis.py\n│   │   └── symbol_table.py\n│   ├── backend/               # LLVM code generation\n│   │   └── llvm_generator.py\n│   └── runtime/               # C runtime library\n│       ├── runtime.c          # I/O functions\n│       ├── math_lib.c         # Math functions\n│       ├── string_lib.c       # String utilities\n│       ├── d_array.c          # Dynamic array implementation\n│       ├── dict_lib.c         # Dictionary implementation\n│       ├── regex_lib.c        # Regex engine\n│       ├── file_lib.c         # File I/O\n│       ├── net_lib.c          # Network functions\n│       └── time_lib.c         # Time functions\n├── docs/                      # Documentation\n├── README.md                  # This file\n└── CHANGELOG.md              # Version history and updates\n```\n\n## Compiler Usage\n\n### Basic Compilation\n```bash\npython3 src/main.py \u003csource_file.pie\u003e\n```\n\nThe compiler performs these steps:\n1. **Lexical Analysis** - Tokenizes the source code\n2. **Parsing** - Generates Abstract Syntax Tree (AST)\n3. **Semantic Analysis** - Type checking and validation\n4. **Code Generation** - Produces LLVM IR\n5. **Linking** - Links with runtime library\n6. **Output** - Creates executable binary `./program`\n\n### Compiler Output\n\nThe compiler generates several intermediate files:\n- `output.ll` - LLVM IR (human-readable)\n- `output.bc` - LLVM bitcode (binary)\n- `program` - Final executable\n\n## Contributing\n\nContributions are welcome! Please feel free to submit issues, feature requests, or pull requests.\n\n## License\n\nThis project is open source. See LICENSE file for details.\n\n## Changelog\n\nSee [CHANGELOG.md](CHANGELOG.md) for detailed version history and updates.\n\n---\n\n\u003cdiv align=\"center\"\u003e\n\n**Happy Coding with PIE! 🥧**\n\nMade with ❤️ by the PIE Compiler Team\n\n\u003c/div\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmansafreo%2Fpie-compiler","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmansafreo%2Fpie-compiler","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmansafreo%2Fpie-compiler/lists"}