Delete push.bat

PCCcompiler/PCCcompiler.vcxproj

@@ -22,12 +22,14 @@
     <ClCompile Include="codegen.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="parser.cpp" />
+    <ClCompile Include="preprocessor.cpp" />
     <ClCompile Include="utils.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="codegen.h" />
     <ClInclude Include="compiler_types.h" />
     <ClInclude Include="parser.h" />
+    <ClInclude Include="preprocessor.h" />
     <ClInclude Include="utils.h" />
   </ItemGroup>
   <PropertyGroup Label="Globals">

PCCcompiler/PCCcompiler.vcxproj.filters

@@ -27,6 +27,9 @@
     <ClCompile Include="codegen.cpp">
       <Filter>Pliki źródłowe</Filter>
     </ClCompile>
+    <ClCompile Include="preprocessor.cpp">
+      <Filter>Pliki źródłowe</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="utils.h">
@@ -41,5 +44,8 @@
     <ClInclude Include="compiler_types.h">
       <Filter>Pliki nagłówkowe</Filter>
     </ClInclude>
+    <ClInclude Include="preprocessor.h">
+      <Filter>Pliki nagłówkowe</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

PCCcompiler/codegen.cpp

@@ -13,7 +13,6 @@ bool isNumber(const std::string& s) {
     return true;
 }
 
-// Zamienia nazwê zmiennej na adres pamiêci [rbp-X] lub liczbê
 std::string getVarLocation(const std::string& name, const std::map<std::string, int>& locals) {
     std::string cleanName = name;
     // Usuwamy ewentualne spacje
@@ -27,23 +26,43 @@ std::string getVarLocation(const std::string& name, const std::map<std::string,
 
     if (cleanName == "RAX") return "eax";
 
+    // USUNIÊTO: if (cleanName == "this") return "[rbp+16]"; 
+    // Teraz "this" wpadnie do bloku poni¿ej i zostanie znalezione w mapie locals.
+
     if (locals.count(cleanName)) {
         int offset = locals.at(cleanName);
         return "[rbp-" + std::to_string(offset) + "]";
     }
 
-    // Zwracamy orygina³ (jeœli to np. nazwa etykiety), ale to zazwyczaj b³¹d dla zmiennych
+    // Zwracamy orygina³ (jeœli to np. nazwa etykiety)
     return cleanName;
 }
 
+
 std::string generateAssembly(const CompilerState& state) {
-    std::string result;
+    // 1. NAG£ÓWEK I DEKLARACJE EXTERN
+    std::string result = "default rel\n";
     result += "global main\n";
     result += "extern printf\n";
-    result += "extern getchar\n"; // <--- DODAJ TO
+    result += "extern getchar\n";
+    result += "extern _getch\n";
+    result += "extern rand\n";
+    result += "extern srand\n";
+    result += "extern time\n";
+    result += "extern MessageBoxA\n";
+
+    // 2. SEKCJA DATA (Tylko raz!)
     result += "section .data\n";
-    result += "  fmt db '%d', 10, 0\n";
+    result += "  fmt_int db \"%lld\", 10, 0\n";  // Format dla liczb
-    result += "section .text\n\n";
+    result += "  fmt_str db \"%s\", 10, 0\n";    // Format dla stringów
+
+    // Zrzucamy stringi: ETYKIETA db "TRESC", 0
+    for (const auto& p : state.stringLiterals) {
+        result += "  " + p.first + " db \"" + p.second + "\", 0\n";
+    }
+
+    // 3. SEKCJA TEXT (Kod programu)
+    result += "section .text\n";
 
     for (const auto& pair : state.functions) {
         const Function& func = pair.second;
@@ -51,39 +70,196 @@ std::string generateAssembly(const CompilerState& state) {
 
         result += "  push rbp\n";
         result += "  mov rbp, rsp\n";
-        result += "  sub rsp, 256\n";
+        result += "  sub rsp, 512\n"; // Zwiêkszy³em stos dla bezpieczeñstwa obiektów
 
         std::map<std::string, int> stackMap;
         int currentStack = 8;
 
-        // 1. ARGUMENTY
+        // ARGUMENTY FUNKCJI
+        // RCX, RDX, R8, R9 - konwencja Windows x64 (shadow space obs³uguje caller)
+        // Jeœli funkcja jest metod¹, pierwszym argumentem jest 'this' (wskaŸnik na obiekt)
+
+        int argIdx = 0;
         if (func.args.size() > 0) {
             stackMap[func.args[0]] = currentStack;
             result += "  mov [rbp-" + std::to_string(currentStack) + "], rcx ; arg " + func.args[0] + "\n";
             currentStack += 8;
+            argIdx++;
         }
         if (func.args.size() > 1) {
             stackMap[func.args[1]] = currentStack;
             result += "  mov [rbp-" + std::to_string(currentStack) + "], rdx ; arg " + func.args[1] + "\n";
             currentStack += 8;
+            argIdx++;
+        }
+        if (func.args.size() > 2) {
+            stackMap[func.args[2]] = currentStack;
+            result += "  mov [rbp-" + std::to_string(currentStack) + "], r8 ; arg " + func.args[2] + "\n";
+            currentStack += 8;
+            argIdx++;
         }
 
-        // 2. INSTRUKCJE
+        // GENEROWANIE INSTRUKCJI
         for (const auto& instr : func.instructions) {
 
-            // Rezerwacja miejsca dla nowych zmiennych
+            // Rezerwacja miejsca na stosie dla zmiennych
-            if ((instr.type == OpType::ASSIGN || instr.type == OpType::ADD || instr.type == OpType::EQ)
+            bool isWriteOp = (instr.type == OpType::ASSIGN ||
-                && stackMap.find(instr.arg1) == stackMap.end() && instr.arg1 != "RAX") {
+                instr.type == OpType::ADD ||
+                instr.type == OpType::EQ ||
+                instr.type == OpType::SUB ||
+                instr.type == OpType::MUL ||
+                instr.type == OpType::DIV ||
+                instr.type == OpType::MOD ||
+                instr.type == OpType::LOGIC_AND ||
+                instr.type == OpType::LOGIC_OR ||
+                instr.type == OpType::MSGBOX ||
+                instr.type == OpType::ARRAY_DECLARE ||
+                instr.type == OpType::ARRAY_SET ||
+                instr.type == OpType::ALLOC_OBJECT ||
+                instr.type == OpType::LOAD_FIELD);
+
+            if (isWriteOp && stackMap.find(instr.arg1) == stackMap.end() && instr.arg1 != "RAX") {
                 stackMap[instr.arg1] = currentStack;
-                currentStack += 8;
+
+                // Dla obiektów i tablic alokujemy wiêcej miejsca
+                if (instr.type == OpType::ALLOC_OBJECT) {
+                    int size = std::stoi(instr.arg2);
+                    currentStack += size;
+                }
+                else if (instr.type == OpType::ARRAY_DECLARE) {
+                    int size = std::stoi(instr.arg2);
+                    currentStack += (size * 8);
+                }
+                else {
+                    currentStack += 8; // domyœlnie zmienna int/ptr
+                }
             }
 
             switch (instr.type) {
             case OpType::ASSIGN: {
-                std::string src = getVarLocation(instr.arg2, stackMap);
+                // Jeœli Ÿród³em jest wynik funkcji (RAX), nie generujemy "mov rax, eax"
-                std::string dst = getVarLocation(instr.arg1, stackMap);
+                if (instr.arg2 == "RAX") {
-                result += "  mov eax, " + src + "\n";
+                    std::string dst = getVarLocation(instr.arg1, stackMap);
-                result += "  mov " + dst + ", eax\n";
+                    // POPRAWIONE: Tylko dwa backslashe, tak jak w reszcie kodu
+                    result += "  mov " + dst + ", rax\n";
+                }
+                else if (instr.arg3.find("ARRAY_IDX:") == 0) {
+                    std::string indexStr = instr.arg3.substr(10);
+                    std::string arrName = instr.arg2;
+                    std::string dst = getVarLocation(instr.arg1, stackMap);
+                    int baseOffset = stackMap[arrName];
+
+                    if (isNumber(indexStr)) result += "  mov rcx, " + indexStr + "\\n";
+                    else result += "  mov rcx, " + getVarLocation(indexStr, stackMap) + "\\n";
+
+                    result += "  imul rcx, 8\\n";
+                    result += "  mov rdx, rbp\\n";
+                    result += "  sub rdx, " + std::to_string(baseOffset) + "\\n";
+                    result += "  sub rdx, rcx\\n";
+                    result += "  mov rax, [rdx]\\n";
+                    result += "  mov " + dst + ", rax\\n";
+                }
+                else if (instr.arg3 == "STRING") {
+                    std::string src = instr.arg2;
+                    result += "  lea rax, [rel " + src + "]\\n";
+                    std::string dst = getVarLocation(instr.arg1, stackMap);
+                    result += "  mov qword " + dst + ", rax\\n";
+                }
+                else {
+                    std::string srcLoc = getVarLocation(instr.arg2, stackMap);
+                    std::string dst = getVarLocation(instr.arg1, stackMap);
+
+                    std::string src = instr.arg2;
+                    if (isNumber(src)) result += "  mov rax, " + src + "\\n";
+                    else result += "  mov rax, " + srcLoc + "\\n";
+
+                    result += "  mov " + dst + ", rax\\n";
+                }
+                break;
+            }
+
+            case OpType::ALLOC_OBJECT: {
+                // Miejsce na stosie zosta³o zarezerwowane wy¿ej w pêtli (currentStack += size)
+                // Mo¿emy opcjonalnie wyzerowaæ pamiêæ (memset), ale na razie pomijamy dla prostoty
+                // Komentarz w ASM
+                result += "  ; Alloc Object " + instr.arg1 + " size: " + instr.arg2 + "\n";
+                break;
+            }
+            case OpType::STORE_FIELD: {
+                // STORE_FIELD objName, offset, value
+                std::string objName = instr.arg1;
+                int offset = std::stoi(instr.arg2);
+                std::string valStr = instr.arg3;
+
+                // 1. Gdzie jest obiekt? (jego baza)
+                // Obiekt na stosie zaczyna siê pod [RBP - stackMap[objName]]
+                // Pola s¹ kolejne w dó³ stosu (bo stos roœnie w dó³, ale struktura ma dodatnie offsety...
+                // W C lokalne struktury: &obj to najni¿szy adres.
+                // U nas stackMap[obj] to "górny" adres (pierwsze zarezerwowane 8 bajtów).
+                // Przyjmijmy: adres_pola = (RBP - stackMap[objName]) - offset
+
+                // Pobierz wartoϾ do zapisania
+                if (isNumber(valStr)) {
+                    result += "  mov rax, " + valStr + "\n";
+                }
+                else {
+                    result += "  mov rax, " + getVarLocation(valStr, stackMap) + "\n";
+                }
+
+                int baseOffset = 0;
+
+                // SprawdŸ czy objName to "this"
+                if (objName == "this") {
+                    // "this" jest wskaŸnikiem! Trzeba go za³adowaæ
+                    std::string thisPtrLoc = getVarLocation("this", stackMap);
+                    result += "  mov rdx, " + thisPtrLoc + "\n"; // RDX = adres obiektu
+                    // Adres pola = RDX - offset (tutaj uwaga: jeœli alokujemy na stosie "w dó³", to pola maj¹ ujemne offsety wzglêdem bazy?)
+                    // Zróbmy proœciej: w 'ALLOC_OBJECT' rezerwujemy blok. 
+                    // [RBP - base] to pocz¹tek (pole 0).
+                    // [RBP - base - 8] to pole 1 (offset 8).
+                    // Czyli adres = RBP - base - offset.
+
+                    // ALE: "this" przekazany do funkcji to wskaŸnik na ten obszar w pamiêci.
+                    // Jeœli przekazujemy adres zmiennej lokalnej (LEA), to wskaŸnik pokazuje na [RBP-base].
+                    // Wiêc [RDX - offset] powinno zadzia³aæ.
+                    result += "  sub rdx, " + std::to_string(offset) + "\n";
+                    result += "  mov [rdx], rax\n";
+                }
+                else {
+                    // Obiekt lokalny na stosie
+                    baseOffset = stackMap[objName];
+                    result += "  mov rdx, rbp\n";
+                    result += "  sub rdx, " + std::to_string(baseOffset) + "\n";
+                    result += "  sub rdx, " + std::to_string(offset) + "\n";
+                    result += "  mov [rdx], rax\n";
+                }
+                break;
+            }
+            case OpType::LOAD_FIELD: {
+                // LOAD_FIELD destVar, objName, offset
+                std::string destVar = instr.arg1; // gdzie zapisaæ wynik
+                std::string objName = instr.arg2; // sk¹d czytaæ
+                int offset = std::stoi(instr.arg3); // offset pola
+
+                // 1. Oblicz adres pola
+                if (objName == "this") {
+                    std::string thisPtrLoc = getVarLocation("this", stackMap);
+                    result += "  mov rdx, " + thisPtrLoc + "\n";
+                    result += "  sub rdx, " + std::to_string(offset) + "\n";
+                }
+                else {
+                    int baseOffset = stackMap[objName];
+                    result += "  mov rdx, rbp\n";
+                    result += "  sub rdx, " + std::to_string(baseOffset) + "\n";
+                    result += "  sub rdx, " + std::to_string(offset) + "\n";
+                }
+
+                // 2. Pobierz wartoϾ
+                result += "  mov rax, [rdx]\n";
+
+                // 3. Zapisz do zmiennej docelowej
+                std::string destLoc = getVarLocation(destVar, stackMap);
+                result += "  mov " + destLoc + ", rax\n";
                 break;
             }
             case OpType::ADD: {
@@ -95,6 +271,56 @@ std::string generateAssembly(const CompilerState& state) {
                 result += "  mov " + dst + ", eax\n";
                 break;
             }
+            case OpType::SUB: {
+                std::string op1 = getVarLocation(instr.arg2, stackMap);
+                std::string op2 = getVarLocation(instr.arg3, stackMap);
+                std::string dst = getVarLocation(instr.arg1, stackMap);
+                result += "  mov eax, " + op1 + "\n";
+                result += "  sub eax, " + op2 + "\n";
+                result += "  mov " + dst + ", eax\n";
+                break;
+            }
+            case OpType::MUL: {
+                std::string op1 = getVarLocation(instr.arg2, stackMap);
+                std::string op2 = getVarLocation(instr.arg3, stackMap);
+                std::string dst = getVarLocation(instr.arg1, stackMap);
+                result += "  mov eax, " + op1 + "\n";
+                result += "  imul eax, " + op2 + "\n";
+                result += "  mov " + dst + ", eax\n";
+                break;
+            }
+            case OpType::DIV: {
+                std::string op1 = getVarLocation(instr.arg2, stackMap);
+                std::string op2 = getVarLocation(instr.arg3, stackMap);
+                std::string dst = getVarLocation(instr.arg1, stackMap);
+                result += "  mov eax, " + op1 + "\n";
+                result += "  cdq\n";
+                if (isdigit(op2[0]) || op2[0] == '-') {
+                    result += "  mov ecx, " + op2 + "\n";
+                    result += "  idiv ecx\n";
+                }
+                else {
+                    result += "  idiv dword " + op2 + "\n";
+                }
+                result += "  mov " + dst + ", eax\n";
+                break;
+            }
+            case OpType::MOD: {
+                std::string op1 = getVarLocation(instr.arg2, stackMap);
+                std::string op2 = getVarLocation(instr.arg3, stackMap);
+                std::string dst = getVarLocation(instr.arg1, stackMap);
+                result += "  mov eax, " + op1 + "\n";
+                result += "  cdq\n";
+                if (isdigit(op2[0]) || op2[0] == '-') {
+                    result += "  mov ecx, " + op2 + "\n";
+                    result += "  idiv ecx\n";
+                }
+                else {
+                    result += "  idiv dword " + op2 + "\n";
+                }
+                result += "  mov " + dst + ", edx\n";
+                break;
+            }
             case OpType::EQ: {
                 std::string op1 = getVarLocation(instr.arg2, stackMap);
                 std::string op2 = getVarLocation(instr.arg3, stackMap);
@@ -106,94 +332,203 @@ std::string generateAssembly(const CompilerState& state) {
                 result += "  mov " + dst + ", eax\n";
                 break;
             }
+            case OpType::LOGIC_AND: {
+                std::string op1 = getVarLocation(instr.arg2, stackMap);
+                std::string op2 = getVarLocation(instr.arg3, stackMap);
+                std::string dst = getVarLocation(instr.arg1, stackMap);
+                result += "  mov eax, " + op1 + "\n";
+                result += "  cmp eax, 0\n";
+                result += "  setne al\n";
+                if (isdigit(op2[0])) result += "  mov ecx, " + op2 + "\n";
+                else result += "  mov ecx, " + op2 + "\n";
+                result += "  cmp ecx, 0\n";
+                result += "  setne cl\n";
+                result += "  and al, cl\n";
+                result += "  movzx eax, al\n";
+                result += "  mov " + dst + ", eax\n";
+                break;
+            }
+            case OpType::LOGIC_OR: {
+                std::string op1 = getVarLocation(instr.arg2, stackMap);
+                std::string op2 = getVarLocation(instr.arg3, stackMap);
+                std::string dst = getVarLocation(instr.arg1, stackMap);
+                result += "  mov eax, " + op1 + "\n";
+                result += "  cmp eax, 0\n";
+                result += "  setne al\n";
+                if (isdigit(op2[0])) result += "  mov ecx, " + op2 + "\n";
+                else result += "  mov ecx, " + op2 + "\n";
+                result += "  cmp ecx, 0\n";
+                result += "  setne cl\n";
+                result += "  or al, cl\n";
+                result += "  movzx eax, al\n";
+                result += "  mov " + dst + ", eax\n";
+                break;
+            }
             case OpType::JMP_FALSE: {
-                // PARSOWANIE WARUNKU: np. "suma == 30" lub "test"
                 std::string condRaw = instr.arg2;
-                size_t eqPos = condRaw.find("==");
+                std::string cond = getVarLocation(condRaw, stackMap);
+                result += "  mov eax, " + cond + "\n";
+                result += "  test eax, eax\n";
+                result += "  je " + instr.arg1 + "\n";
+                break;
+            }
+            case OpType::JMP: {
+                result += "  jmp " + instr.arg1 + "\n";
+                break;
+            }
+            case OpType::ARRAY_DECLARE: {
+                // Obs³u¿one przy alokacji stosu
+                break;
+            }
+            case OpType::ARRAY_SET: {
+                std::string arrName = instr.arg1;
+                std::string indexStr = instr.arg2;
+                std::string valStr = instr.arg3;
 
-                if (eqPos != std::string::npos) {
+                if (isNumber(valStr)) result += "  mov rax, " + valStr + "\n";
-                    // Mamy porównanie w IFie (a == b)
-                    std::string leftStr = condRaw.substr(0, eqPos);
-                    std::string rightStr = condRaw.substr(eqPos + 2);
-
-                    std::string op1 = getVarLocation(leftStr, stackMap);
-                    std::string op2 = getVarLocation(rightStr, stackMap);
-
-                    result += "  mov eax, " + op1 + "\n";
-                    result += "  cmp eax, " + op2 + "\n";
-                    result += "  jne " + instr.arg1 + " ; jump if NOT equal\n";
-                }
                 else {
-                    // Zwyk³a zmienna boolowska (if test)
+                    std::string valLoc = getVarLocation(valStr, stackMap);
-                    std::string cond = getVarLocation(condRaw, stackMap);
+                    result += "  mov rax, " + valLoc + "\n";
-                    result += "  mov eax, " + cond + "\n";
-                    result += "  test eax, eax\n";
-                    result += "  jz " + instr.arg1 + " ; jump if zero\n";
                 }
+
+                int baseOffset = stackMap[arrName];
+
+                if (isNumber(indexStr)) result += "  mov rcx, " + indexStr + "\n";
+                else {
+                    std::string idxLoc = getVarLocation(indexStr, stackMap);
+                    result += "  mov rcx, " + idxLoc + "\n";
+                }
+
+                result += "  imul rcx, 8\n";
+                result += "  mov rdx, rbp\n";
+                result += "  sub rdx, " + std::to_string(baseOffset) + "\n";
+                result += "  sub rdx, rcx\n";
+                result += "  mov [rdx], rax\n";
                 break;
             }
             case OpType::LABEL: {
                 result += instr.arg1 + ":\n";
                 break;
             }
-            case OpType::RETURN: {
-                std::string val = getVarLocation(instr.arg1, stackMap);
-                result += "  mov eax, " + val + " ; return value\n";
-                result += "  leave\n";
-                result += "  ret\n";
-                break;
-            }
             case OpType::PRINT: {
                 std::string val = getVarLocation(instr.arg1, stackMap);
                 result += "  mov edx, " + val + "\n";
-                result += "  lea rcx, [rel fmt]\n";
+                result += "  lea rcx, [rel fmt_int]\n";
+                result += "  xor eax, eax\n";
+                result += "  call printf\n";
+                break;
+            }
+            case OpType::PRINT_STRING: {
+                std::string target = instr.arg1;
+                if (target.rfind("str_", 0) == 0) {
+                    result += "  lea rdx, [rel " + target + "]\n";
+                }
+                else {
+                    std::string val = getVarLocation(target, stackMap);
+                    result += "  mov rdx, " + val + "\n";
+                }
+                result += "  lea rcx, [rel fmt_str]\n";
+                result += "  xor eax, eax\n";
                 result += "  call printf\n";
                 break;
             }
             case OpType::CALL: {
-                // Parsowanie argumentów
+                if (instr.arg1 == "input" || instr.arg1 == "read_key") {
+                    result += "  call _getch\n";
+                    break;
+                }
+                if (instr.arg1 == "sys_seed") {
+                    result += "  mov rcx, 0\n";
+                    result += "  call time\n";
+                    result += "  mov rcx, rax\n";
+                    result += "  call srand\n";
+                    break;
+                }
+                if (instr.arg1 == "sys_rand") {
+                    result += "  call rand\n";
+                    break;
+                }
+
+                // Call metody/funkcji
+                std::string funcName = instr.arg1;
                 std::string argsRaw = instr.arg2;
                 std::vector<std::string> callArgs;
-                if (instr.arg1 == "input") {
+
-                    result += "  call getchar\n"; // Czeka na enter
-                    break; // Wychodzimy, ¿eby nie robiæ standardowego call
-                }
                 if (!argsRaw.empty()) {
-                    size_t comma = argsRaw.find(',');
+                    std::stringstream ss(argsRaw);
-                    if (comma != std::string::npos) {
+                    std::string segment;
-                        callArgs.push_back(argsRaw.substr(0, comma));
+                    while (std::getline(ss, segment, ',')) {
-                        callArgs.push_back(argsRaw.substr(comma + 1));
+                        callArgs.push_back(segment);
-                    }
+                    }
-                    else {
+                }
-                        callArgs.push_back(argsRaw);
+
+                // Przygotowanie argumentów dla Windows x64 (RCX, RDX, R8, R9)
+                // Argument 0 (RCX) - ewentualnie 'this'
+                if (callArgs.size() > 0) {
+                    // Czy to 'this' (nazwa obiektu)?
+                    std::string arg0 = callArgs[0];
+                    if (state.varTypes.count(arg0) && state.classes.count(state.varTypes.at(arg0))) {
+                        // Przekazujemy ADRES obiektu (pointer)
+                        // Obiekt jest na stosie: [RBP - offset]
+                        // Adres to: RBP - offset
+                        int offset = stackMap.at(arg0);
+                        result += "  lea rcx, [rbp-" + std::to_string(offset) + "]\n";
+                    }
+                    else if (arg0 == "this") {
+                        // Przekazujemy this dalej
+                        result += "  mov rcx, [rbp+16]\n"; // zak³adaj¹c ¿e this jest w shadow space? nie, my go kopiujemy na stos
+                        // Wróæmy do logiki argumentów: argumenty funkcji s¹ kopiowane na stos lokalny.
+                        // arg0 ("this") jest w stackMap["this"].
+                        std::string loc = getVarLocation("this", stackMap);
+                        result += "  mov rcx, " + loc + "\n";
+                    }
+                    else {
+                        // Zwyk³a zmienna / liczba
+                        std::string val = getVarLocation(arg0, stackMap);
+                        if (isNumber(val)) result += "  mov rcx, " + val + "\n";
+                        else result += "  movsxd rcx, dword " + val + "\n";
                     }
                 }
 
-                // Obs³uga RDX (arg 2)
                 if (callArgs.size() > 1) {
                     std::string val = getVarLocation(callArgs[1], stackMap);
-                    if (isNumber(val)) {
+                    if (isNumber(val)) result += "  mov rdx, " + val + "\n";
-                        // Jeœli liczba: mov rdx, 100
+                    else result += "  movsxd rdx, dword " + val + "\n";
-                        result += "  mov rdx, " + val + "\n";
-                    }
-                    else {
-                        // Jeœli zmienna/pamiêæ: movsxd rdx, dword [rbp-8]
-                        result += "  movsxd rdx, dword " + val + "\n";
-                    }
                 }
 
-                // Obs³uga RCX (arg 1)
+                // ... (dalsze argumenty R8, R9 jeœli potrzebujesz)
-                if (callArgs.size() > 0) {
+
-                    std::string val = getVarLocation(callArgs[0], stackMap);
+                result += "  call " + funcName + "\n";
-                    if (isNumber(val)) {
+                break;
-                        result += "  mov rcx, " + val + "\n";
+            }
-                    }
+            case OpType::RETURN: {
-                    else {
+                std::string val = getVarLocation(instr.arg1, stackMap);
-                        result += "  movsxd rcx, dword " + val + "\n";
+                if (!val.empty() && val != ";") {
-                    }
+                    result += "  mov eax, " + val + "\n";
+                }
+                result += "  leave\n";
+                result += "  ret\n";
+                break;
+            }
+            case OpType::MSGBOX: {
+                std::string title = instr.arg1;
+                std::string text = instr.arg2;
+
+                if (text.find("str_") == 0) result += "  lea rdx, [rel " + text + "]\n";
+                else {
+                    std::string loc = getVarLocation(text, stackMap);
+                    result += "  mov rdx, " + loc + "\n";
                 }
 
-                result += "  call " + instr.arg1 + "\n";
+                if (title.find("str_") == 0) result += "  lea r8, [rel " + title + "]\n";
+                else {
+                    std::string loc = getVarLocation(title, stackMap);
+                    result += "  mov r8, " + loc + "\n";
+                }
+
+                result += "  mov rcx, 0\n";
+                result += "  mov r9, 0\n";
+                result += "  call MessageBoxA\n";
                 break;
             }
             }

PCCcompiler/compiler_types.h

@@ -6,23 +6,35 @@
 #include <map>
 #include <stack>
 
-// Typy operacji, które nasz kompilator rozumie
+// Typy operacji
 enum class OpType {
     ASSIGN,     // a = 5
     ADD,        // a = b + c
     SUB,        // a = b - c
     MUL,        // a = b * c
+    DIV,        // a = b / c
+    MOD,        // a = b % c
     EQ,         // a == b
-    PRINT,      // print(a)
+    PRINT,      // print(int)
+    PRINT_STRING, // print(string)
     JMP_FALSE,  // if (false) skocz...
+    ARRAY_DECLARE, // int t[10];
+    ARRAY_SET,     // t[0] = 5;
+    ARRAY_GET,     // x = t[0];
     JMP,        // else / pêtla
+    LOGIC_AND,  // &&
+    LOGIC_OR,   // ||
     LABEL,      // miejsce skoku
     CALL,       // wywo³anie funkcji
     RETURN,     // return x
+    MSGBOX,     // msg box
+    ALLOC_OBJECT,     // alokacja obiektu na stosie - NOWE
+    STORE_FIELD,      // zapis do pola obiektu - NOWE
+    LOAD_FIELD,       // odczyt z pola obiektu - NOWE
     NOP         // pusta instrukcja
 };
 
-// Pojedynczy rozkaz kompilatora (Intermediate Representation)
+// Pojedynczy rozkaz
 struct Instruction {
     OpType type;
     std::string arg1;
@@ -33,24 +45,63 @@ struct Instruction {
 // Definicja funkcji
 struct Function {
     std::string name;
-    std::string returnType; // "int", "void", "bool"
+    std::string returnType;
-    std::vector<std::string> args; // Nazwy argumentów (np. "a", "b")
+    std::vector<std::string> args;
-    std::vector<Instruction> instructions; // Lista rozkazów w funkcji
+    std::vector<Instruction> instructions;
 };
 
+// Definicja pola klasy
+struct ClassField {
+    std::string name;
+    std::string type;     // "int", "string", itp.
+    int offset;           // offset w bajtach od pocz¹tku obiektu
+};
+
+// Definicja metody klasy
+struct ClassMethod {
+    std::string name;
+    std::string returnType;
+    std::vector<std::string> args;
+    std::string mangledName;  // np. "User_setAge"
+};
+
+// Definicja klasy
+struct ClassDef {
+    std::string name;
+    std::vector<ClassField> fields;
+    std::vector<ClassMethod> methods;
+    int totalSize;  // rozmiar ca³ego obiektu w bajtach
+};
+
+// G£ÓWNY STAN KOMPILATORA
 struct CompilerState {
-    // Mapa wszystkich funkcji (klucz to nazwa)
+    // Mapa funkcji
     std::map<std::string, Function> functions;
 
-    // Zmienne globalne (tylko nazwa -> wartoœæ pocz¹tkowa)
+    // Mapa klas (NOWE)
+    std::map<std::string, ClassDef> classes;
+
+    // Zmienne globalne
     std::map<std::string, int> globals;
 
-    // Stan parsera
+    // Zarz¹dzanie stosem
-    Function* currentFunction = nullptr; // WskaŸnik na aktualnie parsuj¹c¹ siê funkcjê
+    std::map<std::string, int> stackMap;
-    int labelCounter = 0; // Do generowania unikalnych nazw etykiet (L1, L2...)
+    int stackOffset = 0;
-    std::stack<std::string> loopStack; // Do break/continue (przysz³oœciowo)
 
+    // Stan parsera
+    Function* currentFunction = nullptr;
+    std::string currentClass = ""; // (NOWE) - nazwa aktualnie parsowanej klasy
+    int labelCounter = 0;
+
+    // Stosy bloków
+    std::stack<std::string> loopStack;
     std::stack<std::string> blockStack;
+
+    std::vector<std::pair<std::string, std::string>> stringLiterals;
+
+    // Licznik do generowania nazw str_0, str_1...
+    int stringCounter = 0;
+    std::map<std::string, std::string> varTypes;
 };
 
 #endif

PCCcompiler/main.cpp

@@ -2,14 +2,24 @@
 #include <fstream>
 #include <string>
 #include <vector>
-#include <cstdlib> // do std::system
+#include <cstdlib>
+#include <filesystem>
+#include <windows.h>
 #include "compiler_types.h"
 #include "parser.h"
 #include "codegen.h"
+#include "preprocessor.h"
+
+std::string getExecutablePath() {
+    char buffer[MAX_PATH];
+    GetModuleFileNameA(NULL, buffer, MAX_PATH);
+    std::string::size_type pos = std::string(buffer).find_last_of("\\/");
+    return std::string(buffer).substr(0, pos);
+}
 
 int main(int argc, char* argv[]) {
     std::string inputFile, outputName;
-    std::string Version = "v1.5.0-modular"; // Zaktualizowałem wersję :)
+    std::string Version = "v0.0.7-beta";
     bool showHelp = false, showVersion = false, showCredits = false;
 
     // --- PARSOWANIE ARGUMENTÓW ---
@@ -68,10 +78,22 @@ int main(int argc, char* argv[]) {
         return 1;
     }
 
+    // ... wczytywanie pliku (to co miałeś) ...
     std::string src((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
     in.close();
 
-    // --- LOGIKA KOMPILATORA ---
+    // --- PREPROCESSOR START ---
+    std::cout << "[INFO] Preprocessing...\n";
+
+    // 1. Ścieżka projektu (tam gdzie plik wejściowy)
+    std::filesystem::path p(inputFile);
+    std::string projectDir = p.parent_path().string();
+
+    // 2. Ścieżka kompilatora (tam gdzie PCC.exe i folder std)
+    std::string compilerDir = getExecutablePath();
+
+    // Uruchamiamy z obiema ścieżkami
+    src = preprocessSource(src, projectDir, compilerDir);
     CompilerState state;
 
     std::cout << "[INFO] Parsing code...\n";

PCCcompiler/parser.cpp

@@ -4,6 +4,17 @@
 #include <sstream>
 #include <vector>
 
+// ===================================================================
+// DEKLARACJE WSTĘPNE
+// ===================================================================
+// Musimy zadeklarować tę funkcję wcześniej, bo używają jej i klasy i main
+bool handleAssignment(const std::string& line, Function& f, CompilerState& state);
+bool parseInstruction(const std::string& line, Function& f, CompilerState& state);
+
+// ===================================================================
+// POMOCNICZE FUNKCJE PARSOWANIA
+// ===================================================================
+
 std::vector<std::string> parseArgs(const std::string& line) {
     std::vector<std::string> args;
     size_t open = line.find('(');
@@ -17,8 +28,7 @@ std::vector<std::string> parseArgs(const std::string& line) {
     std::string segment;
     while (std::getline(ss, segment, ',')) {
         segment = trim(segment);
-        // segment to np. "int a". Szukamy ostatniej spacji, by wziąć nazwę "a"
+        size_t space = segment.find_last_of(" \\t");
-        size_t space = segment.find_last_of(" \t");
         if (space != std::string::npos) {
             args.push_back(trim(segment.substr(space + 1)));
         }
@@ -26,20 +36,584 @@ std::vector<std::string> parseArgs(const std::string& line) {
     return args;
 }
 
-void processSource(const std::string& src, CompilerState& state) {
+std::string registerStringLiteral(CompilerState& state, std::string content) {
-    std::istringstream iss(src);
+    std::string label = "str_" + std::to_string(state.stringCounter++);
-    std::string line;
+    state.stringLiterals.push_back({ label, content });
+    return label;
+}
 
-    while (std::getline(iss, line)) {
+int getClassFieldOffset(CompilerState& state, const std::string& fieldName) {
-        line = trim(line);
+    if (state.currentClass.empty()) return -1;
+    if (state.classes.count(state.currentClass) == 0) return -1;
+
+    const auto& fields = state.classes[state.currentClass].fields;
+    for (const auto& f : fields) {
+        if (f.name == fieldName) return f.offset;
+    }
+    return -1;
+}
+
+// ===================================================================
+// FUNKCJE POMOCNICZE DO OBSŁUGI WARUNKÓW
+// ===================================================================
+
+std::string processCondition(const std::string& conditionRaw, Function& f, CompilerState& state) {
+    std::string cond = trim(conditionRaw);
+
+    int fieldOffset = getClassFieldOffset(state, cond);
+    if (fieldOffset != -1) {
+        std::string tmp = "_cond_fld_" + std::to_string(state.labelCounter++);
+        f.instructions.push_back({ OpType::LOAD_FIELD, tmp, "this", std::to_string(fieldOffset) });
+        cond = tmp;
+    }
+
+    if (cond.find("==") != std::string::npos) {
+        size_t opPos = cond.find("==");
+        std::string a = trim(cond.substr(0, opPos));
+        std::string b = trim(cond.substr(opPos + 2));
+
+        int offA = getClassFieldOffset(state, a);
+        if (offA != -1) {
+            std::string t = "_c_a_" + std::to_string(state.labelCounter++);
+            f.instructions.push_back({ OpType::LOAD_FIELD, t, "this", std::to_string(offA) });
+            a = t;
+        }
+        int offB = getClassFieldOffset(state, b);
+        if (offB != -1) {
+            std::string t = "_c_b_" + std::to_string(state.labelCounter++);
+            f.instructions.push_back({ OpType::LOAD_FIELD, t, "this", std::to_string(offB) });
+            b = t;
+        }
+
+        std::string tmp = "_cond_tmp_" + std::to_string(state.labelCounter++);
+        f.instructions.push_back({ OpType::EQ, tmp, a, b });
+        return tmp;
+    }
+    else if (cond.find("!=") != std::string::npos) {
+        size_t opPos = cond.find("!=");
+        std::string a = trim(cond.substr(0, opPos));
+        std::string b = trim(cond.substr(opPos + 2));
+        std::string tmp = "_cond_tmp_" + std::to_string(state.labelCounter++);
+        f.instructions.push_back({ OpType::EQ, tmp, a, b });
+        return tmp;
+    }
+
+    return cond;
+}
+
+// ===================================================================
+// FUNKCJE OBSŁUGI BLOKÓW
+// ===================================================================
+
+void handleBlockClose(CompilerState& state, const std::vector<std::string>& lines, size_t i) {
+    if (state.blockStack.empty()) {
+        state.currentFunction = nullptr;
+        return;
+    }
+
+    bool nextIsElse = false;
+    size_t j = i + 1;
+    while (j < lines.size()) {
+        std::string nl = trim(lines[j]);
+        if (nl.empty() || nl.rfind("//", 0) == 0) { j++; continue; }
+        if (nl.rfind("else", 0) == 0) nextIsElse = true;
+        break;
+    }
+
+    std::string blockInfo = state.blockStack.top();
+
+    if (blockInfo.rfind("WHILE|", 0) == 0) {
+        state.blockStack.pop();
+        size_t p1 = blockInfo.find('|');
+        size_t p2 = blockInfo.rfind('|');
+        std::string labelStart = blockInfo.substr(p1 + 1, p2 - p1 - 1);
+        std::string labelEnd = blockInfo.substr(p2 + 1);
+
+        if (state.currentFunction) {
+            state.currentFunction->instructions.push_back({ OpType::JMP, labelStart, "", "" });
+            state.currentFunction->instructions.push_back({ OpType::LABEL, labelEnd, "", "" });
+        }
+        return;
+    }
+
+    if (blockInfo.rfind("IF|", 0) == 0) {
+        state.blockStack.pop();
+        size_t p1 = blockInfo.find('|');
+        size_t p2 = blockInfo.rfind('|');
+        std::string labelElse = blockInfo.substr(p1 + 1, p2 - p1 - 1);
+        std::string labelEnd = blockInfo.substr(p2 + 1);
+
+        if (nextIsElse) {
+            if (state.currentFunction) {
+                state.currentFunction->instructions.push_back({ OpType::JMP, labelEnd, "", "" });
+                state.currentFunction->instructions.push_back({ OpType::LABEL, labelElse, "", "" });
+            }
+            state.blockStack.push(labelEnd);
+        }
+        else {
+            if (state.currentFunction) {
+                state.currentFunction->instructions.push_back({ OpType::LABEL, labelElse, "", "" });
+            }
+        }
+        return;
+    }
+
+    state.blockStack.pop();
+    if (state.currentFunction) {
+        state.currentFunction->instructions.push_back({ OpType::LABEL, blockInfo, "", "" });
+    }
+}
+
+// ===================================================================
+// FUNKCJE OBSŁUGI INSTRUKCJI
+// ===================================================================
+
+bool handleReturn(const std::string& line, Function& f, CompilerState& state) {
+    if (line.substr(0, 6) != "return") return false;
+    std::string val = trim(line.substr(6));
+    if (!val.empty() && val.back() == ';') val.pop_back();
+
+    int fieldOffset = getClassFieldOffset(state, val);
+    if (fieldOffset != -1) {
+        std::string tmp = "_ret_tmp_" + std::to_string(state.labelCounter++);
+        f.instructions.push_back({ OpType::LOAD_FIELD, tmp, "this", std::to_string(fieldOffset) });
+        val = tmp;
+    }
+    f.instructions.push_back({ OpType::RETURN, val, "", "" });
+    return true;
+}
+
+bool handleStringDeclaration(const std::string& line, Function& f, CompilerState& state) {
+    if (line.substr(0, 6) != "string") return false;
+    size_t eqPos = line.find("=");
+    if (eqPos == std::string::npos) return false;
+    std::string name = trim(line.substr(7, eqPos - 7));
+    size_t quoteStart = line.find("\"", eqPos);
+    size_t quoteEnd = line.rfind("\"");
+
+    if (quoteStart != std::string::npos && quoteEnd > quoteStart) {
+        std::string content = line.substr(quoteStart + 1, quoteEnd - quoteStart - 1);
+        std::string label = registerStringLiteral(state, content);
+        state.varTypes[name] = "string";
+        f.instructions.push_back({ OpType::ASSIGN, name, label, "" });
+        return true;
+    }
+    return false;
+}
+
+bool handleArrayDeclaration(const std::string& line, Function& f, CompilerState& state) {
+    if (line.substr(0, 3) != "int" || line.find("[") == std::string::npos || line.find("=") != std::string::npos) return false;
+    size_t openBracket = line.find("[");
+    size_t closeBracket = line.find("]");
+
+    if (openBracket != std::string::npos && closeBracket > openBracket) {
+        std::string name = trim(line.substr(3, openBracket - 3));
+        std::string sizeStr = trim(line.substr(openBracket + 1, closeBracket - openBracket - 1));
+        state.varTypes[name] = "array";
+        f.instructions.push_back({ OpType::ARRAY_DECLARE, name, sizeStr, "" });
+        std::cout << " [PARSER] Array Decl: " << name << "[" << sizeStr << "]\\n";
+        return true;
+    }
+    return false;
+}
+
+bool handlePrint(const std::string& line, Function& f, CompilerState& state) {
+    if (line.substr(0, 5) != "print") return false;
+    size_t open = line.find("(");
+    size_t close = line.rfind(")");
+    if (open == std::string::npos || close <= open) return false;
+    std::string content = trim(line.substr(open + 1, close - open - 1));
+
+    if (content.find("[") != std::string::npos && content.back() == ']') {
+        size_t opIdx = content.find("[");
+        std::string arrName = content.substr(0, opIdx);
+        std::string arrIdx = content.substr(opIdx + 1, content.length() - opIdx - 2);
+        std::string tmp = "_p_tmp_" + std::to_string(state.labelCounter++);
+        f.instructions.push_back({ OpType::ASSIGN, tmp, arrName, "ARRAY_IDX:" + arrIdx });
+        f.instructions.push_back({ OpType::PRINT, tmp, "", "" });
+    }
+    else if (content.find(".") != std::string::npos) {
+        size_t dotPos = content.find(".");
+        std::string objName = content.substr(0, dotPos);
+        std::string fieldName = content.substr(dotPos + 1);
+        if (state.varTypes.count(objName) && state.classes.count(state.varTypes[objName])) {
+            std::string className = state.varTypes[objName];
+            int offset = -1;
+            for (auto& field : state.classes[className].fields) {
+                if (field.name == fieldName) { offset = field.offset; break; }
+            }
+            if (offset != -1) {
+                std::string tmp = "_p_tmp_" + std::to_string(state.labelCounter++);
+                f.instructions.push_back({ OpType::LOAD_FIELD, tmp, objName, std::to_string(offset) });
+                f.instructions.push_back({ OpType::PRINT, tmp, "", "" });
+            }
+        }
+    }
+    else if (getClassFieldOffset(state, content) != -1) {
+        int offset = getClassFieldOffset(state, content);
+        std::string tmp = "_p_tmp_" + std::to_string(state.labelCounter++);
+        f.instructions.push_back({ OpType::LOAD_FIELD, tmp, "this", std::to_string(offset) });
+        f.instructions.push_back({ OpType::PRINT, tmp, "", "" });
+    }
+    else if (content.front() == '"' && content.back() == '"') {
+        std::string text = content.substr(1, content.length() - 2);
+        std::string label = registerStringLiteral(state, text);
+        f.instructions.push_back({ OpType::PRINT_STRING, label, "", "" });
+    }
+    else if (state.varTypes.count(content) && state.varTypes[content] == "string") {
+        f.instructions.push_back({ OpType::PRINT_STRING, content, "", "" });
+    }
+    else {
+        f.instructions.push_back({ OpType::PRINT, content, "", "" });
+    }
+    return true;
+}
+
+bool handleIf(const std::string& line, Function& f, CompilerState& state) {
+    if (line.rfind("if", 0) != 0) return false;
+    size_t openParen = line.find("(");
+    size_t closeParen = line.rfind(")");
+    if (openParen == std::string::npos) return false;
+    std::string conditionRaw = trim(line.substr(openParen + 1, closeParen - openParen - 1));
+    std::string finalCond = processCondition(conditionRaw, f, state);
+    std::string labelElse = "L_" + std::to_string(state.labelCounter++);
+    std::string labelEnd = "L_" + std::to_string(state.labelCounter++);
+    f.instructions.push_back({ OpType::JMP_FALSE, labelElse, finalCond, "" });
+    state.blockStack.push("IF|" + labelElse + "|" + labelEnd);
+    return true;
+}
+
+bool handleWhile(const std::string& line, Function& f, CompilerState& state) {
+    if (line.substr(0, 5) != "while") return false;
+    size_t openParen = line.find("(");
+    size_t closeParen = line.rfind(")");
+    if (openParen == std::string::npos) return false;
+    std::string conditionRaw = trim(line.substr(openParen + 1, closeParen - openParen - 1));
+    std::string labelStart = "L_" + std::to_string(state.labelCounter++);
+    std::string labelEnd = "L_" + std::to_string(state.labelCounter++);
+    f.instructions.push_back({ OpType::LABEL, labelStart, "", "" });
+    std::string finalCond = processCondition(conditionRaw, f, state);
+    f.instructions.push_back({ OpType::JMP_FALSE, labelEnd, finalCond, "" });
+    state.blockStack.push("WHILE|" + labelStart + "|" + labelEnd);
+    return true;
+}
+
+bool handleMsgbox(const std::string& line, Function& f, CompilerState& state) {
+    if (line.substr(0, 6) != "msgbox") return false;
+    size_t open = line.find("(");
+    size_t close = line.rfind(")");
+    if (open == std::string::npos) return false;
+    std::string args = line.substr(open + 1, close - open - 1);
+    size_t comma = args.find(",");
+    if (comma == std::string::npos) return false;
+    std::string arg1 = trim(args.substr(0, comma));
+    std::string arg2 = trim(args.substr(comma + 1));
+    std::string l1 = (arg1.front() == '"') ? registerStringLiteral(state, arg1.substr(1, arg1.size() - 2)) : arg1;
+    std::string l2 = (arg2.front() == '"') ? registerStringLiteral(state, arg2.substr(1, arg2.size() - 2)) : arg2;
+    f.instructions.push_back({ OpType::MSGBOX, l1, l2, "" });
+    return true;
+}
+
+bool handleAssignment(const std::string& line, Function& f, CompilerState& state) {
+    // Specjalny przypadek: samodzielne wywołanie metody/funkcji bez "="
+    if (line.find("=") == std::string::npos) {
+        if (line.find("(") != std::string::npos && line.find(")") != std::string::npos) {
+            // Metoda: u.setAge(5);
+            if (line.find(".") != std::string::npos) {
+                size_t dotPos = line.find(".");
+                size_t openParen = line.find("(");
+                std::string objName = trim(line.substr(0, dotPos));
+                std::string methodName = trim(line.substr(dotPos + 1, openParen - dotPos - 1));
+                std::string argsContent = line.substr(openParen + 1, line.rfind(")") - openParen - 1);
+
+                if (state.varTypes.count(objName)) {
+                    std::string className = state.varTypes[objName];
+                    std::string mangledName = className + "_" + methodName;
+                    std::string fullArgs = objName;
+                    if (!argsContent.empty()) fullArgs += "," + argsContent;
+                    f.instructions.push_back({ OpType::CALL, mangledName, fullArgs, "" });
+                    return true;
+                }
+            }
+            // Zwykła funkcja: func();
+            size_t open = line.find('(');
+            std::string funcName = trim(line.substr(0, open));
+            std::string argsContent = line.substr(open + 1, line.find(')') - open - 1);
+            f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
+            return true;
+        }
+        return false;
+    }
+
+    size_t eqPos = line.find('=');
+    std::string leftSide = trim(line.substr(0, eqPos));
+    std::string rightSide = trim(line.substr(eqPos + 1));
+    if (!rightSide.empty() && rightSide.back() == ';') rightSide.pop_back();
+
+    // 1. Zapis do pola: u.age = 5
+    if (leftSide.find(".") != std::string::npos && leftSide.find("[") == std::string::npos) {
+        size_t dotPos = leftSide.find(".");
+        std::string objName = trim(leftSide.substr(0, dotPos));
+        std::string fieldName = trim(leftSide.substr(dotPos + 1));
+        std::string className = state.varTypes[objName];
+        ClassDef& cls = state.classes[className];
+        int offset = -1;
+        for (auto& field : cls.fields) {
+            if (field.name == fieldName) { offset = field.offset; break; }
+        }
+        f.instructions.push_back({ OpType::STORE_FIELD, objName, std::to_string(offset), rightSide });
+        return true;
+    }
+    // 2. Zapis do pola wewnątrz metody: age = 5
+    else {
+        int fieldOffset = getClassFieldOffset(state, leftSide);
+        if (fieldOffset != -1) {
+            f.instructions.push_back({ OpType::STORE_FIELD, "this", std::to_string(fieldOffset), rightSide });
+            return true;
+        }
+    }
+
+    // Tablice
+    if (leftSide.find("[") != std::string::npos) {
+        size_t open = leftSide.find("[");
+        size_t close = leftSide.find("]");
+        std::string arrName = trim(leftSide.substr(0, open));
+        std::string index = trim(leftSide.substr(open + 1, close - open - 1));
+        f.instructions.push_back({ OpType::ARRAY_SET, arrName, index, rightSide });
+        return true;
+    }
+
+    std::string varName = leftSide;
+    if (leftSide.rfind("int ", 0) == 0) varName = trim(leftSide.substr(4));
+    else if (leftSide.rfind("bool ", 0) == 0) varName = trim(leftSide.substr(5));
+    else if (leftSide.rfind("string ", 0) == 0) varName = trim(leftSide.substr(7));
+
+    // Odczyt pola: x = u.age
+    if (rightSide.find(".") != std::string::npos && rightSide.find("(") == std::string::npos) {
+        size_t dot = rightSide.find(".");
+        std::string obj = rightSide.substr(0, dot);
+        std::string fld = rightSide.substr(dot + 1);
+        if (state.varTypes.count(obj)) {
+            std::string cName = state.varTypes[obj];
+            int off = -1;
+            for (auto& ff : state.classes[cName].fields) if (ff.name == fld) off = ff.offset;
+            if (off != -1) {
+                f.instructions.push_back({ OpType::LOAD_FIELD, varName, obj, std::to_string(off) });
+                return true;
+            }
+        }
+    }
+
+    // Tablice odczyt
+    if (rightSide.find("[") != std::string::npos && rightSide.back() == ']') {
+        size_t open = rightSide.find("[");
+        size_t close = rightSide.find("]");
+        std::string arrName = trim(rightSide.substr(0, open));
+        std::string index = trim(rightSide.substr(open + 1, close - open - 1));
+        f.instructions.push_back({ OpType::ASSIGN, varName, arrName, "ARRAY_IDX:" + index });
+        return true;
+    }
+
+    // Wywołanie metody po prawej stronie: x = u.getAge()
+    if (rightSide.find("(") != std::string::npos && rightSide.find(")") != std::string::npos) {
+        if (rightSide.find(".") != std::string::npos) {
+            size_t dot = rightSide.find(".");
+            size_t op = rightSide.find("(");
+            std::string obj = trim(rightSide.substr(0, dot));
+            std::string met = trim(rightSide.substr(dot + 1, op - dot - 1));
+            std::string args = rightSide.substr(op + 1, rightSide.find(")") - op - 1);
+            std::string cName = state.varTypes[obj];
+            std::string mangled = cName + "_" + met;
+            std::string fullArgs = obj;
+            if (!args.empty()) fullArgs += "," + args;
+            f.instructions.push_back({ OpType::CALL, mangled, fullArgs, "" });
+            f.instructions.push_back({ OpType::ASSIGN, varName, "RAX", "" });
+            return true;
+        }
+        // Zwykła funkcja
+        size_t open = rightSide.find('(');
+        std::string funcName = trim(rightSide.substr(0, open));
+        std::string argsContent = rightSide.substr(open + 1, rightSide.find(')') - open - 1);
+        f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
+        f.instructions.push_back({ OpType::ASSIGN, varName, "RAX", "" });
+        return true;
+    }
+
+    // Arytmetyka
+    struct Operator { std::string symbol; OpType type; size_t length; };
+    std::vector<Operator> operators = {
+        {"&&", OpType::LOGIC_AND, 2}, {"||", OpType::LOGIC_OR, 2}, {"==", OpType::EQ, 2},
+        {"+", OpType::ADD, 1}, {"-", OpType::SUB, 1}, {"*", OpType::MUL, 1}, {"/", OpType::DIV, 1}, {"%", OpType::MOD, 1}
+    };
+    for (const auto& op : operators) {
+        size_t opPos = rightSide.find(op.symbol);
+        if (opPos != std::string::npos) {
+            std::string a = trim(rightSide.substr(0, opPos));
+            std::string b = trim(rightSide.substr(opPos + op.length));
+            int offA = getClassFieldOffset(state, a);
+            if (offA != -1) { std::string t = "_opa" + std::to_string(state.labelCounter++); f.instructions.push_back({ OpType::LOAD_FIELD, t, "this", std::to_string(offA) }); a = t; }
+            int offB = getClassFieldOffset(state, b);
+            if (offB != -1) { std::string t = "_opb" + std::to_string(state.labelCounter++); f.instructions.push_back({ OpType::LOAD_FIELD, t, "this", std::to_string(offB) }); b = t; }
+            f.instructions.push_back({ op.type, varName, a, b });
+            return true;
+        }
+    }
+
+    if (rightSide.size() >= 2 && rightSide.front() == '"') {
+        std::string content = rightSide.substr(1, rightSide.size() - 2);
+        std::string label = registerStringLiteral(state, content);
+        state.varTypes[varName] = "string";
+        f.instructions.push_back({ OpType::ASSIGN, varName, label, "" });
+        return true;
+    }
+
+    int fOff = getClassFieldOffset(state, rightSide);
+    if (fOff != -1) {
+        f.instructions.push_back({ OpType::LOAD_FIELD, varName, "this", std::to_string(fOff) });
+    }
+    else {
+        f.instructions.push_back({ OpType::ASSIGN, varName, rightSide, "" });
+    }
+    return true;
+}
+
+bool handleFunctionCall(const std::string& line, Function& f) {
+    if (line.find("(") == std::string::npos || line.find(")") == std::string::npos) return false;
+    size_t open = line.find('(');
+    std::string funcName = trim(line.substr(0, open));
+    std::string argsContent = line.substr(open + 1, line.find(')') - open - 1);
+    f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
+    return true;
+}
+
+// Funkcja zbiorcza parsująca jedną linię (dla processSource i dla metody w klasie)
+bool parseInstruction(const std::string& line, Function& f, CompilerState& state) {
+    if (line.rfind("else", 0) == 0) return true;
+
+    if (handleReturn(line, f, state)) return true;
+    if (handleStringDeclaration(line, f, state)) return true;
+    if (handleArrayDeclaration(line, f, state)) return true;
+    if (handlePrint(line, f, state)) return true;
+    if (handleIf(line, f, state)) return true;
+    if (handleWhile(line, f, state)) return true;
+    if (handleMsgbox(line, f, state)) return true;
+
+    // handleAssignment obsługuje też wywołania metod i operacje
+    if (handleAssignment(line, f, state)) return true;
+
+    // Deklaracja obiektu: User u;
+    if (state.classes.count(line.substr(0, line.find(" "))) > 0) {
+        size_t spacePos = line.find(" ");
+        std::string className = line.substr(0, spacePos);
+        std::string varName = trim(line.substr(spacePos + 1));
+        if (varName.back() == ';') varName.pop_back();
+        state.varTypes[varName] = className;
+        int size = state.classes[className].totalSize;
+        f.instructions.push_back({ OpType::ALLOC_OBJECT, varName, std::to_string(size), "" });
+        return true;
+    }
+
+    return false;
+}
+
+// ===================================================================
+// PARSOWANIE KLASY (TERAZ PARSUJE CIAŁA METOD!)
+// ===================================================================
+
+void parseClassDefinition(const std::vector<std::string>& lines, size_t& i, CompilerState& state) {
+    std::string line = trim(lines[i]);
+    size_t bracePos = line.find("{");
+    std::string className = trim(line.substr(6, bracePos - 6));
+
+    ClassDef classDef;
+    classDef.name = className;
+    int currentOffset = 0;
+    i++;
+
+    while (i < lines.size()) {
+        line = trim(lines[i]);
+        if (line == "}") break;
+        if (line.empty() || line.rfind("//", 0) == 0) { i++; continue; }
+
+        if (line.back() == ';' && line.find("(") == std::string::npos && line.find("=") == std::string::npos) {
+            size_t spacePos = line.find(" ");
+            std::string type = line.substr(0, spacePos);
+            std::string name = trim(line.substr(spacePos + 1, line.size() - spacePos - 2));
+            ClassField field; field.name = name; field.type = type; field.offset = currentOffset;
+            if (type == "int" || type == "bool") currentOffset += 8;
+            else if (type == "string") currentOffset += 8;
+            classDef.fields.push_back(field);
+            std::cout << "  [CLASS] Field: " << type << " " << name << " @ offset " << field.offset << "\n";
+        }
+        else if (line.find("(") != std::string::npos && line.find("{") != std::string::npos) {
+            size_t openParen = line.find("(");
+            size_t spacePos = line.find(" ");
+            std::string returnType = line.substr(0, spacePos);
+            std::string methodName = trim(line.substr(spacePos + 1, openParen - spacePos - 1));
+
+            ClassMethod method;
+            method.name = methodName; method.returnType = returnType;
+            method.args = parseArgs(line);
+            method.mangledName = className + "_" + methodName;
+            classDef.methods.push_back(method);
+
+            Function newFunc;
+            newFunc.name = method.mangledName;
+            newFunc.returnType = returnType;
+            newFunc.args = method.args;
+            newFunc.args.insert(newFunc.args.begin(), "this");
+            state.functions[method.mangledName] = newFunc;
+
+            // --- TUTAJ PARSUJEMY WNĘTRZE METODY ---
+            state.currentFunction = &state.functions[method.mangledName];
+            state.currentClass = className;
+            state.classes[className] = classDef; // Rejestrujemy tymczasowo, by widzieć pola
+
+            i++; // Wejdź do środka metody
+            while (i < lines.size()) {
+                std::string mLine = trim(lines[i]);
+                if (mLine == "}") break; // Koniec metody
+                if (!mLine.empty() && mLine.rfind("//", 0) != 0) {
+                    parseInstruction(mLine, *state.currentFunction, state);
+                }
+                i++;
+            }
+            state.currentFunction = nullptr;
+            state.currentClass = "";
+        }
+        i++;
+    }
+    classDef.totalSize = currentOffset;
+    state.classes[className] = classDef;
+    std::cout << "[PARSER] Class " << className << " registered size=" << currentOffset << "\n";
+}
+
+// ===================================================================
+// GŁÓWNA PĘTLA
+// ===================================================================
+
+void processSource(const std::string& src, CompilerState& state) {
+    std::vector<std::string> lines;
+    std::istringstream iss(src);
+    std::string t;
+    while (std::getline(iss, t)) lines.push_back(trim(t));
+
+    for (size_t i = 0; i < lines.size(); i++) {
+        std::string line = trim(lines[i]);
         if (line.empty() || line.substr(0, 2) == "//" || line[0] == '#') continue;
 
-        // --- 1. DEFINICJA FUNKCJI ---
+        if (line.find("} else") != std::string::npos) {
-        // Warunki: zaczyna się od typu, ma '(', ma '{' i NIE ma '=' (żeby nie mylić ze zmienną)
+            handleBlockClose(state, lines, i);
+            continue;
+        }
+
+        if (line.rfind("class ", 0) == 0 && line.find("{") != std::string::npos) {
+            parseClassDefinition(lines, i, state);
+            continue;
+        }
+
         bool startsWithType = (line.rfind("int ", 0) == 0 || line.rfind("void ", 0) == 0 || line.rfind("bool ", 0) == 0);
-
         if (startsWithType && line.find("(") != std::string::npos && line.find("{") != std::string::npos && line.find("=") == std::string::npos) {
-
             size_t openParen = line.find('(');
             std::string typeRaw = line.substr(0, line.find(' '));
             std::string nameRaw = line.substr(typeRaw.length(), openParen - typeRaw.length());
@@ -49,124 +623,21 @@ void processSource(const std::string& src, CompilerState& state) {
             newFunc.name = funcName;
             newFunc.returnType = typeRaw;
             newFunc.args = parseArgs(line);
-
             state.functions[funcName] = newFunc;
             state.currentFunction = &state.functions[funcName];
-
             std::cout << "[PARSER] New Function: " << funcName << "\n";
             continue;
         }
 
-        // --- 2. ZAMYKANIE BLOKU '}' ---
         if (line == "}") {
-            // Najpierw sprawdzamy, czy zamykamy IF-a (czy jest coś na stosie bloków)
+            handleBlockClose(state, lines, i);
-            if (!state.blockStack.empty()) {
-                std::string label = state.blockStack.top();
-                state.blockStack.pop();
-                if (state.currentFunction) {
-                    state.currentFunction->instructions.push_back({ OpType::LABEL, label, "", "" });
-                }
-                std::cout << " [PARSER] } End IF block -> " << label << "\n";
-            }
-            else {
-                // Jeśli stos pusty, to koniec funkcji
-                state.currentFunction = nullptr;
-                std::cout << " [PARSER] } End Function\n";
-            }
             continue;
         }
 
-        // --- JESTEŚMY W ŚRODKU FUNKCJI ---
         if (state.currentFunction) {
-            Function& f = *state.currentFunction;
+            parseInstruction(line, *state.currentFunction, state);
-
-            // A. RETURN
-            if (line.substr(0, 6) == "return") {
-                std::string val = trim(line.substr(6));
-                if (!val.empty() && val.back() == ';') val.pop_back();
-                f.instructions.push_back({ OpType::RETURN, val, "", "" });
-                std::cout << " [PARSER] Return: " << val << "\n";
-            }
-            // B. PRINT
-            else if (line.substr(0, 5) == "print") {
-                size_t start = line.find('(') + 1;
-                size_t end = line.find(')');
-                if (start != std::string::npos && end != std::string::npos) {
-                    std::string var = trim(line.substr(start, end - start));
-                    f.instructions.push_back({ OpType::PRINT, var, "", "" });
-                }
-            }
-            // C. IF STATEMENT
-            else if (line.substr(0, 2) == "if") {
-                size_t openParen = line.find("(");
-                size_t closeParen = line.find(")");
-                if (openParen != std::string::npos && closeParen > openParen) {
-                    std::string condition = trim(line.substr(openParen + 1, closeParen - openParen - 1));
-                    std::string labelName = "L_" + std::to_string(state.labelCounter++);
-
-                    // Skok warunkowy
-                    f.instructions.push_back({ OpType::JMP_FALSE, labelName, condition, "" });
-                    state.blockStack.push(labelName);
-
-                    std::cout << " [PARSER] IF (" << condition << ") -> Jump to " << labelName << "\n";
-                }
-            }
-            // D. PRZYPISANIE ZMIENNEJ (LUB DEKLARACJA)
-            // np. "int a = 5;" LUB "a = b + c;"
-            else if (line.find("=") != std::string::npos) {
-                size_t eqPos = line.find('=');
-                std::string leftSide = trim(line.substr(0, eqPos));
-                std::string rightSide = trim(line.substr(eqPos + 1));
-                if (!rightSide.empty() && rightSide.back() == ';') rightSide.pop_back();
-
-                // Obsługa nazwy zmiennej (usuwanie "int ", "bool ")
-                std::string varName = leftSide;
-                if (leftSide.rfind("int ", 0) == 0) varName = trim(leftSide.substr(4));
-                else if (leftSide.rfind("bool ", 0) == 0) varName = trim(leftSide.substr(5));
-
-                // 1. Czy to wywołanie funkcji? int x = func();
-                if (rightSide.find("(") != std::string::npos && rightSide.find(")") != std::string::npos) {
-                    size_t open = rightSide.find('(');
-                    std::string funcName = trim(rightSide.substr(0, open));
-                    std::string argsContent = rightSide.substr(open + 1, rightSide.find(')') - open - 1);
-
-                    // CALL func
-                    f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
-                    // ASSIGN result (RAX) to variable
-                    f.instructions.push_back({ OpType::ASSIGN, varName, "RAX", "" });
-                    std::cout << " [PARSER] Call & Assign: " << varName << " = " << funcName << "()\n";
-                }
-                // 2. Czy to dodawanie? a + b
-                else if (rightSide.find("+") != std::string::npos) {
-                    size_t opPos = rightSide.find("+");
-                    std::string a = trim(rightSide.substr(0, opPos));
-                    std::string b = trim(rightSide.substr(opPos + 1));
-                    f.instructions.push_back({ OpType::ADD, varName, a, b });
-                }
-                // 3. Czy to porównanie? a == b (Ważne: == może być w IFie, ale tu jesteśmy w linii z '=')
-                // UWAGA: To rzadkie w C++ (bool x = a == b), ale obsłużmy proste przypisanie wartości logicznej
-                else if (rightSide.find("==") != std::string::npos) {
-                    size_t opPos = rightSide.find("==");
-                    std::string a = trim(rightSide.substr(0, opPos));
-                    std::string b = trim(rightSide.substr(opPos + 2));
-                    f.instructions.push_back({ OpType::EQ, varName, a, b });
-                }
-                // 4. Zwykłe przypisanie: a = 5
-                else {
-                    f.instructions.push_back({ OpType::ASSIGN, varName, rightSide, "" });
-                }
-            }
-            // E. SAMODZIELNE WYWOŁANIE FUNKCJI (bez =)
-            // np. func();
-            else if (line.find("(") != std::string::npos && line.find(")") != std::string::npos) {
-                size_t open = line.find('(');
-                std::string funcName = trim(line.substr(0, open));
-                std::string argsContent = line.substr(open + 1, line.find(')') - open - 1);
-
-                f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
-                std::cout << " [PARSER] Call void: " << funcName << "\n";
-            }
         }
     }
 }
+
 void calculateExpressions(CompilerState& state) {}

PCCcompiler/preprocessor.cpp

@@ -0,0 +1,130 @@
+#include "preprocessor.h"
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <filesystem>
+#include <unordered_set>
+
+namespace fs = std::filesystem;
+
+static std::string ltrim(std::string s) {
+    const size_t first = s.find_first_not_of(" \t");
+    if (first == std::string::npos) return "";
+    return s.substr(first);
+}
+
+static std::string loadFileContent(const std::string& path) {
+    std::ifstream in(path, std::ios::binary);
+    if (!in) {
+        std::cerr << "[PREPROCESSOR] Error: Could not open included file: " << path << "\n";
+        return "";
+    }
+    return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+}
+
+// Próbuje sparsowaæ #include "x" albo #include <x>
+// Zwraca: true jeœli linia to include i uda³o siê wyci¹gn¹æ œcie¿kê.
+static bool parseIncludeLine(const std::string& line, std::string& includePath, bool& isStdLib) {
+    includePath.clear();
+    isStdLib = false;
+
+    std::string t = ltrim(line);
+    if (t.rfind("#include", 0) != 0) return false;
+
+    const size_t openQuote = t.find('"');
+    const size_t closeQuote = t.rfind('"');
+    const size_t openAngle = t.find('<');
+    const size_t closeAngle = t.rfind('>');
+
+    if (openQuote != std::string::npos && closeQuote != std::string::npos && closeQuote > openQuote) {
+        includePath = t.substr(openQuote + 1, closeQuote - openQuote - 1);
+        isStdLib = false;
+        return true;
+    }
+
+    if (openAngle != std::string::npos && closeAngle != std::string::npos && closeAngle > openAngle) {
+        includePath = t.substr(openAngle + 1, closeAngle - openAngle - 1);
+        isStdLib = true;
+        return true;
+    }
+
+    // To jest #include ale w z³ym formacie (np. brak cudzys³owu / nawiasów)
+    return true;
+}
+
+// Wewnêtrzna funkcja z guardem na rekurencjê.
+static std::string preprocessSourceImpl(
+    const std::string& src,
+    const std::string& projectDir,
+    const std::string& compilerDir,
+    std::unordered_set<std::string>& includeGuard
+) {
+    std::istringstream iss(src);
+    std::string line;
+    std::stringstream output;
+
+    while (std::getline(iss, line)) {
+        std::string includePath;
+        bool isStdLib = false;
+
+        const bool isIncludeLine = parseIncludeLine(line, includePath, isStdLib);
+
+        if (!isIncludeLine) {
+            output << line << "\n";
+            continue;
+        }
+
+        if (includePath.empty()) {
+            output << "\n// [PREPROCESSOR] Invalid include (no path): " << line << "\n";
+            continue;
+        }
+
+        // Z³ó¿ fullPath
+        fs::path fullPath;
+        if (isStdLib) {
+            fullPath = fs::path(compilerDir) / "std" / includePath;
+            std::cout << "[PREPROCESSOR] Including STD lib: " << fullPath.string() << "\n";
+        }
+        else {
+            if (projectDir.empty()) fullPath = fs::path(includePath);
+            else fullPath = fs::path(projectDir) / includePath;
+            std::cout << "[PREPROCESSOR] Including local file: " << fullPath.string() << "\n";
+        }
+
+        // Normalizacja œcie¿ki (jeœli siê da)
+        std::string guardKey;
+        try {
+            guardKey = fs::weakly_canonical(fullPath).string();
+        }
+        catch (...) {
+            guardKey = fullPath.lexically_normal().string();
+        }
+
+        // Guard przeciw include-loop oraz wielokrotnemu includowaniu
+        if (includeGuard.find(guardKey) != includeGuard.end()) {
+            output << "\n// [PREPROCESSOR] Skipped include (already included): " << includePath << "\n";
+            continue;
+        }
+        includeGuard.insert(guardKey);
+
+        // Wczytaj + przetwórz rekurencyjnie
+        std::string content = loadFileContent(fullPath.string());
+        if (content.empty()) {
+            output << "\n// [PREPROCESSOR] FAILED INCLUDE: " << includePath << "\n";
+            continue;
+        }
+
+        std::string processedContent = preprocessSourceImpl(content, projectDir, compilerDir, includeGuard);
+
+        output << "\n// --- BEGIN INCLUDE: " << includePath << " ---\n";
+        output << processedContent;
+        output << "\n// --- END INCLUDE ---\n";
+    }
+
+    return output.str();
+}
+
+std::string preprocessSource(const std::string& src, const std::string& projectDir, const std::string& compilerDir) {
+    std::unordered_set<std::string> includeGuard;
+    return preprocessSourceImpl(src, projectDir, compilerDir, includeGuard);
+}

PCCcompiler/preprocessor.h

@@ -0,0 +1,13 @@
+#ifndef PREPROCESSOR_H
+#define PREPROCESSOR_H
+
+#include <string>
+std::string preprocessSource(
+    const std::string& src,
+    const std::string& projectDir,
+    const std::string& compilerDir
+);
+
+
+
+#endif

README.md

@@ -1,17 +1,23 @@
 # PCC Compiler (My C++ Compiler)
 
-![Version](https://img.shields.io/badge/version-1.5.0-blue.svg)
+![Version](https://img.shields.io/badge/version-0.0.9-blue.svg)
 ![Status](https://img.shields.io/badge/status-BETA-orange.svg)
 ![Platform](https://img.shields.io/badge/platform-Windows%20x64-lightgrey.svg)
 
+## Docs
+https://nodrop.xyz/docs/docs.html
+
 **PCC Compiler** is a custom programming language compiler built from scratch in C++. It translates PCC code into x64 Assembly (NASM), which is then linked into a standalone Windows executable.
 
 ## 🚀 Features
 - **Custom Syntax**: C-like syntax easy for beginners.
-- **Variables**: Support for `int` and `bool`.
+- **Variables**: Support for `int`, `bool` and `string`.
+- **include files**: you can include base files from compiler `#include <main.pcc>` or your own files `#include "myfile.pcc"`.
+- **KeyBoard and Inputs Support**: now you can control keyboard inputs using `#include <Input.pcc>`.
 - **Control Flow**: `if` statements support.
 - **Functions**: Define and call `void` functions.
 - **Native Compilation**: Compiles directly to x64 machine code.
+- **More Informations**: For more informations check PCC Docs.
 
 ## 🛠️ Usage
 1. Download the latest release from the [Releases](../../releases) page.