Repo Update

Complete E-Lang to CP-Lang refactor and compiler implementation

- Rebranded entire project from E-Lang to CP-Lang
- Changed all unit names from ELang to CPLang prefix
- Updated copyright to tinyBigGAMES LLC 2025-present
- New project identity C Power Pascal Clarity
- Website changed to https://cp-lang.org/

- Implemented complete lexical analyzer in CPLang.Lexer.pas
- Added comprehensive parser in CPLang.Parser.pas
- Built full semantic analysis system in CPLang.Semantic.pas
- Created complete type system in CPLang.Types.pas
- Added LLVM integration and code generation
- Implemented include system with preprocessor directives
- Built comprehensive error handling and reporting
- Added symbol table management
- Created platform abstraction layer
- Implemented compiler orchestration with progress reporting

- Language supports C99 syntax with Pascal keywords
- Mandatory main function requirement
- Variable declarations with initialization
- Functions and procedures with external linking
- Record types and arrays
- Full control flow statements
- Expression evaluation with operator precedence
- Preprocessor directives support

- 18 Pascal units plus 1 include file
- Targets 64-bit platforms Windows Linux macOS
- Requires Delphi 12 or higher
- Professional compiler architecture with multi-phase compilation

Author: jarroddavis68

.gitignore

@@ -93,3 +93,5 @@ src/todo.md
 checkpoint.zip
 checkpoint_base.zip
 CPascal-main.zip
+bin/math.e
+bin/test.e

README.md

@@ -1,16 +1,16 @@
-![E-Lang](media/e-lang.png)
+![CP-Lang](media/cp-lang.png)
 [![Chat on Discord](https://img.shields.io/discord/754884471324672040?style=for-the-badge)](https://discord.gg/tPWjMwK) [![Follow on Bluesky](https://img.shields.io/badge/Bluesky-tinyBigGAMES-blue?style=for-the-badge&logo=bluesky)](https://bsky.app/profile/tinybiggames.com)  
-> 🚧 **E-Lang is Work in Progress**
+> 🚧 **CP-Lang is Work in Progress**
 >
-> E-Lang is currently under active development and evolving quickly. Some features described in this documentation may be incomplete, experimental, or subject to significant changes as the project matures.
+> CP-Lang is currently under active development and evolving quickly. Some features described in this documentation may be incomplete, experimental, or subject to significant changes as the project matures.
 >
-> We welcome your feedback, ideas, and issue reports — your input will directly influence the direction and quality of E-Lang as we strive to build the ultimate modern programming language.
+> We welcome your feedback, ideas, and issue reports — your input will directly influence the direction and quality of CP-Lang as we strive to build the ultimate modern programming language.
 
 ## C Power, Pascal Clarity
 
-E-Lang is a modern programming language that combines **C99 semantics with Pascal-style syntax**, giving you the raw power and flexibility of C with the clean, readable elegance of Pascal.
+CP-Lang is a modern programming language that combines **C99 semantics with Pascal-style syntax**, giving you the raw power and flexibility of C with the clean, readable elegance of Pascal.
 
-### Why E-Lang?
+### Why CP-Lang?
 
 - **🚀 C99 Performance** - Full access to pointers, manual memory management, and low-level system programming
 - **📖 Pascal Readability** - Clean, self-documenting syntax that's easy to read and maintain  
@@ -25,15 +25,15 @@ E-Lang is a modern programming language that combines **C99 semantics with Pasca
 
 function main(): int32
 begin
-    msg: string := "Hello, E-Lang!";
-    count: int32 := 42;
+  var msg: char := "Hello, CP-Lang!";
+  var count: int32 := 42;
     
-    if count > 0 then
-        printf("%s Count: %d\n", msg, count)
-    else
-        printf("Nothing to count\n");
+  if count > 0 then
+    printf("%s Count: %d\n", msg, count)
+  else
+    printf("Nothing to count\n");
     
-    return 0;
+  return 0;
 end
 ```
 
@@ -47,52 +47,53 @@ end
 ### 🔧 **Rich Type System**
 ```pascal
 // Basic types
-x: int32 := 100;
-y: float := 3.14;
-flag: bool := true;
+var x: int32 := 100;
+var y: float := 3.14;
+var flag: bool := true;
 
 // Sized integers
-byte_val: uint8 := 255;
-big_num: int64 := 9223372036854775807;
+var byte_val: uint8 := 255;
+var big_num: int64 := 9223372036854775807;
 
 // Pointers and arrays
-ptr: ^int32;
-numbers: array[10] of int32;
+var ptr: ^int32;
+var numbers: array[10] of int32;
 
 // Records (structs)
 type Point = record
-    x, y: float;
+  x, y: float;
 end;
 ```
 
 ### ⚙️ **Powerful Control Flow**
 ```pascal
-// Modern for loops
-for i := 0; i < 10; i := i + 1 do
-    printf("Count: %d\n", i);
+// Pascal-style for loops
+var i: int32;
+
+for i := 1 to 10 do
+  printf("Count: %d\n", i);
 
-// Pascal-style for loops  
 for i := 1 to 100 do
-    process(i);
+  process(i);
 
 // Pattern matching
 case value of
-    1..10: printf("Small");
-    11..50: printf("Medium"); 
-    else printf("Large");
-end;
+  1..10: printf("Small");
+  11..50: printf("Medium"); 
+else 
+  printf("Large");
+end
 ```
 
 ### 🔗 **C99 Compatibility**
 ```pascal
-#include <stdlib>
-#define MAX_SIZE 1024
+#include <stdlib.e>
 
 function allocate_buffer(): ^char
 begin
-    buffer: ^char := malloc(MAX_SIZE);
-    return buffer;
-end;
+  var buffer: ^char := malloc(1024);
+  return buffer;
+end
 ```
 
 ---

bin/test.e

@@ -1,9 +1,28 @@
 // Main program
 
+#include "math.e"
+#include "math.e"
+
 function printf(const AFormat: ^char, ...): int32 external "msvcrt.dll";
 
 function main(): int32
 begin
   printf("Hello, %s\n", "World!");
+  printf("add(7, 3): %d\n", add(7, 3));
+  
+  var i: int32;
+  
+  printf("for-loop-to:\n");
+  for i := 1 to 10 do 
+  begin
+    printf("%d\n", i);
+  end   
+  
+  printf("\nfor-loop-downto:\n");
+  for i := 10 downto 1 do
+  begin
+    printf("%d\n", i);
+  end
+  
   return 0;
 end

docs/e-lang-bnf.txt docs/cp-lang-bnf.mddocs/e-lang-bnf.txt renamed to docs/cp-lang-bnf.md

@@ -1,12 +1,20 @@
-(* E Language Grammar - C99 with Pascal Syntax, Mandatory Main Function *)
+# CP-Lang Grammar Specification
 
+**CP Language Grammar - C99 with Pascal Syntax, Mandatory Main Function**
+
+## Program Structure
+
+```bnf
 program ::= translation_unit main_function
 
 translation_unit ::= (preprocessor_directive | declaration)*
 
 main_function ::= "function" "main" "(" ")" ":" "int32" statement_block
+```
 
-(* Preprocessor Directives *)
+## Preprocessor Directives
+
+```bnf
 preprocessor_directive ::= "#include " ("<" IDENTIFIER ">" | STRING_LITERAL)
                          | "#includepath " STRING_LITERAL
                          | "#define " IDENTIFIER replacement_list?
@@ -24,25 +32,40 @@ preprocessor_directive ::= "#include " ("<" IDENTIFIER ">" | STRING_LITERAL)
 replacement_list ::= token_sequence
 token_sequence ::= [^\n]+
 constant_expression ::= expression
+```
+
+## Declarations
 
+```bnf
 declaration_list ::= declaration*
 
 declaration ::= variable_declaration
               | function_declaration  
               | type_declaration
               | statement
+```
 
-(* Variable Declarations - can appear anywhere like C *)
+### Variable Declarations
+
+Variables can appear anywhere like C:
+
+```bnf
 variable_declaration ::= "var" identifier_list ":" type_spec init_value? ";"
 
 identifier_list ::= IDENTIFIER ("," IDENTIFIER)*
 
 init_value ::= ":=" expression
+```
 
-(* Type Declarations *)
+### Type Declarations
+
+```bnf
 type_declaration ::= "type" IDENTIFIER "=" type_spec ";"
+```
+
+### Function Declarations
 
-(* Function Declarations *)
+```bnf
 function_declaration ::= function_header statement_block
                        | function_header "external" STRING_LITERAL ";"
 
@@ -57,10 +80,11 @@ param_def_list ::= param_def ("," param_def)* ("," "...")?
 param_def ::= param_modifier? identifier_list ":" type_spec
 
 param_modifier ::= "ref" | "const"
+```
 
-(* No separate return_type rule needed - incorporated into function_header *)
+## Type Specifications
 
-(* Type Specifications *)
+```bnf
 type_spec ::= basic_type
             | pointer_type
             | array_type  
@@ -84,8 +108,11 @@ field_def ::= identifier_list ":" type_spec
 
 function_type ::= "function" parameter_list return_type
                 | "procedure" parameter_list
+```
 
-(* Statements *)
+## Statements
+
+```bnf
 statement_block ::= "begin" statement_list "end"
 
 statement_list ::= statement*
@@ -108,7 +135,11 @@ statement ::= assignment_statement ";"
 assignment_statement ::= lvalue ":=" expression
 
 call_statement ::= expression
+```
+
+### Control Flow Statements
 
+```bnf
 if_statement ::= "if" expression "then" statement ("else" statement)?
 
 while_statement ::= "while" expression "do" statement
@@ -135,8 +166,13 @@ return_statement ::= "return" expression?
 goto_statement ::= "goto" IDENTIFIER
 
 label_statement ::= IDENTIFIER ":"
+```
+
+**Note:** For Pascal-style for-loops (first form), the IDENTIFIER must refer to a previously declared variable of an ordinal type (integer types: int, int8, int16, int32, int64, uint8, uint16, uint32, uint64, or char). Boolean, floating-point, string, pointer, array, and record types are not allowed as they lack practical discrete ordering semantics required by "to" and "downto" operations.
+
+## Expressions
 
-(* Expressions *)
+```bnf
 expression ::= conditional_expression
 
 conditional_expression ::= logical_or_expression ("?" expression ":" conditional_expression)?
@@ -178,14 +214,38 @@ lvalue ::= IDENTIFIER
          | "(" lvalue ")"
 
 constant ::= INTEGER_LITERAL | REAL_LITERAL | CHAR_LITERAL | BOOLEAN_LITERAL
+```
 
-(* Comments - C-style *)
+## Lexical Elements
+
+### Comments
+
+C-style comments are supported:
+
+```bnf
 COMMENT ::= "//" [^\n]* "\n"
           | "/*" .* "*/"
+```
+
+### Literals
 
+```bnf
 BOOLEAN_LITERAL ::= "true" | "false"
 IDENTIFIER ::= [a-zA-Z_][a-zA-Z0-9_]*
 INTEGER_LITERAL ::= [0-9]+ | "0x"[0-9a-fA-F]+ | "0"[0-7]+
 REAL_LITERAL ::= [0-9]+"."[0-9]+([eE][+-]?[0-9]+)?
 CHAR_LITERAL ::= "'"[^']"'"
-STRING_LITERAL ::= '"'[^"]*'"'
+STRING_LITERAL ::= '"'[^"]*'"'
+```
+
+## Language Features
+
+- **C99 syntax** with Pascal keywords and structure
+- **Mandatory main function** requirement
+- **Preprocessor directives** for include management and conditional compilation
+- **Strong typing** with comprehensive type system
+- **Pascal-style** begin/end blocks and control structures
+- **Modern data types** including sized integers and floating-point types
+- **Record types** for structured data
+- **Function pointers** and external function declarations
+- **Flexible variable declarations** that can appear anywhere in scope