Large Functions Update

PCCcompiler.slnx

@@ -0,0 +1,7 @@
+<Solution>
+  <Configurations>
+    <Platform Name="x64" />
+    <Platform Name="x86" />
+  </Configurations>
+  <Project Path="PCCcompiler/PCCcompiler.vcxproj" Id="60a99674-9bdb-4552-bfef-fc5b17de2cf8" />
+</Solution>

PCCcompiler/PCCcompiler.vcxproj

@@ -0,0 +1,146 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <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">
+    <VCProjectVersion>18.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{60a99674-9bdb-4552-bfef-fc5b17de2cf8}</ProjectGuid>
+    <RootNamespace>PCCcompiler</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v145</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v145</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v145</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v145</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

PCCcompiler/PCCcompiler.vcxproj.filters

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Pliki źródłowe">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Pliki nagłówkowe">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Pliki zasobów">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="main.cpp">
+      <Filter>Pliki źródłowe</Filter>
+    </ClCompile>
+    <ClCompile Include="utils.cpp">
+      <Filter>Pliki źródłowe</Filter>
+    </ClCompile>
+    <ClCompile Include="parser.cpp">
+      <Filter>Pliki źródłowe</Filter>
+    </ClCompile>
+    <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">
+      <Filter>Pliki nagłówkowe</Filter>
+    </ClInclude>
+    <ClInclude Include="parser.h">
+      <Filter>Pliki nagłówkowe</Filter>
+    </ClInclude>
+    <ClInclude Include="codegen.h">
+      <Filter>Pliki nagłówkowe</Filter>
+    </ClInclude>
+    <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

@@ -0,0 +1,490 @@
+#include "codegen.h"
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+// Pomocnicza funkcja: sprawdza czy string to czysta liczba
+bool isNumber(const std::string& s) {
+    if (s.empty()) return false;
+    size_t start = (s[0] == '-') ? 1 : 0;
+    for (size_t i = start; i < s.length(); i++) {
+        if (!isdigit(s[i])) return false;
+    }
+    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
+    size_t first = cleanName.find_first_not_of(" \t");
+    if (first != std::string::npos) cleanName = cleanName.substr(first);
+    size_t last = cleanName.find_last_not_of(" \t");
+    if (last != std::string::npos) cleanName = cleanName.substr(0, last + 1);
+
+    if (cleanName.empty()) return "0";
+    if (isNumber(cleanName)) return cleanName;
+
+    if (cleanName == "RAX") return "eax";
+
+    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
+    return cleanName;
+}
+
+std::string generateAssembly(const CompilerState& state) {
+    // 1. NAG£ÓWEK I DEKLARACJE EXTERN
+    std::string result = "default rel\n";
+    result += "global main\n";
+    result += "extern printf\n";
+    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_int db \"%lld\", 10, 0\n";  // Format dla liczb
+    result += "  fmt_str db \"%s\", 10, 0\n";    // Format dla stringów
+
+    // Zrzucamy stringi: ETYKIETA db "TRESC", 0
+    for (const auto& p : state.stringLiterals) {
+        // p.first  -> Etykieta (np. str_0)
+        // p.second -> TreϾ (np. Hello World)
+        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;
+        result += func.name + ":\n";
+
+        result += "  push rbp\n";
+        result += "  mov rbp, rsp\n";
+        result += "  sub rsp, 256\n";
+
+        std::map<std::string, int> stackMap;
+        int currentStack = 8;
+
+        // ARGUMENTY FUNKCJI
+        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;
+        }
+        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;
+        }
+
+        // GENEROWANIE INSTRUKCJI
+        for (const auto& instr : func.instructions) {
+
+            // Rezerwacja miejsca na stosie
+            bool isWriteOp = (instr.type == OpType::ASSIGN ||
+                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);
+
+            if (isWriteOp && stackMap.find(instr.arg1) == stackMap.end() && instr.arg1 != "RAX") {
+                stackMap[instr.arg1] = currentStack;
+                currentStack += 8;
+            }
+
+            switch (instr.type) {
+            case OpType::ASSIGN: {
+                std::string src = instr.arg2;
+                // ODCZYT TABLICY: x = t[i]
+                if (instr.arg3.find("ARRAY_IDX:") == 0) {
+                    std::string indexStr = instr.arg3.substr(10); // Pobierz "i"
+                    std::string arrName = instr.arg2; // Pobierz "t"
+                    std::string dst = getVarLocation(instr.arg1, stackMap);
+
+                    int baseOffset = stackMap[arrName];
+
+                    // £adujemy indeks do RCX
+                    if (isNumber(indexStr)) result += "  mov rcx, " + indexStr + "\n";
+                    else result += "  mov rcx, " + getVarLocation(indexStr, stackMap) + "\n";
+
+                    result += "  imul rcx, 8\n"; // index * 8
+
+                    // Obliczamy adres
+                    result += "  mov rdx, rbp\n";
+                    result += "  sub rdx, " + std::to_string(baseOffset) + "\n";
+                    result += "  sub rdx, rcx\n";
+
+                    // Odczytujemy wartoϾ z tablicy do RAX
+                    result += "  mov rax, [rdx]\n";
+
+                    // Zapisujemy do zmiennej docelowej
+                    result += "  mov " + dst + ", rax\n"; // Lub eax, zale¿y jak masz
+                }
+                else if (instr.arg3 == "STRING") {
+                    // Przypisanie stringa: ³adujemy ADRES (LEA)
+                    result += "  lea rax, [rel " + src + "]\n";
+                    std::string dst = getVarLocation(instr.arg1, stackMap);
+                    // Zapisujemy adres w zmiennej lokalnej (wskaŸnik 64-bit qword)
+                    result += "  mov qword " + dst + ", rax\n";
+                }
+                else {
+                    // Zwyk³e przypisanie liczby
+                    std::string srcLoc = getVarLocation(instr.arg2, stackMap);
+                    std::string dst = getVarLocation(instr.arg1, stackMap);
+
+                    if (isNumber(src)) {
+                        result += "  mov eax, " + src + "\n";
+                    }
+                    else {
+                        result += "  mov eax, " + srcLoc + "\n";
+                    }
+                    result += "  mov " + dst + ", eax\n";
+                }
+                break;
+            }
+            case OpType::ADD: {
+                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 += "  add eax, " + op2 + "\n";
+                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"; // Reszta
+                break;
+            }
+            case OpType::EQ: {
+                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, " + op2 + "\n";
+                result += "  sete al\n";
+                result += "  movzx eax, al\n";
+                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: {
+                std::string condRaw = instr.arg2;
+                size_t eqPos = condRaw.find("==");
+                if (eqPos != std::string::npos) {
+                    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 + "\n";
+                }
+                else {
+                    std::string cond = getVarLocation(condRaw, stackMap);
+                    result += "  mov eax, " + cond + "\n";
+                    result += "  test eax, eax\n";
+                    result += "  jz " + instr.arg1 + "\n";
+                }
+                break;
+            }
+            case OpType::JMP: {
+                result += "  jmp " + instr.arg1 + "\n";
+                break;
+            }
+            case OpType::ARRAY_DECLARE: {
+                std::string name = instr.arg1;
+                int size = std::stoi(instr.arg2);
+
+                // Rezerwujemy miejsce dla ca³ej tablicy
+                // t[0] bêdzie pod aktualnym currentStack
+                stackMap[name] = currentStack;
+
+                // Przesuwamy wskaŸnik stosu o (rozmiar * 8 bajtów)
+                // Zak³adamy, ¿e ka¿dy element to 64-bit (dla bezpieczeñstwa i prostoty assemblera)
+                currentStack += (size * 8);
+
+                // W ASM nie musimy generowaæ ¿adnego kodu! (Miejsce ju¿ jest z sub rsp, 256)
+                // O ile tablica mieœci siê w tych 256 bajtach.
+                // Jeœli chcesz byæ PRO: dodaj na pocz¹tku funkcji "sub rsp, (currentStack + zapas)"
+                break;
+            }
+            case OpType::ARRAY_SET: {
+                std::string arrName = instr.arg1; // t
+                std::string indexStr = instr.arg2; // i
+                std::string valStr = instr.arg3;   // val
+
+                // 1. Obliczamy wartoϾ do wpisania
+                if (isNumber(valStr)) {
+                    result += "  mov rax, " + valStr + "\n";
+                }
+                else {
+                    std::string valLoc = getVarLocation(valStr, stackMap);
+                    // Jeœli to zmienna ze stosu, to movsxd (rozszerzenie znaku) lub mov
+                    result += "  mov rax, " + valLoc + "\n"; // Zak³adamy 64-bit (lub eax dla 32)
+                }
+
+                // 2. Obliczamy adres elementu tablicy
+                // Adres = [rbp - offset_bazowy - (index * 8)]
+                // U nas stackMap trzyma offset_bazowy.
+                // Poniewa¿ stos roœnie w DÓ£, a my rezerwowaliœmy w DÓ£:
+                // t[0] -> offset
+                // t[1] -> offset + 8
+                // Czekaj, rbp-8, rbp-16...
+                // Im wiêkszy offset w stackMap, tym ni¿ej w pamiêci.
+                // stackMap["t"] = 8. [rbp-8].
+                // t[1] powinno byæ [rbp-16].
+                // Czyli Wzór: [rbp - (base_offset + index*8)]
+
+                int baseOffset = stackMap[arrName];
+
+                // £adujemy indeks do RCX
+                if (isNumber(indexStr)) {
+                    result += "  mov rcx, " + indexStr + "\n";
+                }
+                else {
+                    std::string idxLoc = getVarLocation(indexStr, stackMap);
+                    result += "  mov rcx, " + idxLoc + "\n"; // Pobierz indeks ze zmiennej
+                }
+
+                // Obliczamy przesuniêcie bajtowe: index * 8
+                result += "  imul rcx, 8\n";
+
+                // Poniewa¿ adres to RBP - (base + index*8) -> RBP - base - index*8
+                // Musimy to sprytnie zmontowaæ.
+                // Obliczmy finalny adres w RDX.
+
+                result += "  mov rdx, rbp\n";
+                result += "  sub rdx, " + std::to_string(baseOffset) + "\n"; // RDX = adres t[0]
+                result += "  sub rdx, rcx\n"; // RDX = adres t[i]
+
+                // Zapisujemy wartoϾ (RAX) pod adres (RDX)
+                result += "  mov [rdx], rax\n";
+                break;
+            }
+            case OpType::LABEL: {
+                result += instr.arg1 + ":\n";
+                break;
+            }
+            case OpType::PRINT: {
+                // Instrukcja PRINT zwyk³a (liczba)
+                std::string val = getVarLocation(instr.arg1, stackMap);
+                result += "  mov edx, " + val + "\n";
+                result += "  lea rcx, [rel fmt_int]\n";
+                result += "  call printf\n";
+                break;
+            }
+            case OpType::PRINT_STRING: {
+                // Instrukcja PRINT_STRING (tekst)
+                std::string target = instr.arg1;
+                if (target.find("str_") == 0) {
+                    // Litera³: print("tekst")
+                    result += "  lea rdx, [rel " + target + "]\n";
+                }
+                else {
+                    // Zmienna: print(s) -> s trzyma adres
+                    std::string val = getVarLocation(target, stackMap);
+                    result += "  mov rdx, " + val + "\n";
+                }
+                result += "  lea rcx, [rel fmt_str]\n";
+                result += "  call printf\n";
+                break;
+            }
+            case OpType::CALL: {
+                if (instr.arg1 == "input") {
+                    result += "  call getchar\n";
+                    break;
+                }
+                if (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;
+                }
+
+                // Standardowe wywo³anie funkcji
+                std::string argsRaw = instr.arg2;
+                std::vector<std::string> callArgs;
+                if (!argsRaw.empty()) {
+                    size_t comma = argsRaw.find(',');
+                    if (comma != std::string::npos) {
+                        callArgs.push_back(argsRaw.substr(0, comma));
+                        callArgs.push_back(argsRaw.substr(comma + 1));
+                    }
+                    else {
+                        callArgs.push_back(argsRaw);
+                    }
+                }
+                if (callArgs.size() > 1) {
+                    std::string val = getVarLocation(callArgs[1], stackMap);
+                    if (isNumber(val)) result += "  mov rdx, " + val + "\n";
+                    else result += "  movsxd rdx, dword " + val + "\n";
+                }
+                if (callArgs.size() > 0) {
+                    std::string val = getVarLocation(callArgs[0], stackMap);
+                    if (isNumber(val)) result += "  mov rcx, " + val + "\n";
+                    else result += "  movsxd rcx, dword " + val + "\n";
+                }
+                result += "  call " + instr.arg1 + "\n";
+                break;
+            }
+            case OpType::RETURN: {
+                std::string val = getVarLocation(instr.arg1, stackMap);
+                if (!val.empty() && val != ";") {
+                    result += "  mov eax, " + val + "\n";
+                }
+                result += "  leave\n";
+                result += "  ret\n";
+                break;
+            }
+            case OpType::MSGBOX: {
+                // Konwencja Windows x64:
+                // RCX = HWND (0 = brak okna nadrzêdnego)
+                // RDX = TreϾ (Text)
+                // R8  = Tytu³ (Caption)
+                // R9  = Typ (0 = przycisk OK)
+
+                std::string title = instr.arg1;
+                std::string text = instr.arg2;
+
+                // --- 1. Ustawiamy RDX (TreϾ) ---
+                if (text.find("str_") == 0) {
+                    // Jeœli to litera³ (np. str_5), ³adujemy jego adres (LEA)
+                    result += "  lea rdx, [rel " + text + "]\n";
+                }
+                else {
+                    // Jeœli to zmienna, pobieramy jej wartoœæ ze stosu (która jest adresem)
+                    std::string loc = getVarLocation(text, stackMap);
+                    result += "  mov rdx, " + loc + "\n";
+                }
+
+                // --- 2. Ustawiamy R8 (Tytu³) ---
+                if (title.find("str_") == 0) {
+                    result += "  lea r8, [rel " + title + "]\n";
+                }
+                else {
+                    std::string loc = getVarLocation(title, stackMap);
+                    result += "  mov r8, " + loc + "\n";
+                }
+
+                // --- 3. Pozosta³e argumenty (Sta³e) ---
+                result += "  mov rcx, 0\n"; // HWND = NULL
+                result += "  mov r9, 0\n";  // MB_OK
+
+                // --- 4. Wywo³anie ---
+                // Stos (shadow space) jest ju¿ przygotowany na pocz¹tku funkcji (sub rsp, 256)
+                result += "  call MessageBoxA\n";
+                break;
+            }
+            }
+        }
+
+        if (func.returnType == "void") {
+            result += "  leave\n  ret\n";
+        }
+        result += "\n";
+    }
+
+    return result;
+}

PCCcompiler/codegen.h

@@ -0,0 +1,11 @@
+#ifndef CODEGEN_H
+#define CODEGEN_H
+
+#include <string>
+#include "compiler_types.h"
+
+// G³ówna funkcja generuj¹ca kod ASM na podstawie stanu kompilatora
+std::string generateAssembly(const CompilerState& state);
+
+#endif // CODEGEN_H
+

PCCcompiler/compiler_types.h

@@ -0,0 +1,77 @@
+#ifndef COMPILER_TYPES_H
+#define COMPILER_TYPES_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <stack>
+
+// 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(int)
+    PRINT_STRING, // print(string) - NOWE
+    JMP_FALSE,  // if (false) skocz...
+    ARRAY_DECLARE, // int t[10];
+    ARRAY_SET,     // t[0] = 5;
+    ARRAY_GET,     // x = t[0]; - to obs³u¿ymy w ASSIGN, ale warto mieæ typ
+    JMP,        // else / pêtla
+    LOGIC_AND,  // &&
+    LOGIC_OR,   // ||
+    LABEL,      // miejsce skoku
+    CALL,       // wywo³anie funkcji
+    RETURN,     // return x
+    MSGBOX,     // msg box
+    NOP         // pusta instrukcja
+};
+
+// Pojedynczy rozkaz
+struct Instruction {
+    OpType type;
+    std::string arg1;
+    std::string arg2;
+    std::string arg3;
+};
+
+// Definicja funkcji
+struct Function {
+    std::string name;
+    std::string returnType;
+    std::vector<std::string> args;
+    std::vector<Instruction> instructions;
+};
+
+// G£ÓWNY STAN KOMPILATORA
+struct CompilerState {
+    // Mapa funkcji
+    std::map<std::string, Function> functions;
+
+    // Zmienne globalne
+    std::map<std::string, int> globals;
+
+    // Zarz¹dzanie stosem
+    std::map<std::string, int> stackMap;
+    int stackOffset = 0;
+
+    // Stan parsera
+    Function* currentFunction = nullptr;
+    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

@@ -0,0 +1,163 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#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 = "v0.0.7-beta";
+    bool showHelp = false, showVersion = false, showCredits = false;
+
+    // --- PARSOWANIE ARGUMENTÓW ---
+    for (int i = 1; i < argc; i++) {
+        std::string arg = argv[i];
+
+        if (arg == "--help" || arg == "-h") {
+            showHelp = true;
+        }
+        else if (arg == "--version" || arg == "-v") {
+            showVersion = true;
+        }
+        else if (arg == "--credits" || arg == "-c") {
+            showCredits = true;
+        }
+        else if (arg.substr(0, 2) == "-o") {
+            if (arg.size() > 2) {
+                outputName = arg.substr(2);
+            }
+            else if (i + 1 < argc) {
+                outputName = argv[++i];
+            }
+        }
+        else {
+            inputFile = arg;
+        }
+    }
+
+    // --- OBSŁUGA INFORMACYJNA ---
+    if (showVersion) {
+        std::cout << "PCC Compiler " << Version << " (x64, Modular structure)\n";
+        return 0;
+    }
+
+    if (showCredits) {
+        std::cout << "Created by: Michal Lewandowski\n";
+        std::cout << "Contact   : slawek.1q2w3e4r@gmail.com\n"; // Twój email z oryginału
+        std::cout << "Docs: https://nodrop.xyz/PCC_docs.html\n";
+        return 0;
+    }
+
+    if (showHelp || inputFile.empty()) {
+        std::cout << "PCC Compiler " << Version << "\n";
+        std::cout << "Usage: PCC [Options] File.pcc\n\n";
+        std::cout << "Options:\n";
+        std::cout << " -h, --help      Show Help\n";
+        std::cout << " -v, --version   Show Version\n";
+        std::cout << " -o Name         Exe Name (output\\Name.exe)\n";
+        return 0;
+    }
+
+    // --- WCZYTYWANIE PLIKU ---
+    std::ifstream in(inputFile);
+    if (!in) {
+        std::cerr << "Error: Cannot open file " << inputFile << "\n";
+        return 1;
+    }
+
+    // ... wczytywanie pliku (to co miałeś) ...
+    std::string src((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+    in.close();
+
+    // --- 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";
+    // 1. Parsowanie tekstu do struktur
+    processSource(src, state);
+
+    std::cout << "[INFO] Calculating expressions...\n";
+    // 2. Obliczanie matematyki
+    calculateExpressions(state);
+
+    std::cout << "[INFO] Generating Assembly...\n";
+    // 3. Generowanie kodu ASM
+    std::string asmCode = generateAssembly(state);
+
+
+    // --- ZAPIS I KOMPILACJA ZEWNĘTRZNA ---
+    std::system("if not exist output mkdir output");
+
+    // 1. Ustal bazową nazwę (bez rozszerzenia)
+    std::string baseName;
+    if (outputName.empty()) {
+        // Jeśli nie podano -o, weź nazwę pliku wejściowego i utnij .pcc
+        size_t lastDot = inputFile.find_last_of(".");
+        if (lastDot != std::string::npos)
+            baseName = inputFile.substr(0, lastDot);
+        else
+            baseName = inputFile;
+    }
+    else {
+        // Jeśli podano -o, sprawdź czy ma .exe i ewentualnie utnij
+        // (żebyśmy mogli dodać .asm i .obj bez bałaganu)
+        size_t exePos = outputName.find(".exe");
+        if (exePos != std::string::npos)
+            baseName = outputName.substr(0, exePos);
+        else
+            baseName = outputName;
+    }
+
+    // Teraz budujemy ścieżki - czysto i ładnie
+    std::string asmPath = "output\\" + baseName + ".asm";
+    std::string objPath = "output\\" + baseName + ".obj";
+    std::string exePath = "output\\" + baseName + ".exe";
+
+
+    // Zapisz ASM
+    std::ofstream asmOut(asmPath);
+    asmOut << asmCode;
+    asmOut.close();
+    std::cout << "ASM saved to: " << asmPath << "\n";
+
+    // Uruchom NASM
+    std::string nasmCmd = "nasm -f win64 \"" + asmPath + "\" -o \"" + objPath + "\"";
+    if (std::system(nasmCmd.c_str()) != 0) {
+        std::cerr << "NASM Error! Check if NASM is in PATH.\n";
+        return 1;
+    }
+
+    // Uruchom GoLink
+    std::string linkCmd = "go-link.exe /console /entry:main \"" + objPath + "\" msvcrt.dll kernel32.dll user32.dll \"" + exePath + "\"";
+    if (std::system(linkCmd.c_str()) != 0) {
+        std::cerr << "GoLink Error! Check if go-link.exe is in PATH.\n";
+        return 1;
+    }
+
+    std::cout << "SUCCESS! Executable created: " << exePath << "\n";
+    return 0;
+}

PCCcompiler/parser.cpp

@@ -0,0 +1,424 @@
+#include "parser.h"
+#include "utils.h"
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+std::vector<std::string> parseArgs(const std::string& line) {
+    std::vector<std::string> args;
+    size_t open = line.find('(');
+    size_t close = line.find(')');
+    if (open == std::string::npos || close == std::string::npos) return args;
+
+    std::string inside = line.substr(open + 1, close - open - 1);
+    if (inside.empty()) return args;
+
+    std::stringstream ss(inside);
+    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");
+        if (space != std::string::npos) {
+            args.push_back(trim(segment.substr(space + 1)));
+        }
+    }
+    return args;
+}
+
+// Funkcja wyciągająca "tekst" i rejestrująca go w state
+// Rejestruje tekst i zwraca jego etykietę (np. str_5)
+std::string registerStringLiteral(CompilerState& state, std::string content) {
+    // Używamy stringCounter z CompilerState
+    std::string label = "str_" + std::to_string(state.stringCounter++);
+
+    // Dodajemy do WEKTORA (push_back działa tylko na wektorze/liście)
+    state.stringLiterals.push_back({ label, content });
+
+    return label;
+}
+
+void processSource(const std::string& src, CompilerState& state) {
+    std::istringstream iss(src);
+    std::string line;
+
+    while (std::getline(iss, line)) {
+        line = trim(line);
+        if (line.empty() || line.substr(0, 2) == "//" || line[0] == '#') continue;
+
+        // =========================================================
+        // 1. DEFINICJA FUNKCJI (np. void main() { )
+        // =========================================================
+        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());
+            std::string funcName = trim(nameRaw);
+
+            Function newFunc;
+            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 '}' (Koniec funkcji, IF-a lub WHILE)
+        // =========================================================
+        if (line == "}") {
+            if (!state.blockStack.empty()) {
+                std::string blockInfo = state.blockStack.top();
+                state.blockStack.pop();
+
+                // Sprawdzamy czy to pętla WHILE (znacznik "WHILE|...")
+                bool isWhile = (blockInfo.length() > 6 && blockInfo.substr(0, 6) == "WHILE|");
+
+                if (isWhile) {
+                    size_t firstPipe = blockInfo.find('|');
+                    size_t secondPipe = blockInfo.rfind('|');
+                    std::string labelStart = blockInfo.substr(firstPipe + 1, secondPipe - firstPipe - 1);
+                    std::string labelEnd = blockInfo.substr(secondPipe + 1);
+
+                    if (state.currentFunction) {
+                        state.currentFunction->instructions.push_back({ OpType::JMP, labelStart, "", "" });
+                        state.currentFunction->instructions.push_back({ OpType::LABEL, labelEnd, "", "" });
+                    }
+                    std::cout << " [PARSER] } End WHILE loop\n";
+                }
+                else {
+                    // To zwykły IF
+                    if (state.currentFunction) {
+                        state.currentFunction->instructions.push_back({ OpType::LABEL, blockInfo, "", "" });
+                    }
+                    std::cout << " [PARSER] } End IF block -> " << blockInfo << "\n";
+                }
+            }
+            else {
+                // Koniec funkcji
+                state.currentFunction = nullptr;
+                std::cout << " [PARSER] } End Function\n";
+            }
+            continue;
+        }
+
+        // =========================================================
+        // JESTEŚMY W ŚRODKU FUNKCJI
+        // =========================================================
+        if (state.currentFunction) {
+            Function& f = *state.currentFunction;
+
+            // 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, "", "" });
+                continue;
+            }
+
+            // B. DEKLARACJA STRINGA: string s = "hello";
+            else if (line.substr(0, 6) == "string") {
+                size_t eqPos = line.find("=");
+                if (eqPos != std::string::npos) {
+                    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, "" });
+                    }
+                }
+                continue;
+            }
+
+            // C. DEKLARACJA TABLICY: int t[10];
+            else if (line.substr(0, 3) == "int" && line.find("[") != std::string::npos && line.find("=") == std::string::npos) {
+                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";
+                }
+                continue;
+            }
+
+            // D. DRUKOWANIE (PRINT)
+            else if (line.substr(0, 5) == "print") {
+                size_t open = line.find("(");
+                size_t close = line.rfind(")");
+                if (open != std::string::npos && close > open) {
+                    std::string content = trim(line.substr(open + 1, close - open - 1));
+
+                    // Czy to element tablicy? print(t[0])
+                    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);
+
+                        // Hack: Używamy tymczasowej zmiennej do wydruku
+                        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, "", "" });
+                    }
+                    // Literał tekstowy
+                    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, "", "" });
+                    }
+                    // Zmienna string
+                    else if (state.varTypes.count(content) && state.varTypes[content] == "string") {
+                        f.instructions.push_back({ OpType::PRINT_STRING, content, "", "" });
+                    }
+                    // Liczba
+                    else {
+                        f.instructions.push_back({ OpType::PRINT, content, "", "" });
+                    }
+                }
+                continue;
+            }
+
+            // E. IF STATEMENT
+            else if (line.substr(0, 2) == "if") {
+                size_t openParen = line.find("(");
+                size_t closeParen = line.rfind(")");
+
+                if (openParen != std::string::npos && closeParen > openParen) {
+                    std::string conditionRaw = trim(line.substr(openParen + 1, closeParen - openParen - 1));
+                    std::string finalConditionVar = conditionRaw;
+
+                    // Logika && i || (uproszczona)
+                    size_t andPos = conditionRaw.find("&&");
+                    size_t orPos = conditionRaw.find("||");
+
+                    if (andPos != std::string::npos) {
+                        std::string partA = trim(conditionRaw.substr(0, andPos));
+                        std::string partB = trim(conditionRaw.substr(andPos + 2));
+                        std::string tempA = "_tmp_and_a_" + std::to_string(state.labelCounter);
+                        std::string tempB = "_tmp_and_b_" + std::to_string(state.labelCounter);
+                        std::string tempRes = "_tmp_and_res_" + std::to_string(state.labelCounter);
+
+                        // A
+                        if (partA.find("==") != std::string::npos) {
+                            size_t eq = partA.find("==");
+                            f.instructions.push_back({ OpType::EQ, tempA, trim(partA.substr(0, eq)), trim(partA.substr(eq + 2)) });
+                        }
+                        else f.instructions.push_back({ OpType::ASSIGN, tempA, partA, "" });
+
+                        // B
+                        if (partB.find("==") != std::string::npos) {
+                            size_t eq = partB.find("==");
+                            f.instructions.push_back({ OpType::EQ, tempB, trim(partB.substr(0, eq)), trim(partB.substr(eq + 2)) });
+                        }
+                        else f.instructions.push_back({ OpType::ASSIGN, tempB, partB, "" });
+
+                        f.instructions.push_back({ OpType::LOGIC_AND, tempRes, tempA, tempB });
+                        finalConditionVar = tempRes;
+                    }
+                    else if (orPos != std::string::npos) {
+                        // ... (Tutaj można dodać logikę OR analogicznie jak wyżej, skracam dla czytelności)
+                    }
+                    else if (conditionRaw.find("==") != std::string::npos) {
+                        size_t eq = conditionRaw.find("==");
+                        std::string tempRes = "_tmp_eq_" + std::to_string(state.labelCounter);
+                        f.instructions.push_back({ OpType::EQ, tempRes, trim(conditionRaw.substr(0, eq)), trim(conditionRaw.substr(eq + 2)) });
+                        finalConditionVar = tempRes;
+                    }
+
+                    std::string labelName = "L_" + std::to_string(state.labelCounter++);
+                    f.instructions.push_back({ OpType::JMP_FALSE, labelName, finalConditionVar, "" });
+                    state.blockStack.push(labelName);
+                }
+                continue;
+            }
+
+            // F. WHILE LOOP
+            else if (line.substr(0, 5) == "while") {
+                size_t openParen = line.find("(");
+                size_t closeParen = line.rfind(")");
+                if (openParen != std::string::npos && closeParen > openParen) {
+                    std::string conditionRaw = trim(line.substr(openParen + 1, closeParen - openParen - 1));
+
+                    // 1. Generujemy etykiety
+                    std::string labelStart = "L_" + std::to_string(state.labelCounter++);
+                    std::string labelEnd = "L_" + std::to_string(state.labelCounter++);
+
+                    // 2. Wstawiamy etykietę START (tu będziemy wracać)
+                    f.instructions.push_back({ OpType::LABEL, labelStart, "", "" });
+
+                    // 3. OBLICZANIE WARUNKU (Tu był błąd - brakowało tego!)
+                    // Jeśli warunek to np. "j - 3", musimy to policzyć do zmiennej tymczasowej
+                    std::string finalCondVar = conditionRaw;
+
+                    // Prosta obsługa odejmowania w warunku (np. while (i - 10))
+                    if (conditionRaw.find("-") != std::string::npos) {
+                        size_t opPos = conditionRaw.find("-");
+                        std::string a = trim(conditionRaw.substr(0, opPos));
+                        std::string b = trim(conditionRaw.substr(opPos + 1));
+                        std::string tmp = "_while_tmp_" + std::to_string(state.labelCounter);
+
+                        f.instructions.push_back({ OpType::SUB, tmp, a, b });
+                        finalCondVar = tmp;
+                    }
+                    // Prosta obsługa "==" (np. while (i == 10))
+                    else if (conditionRaw.find("==") != std::string::npos) {
+                        size_t opPos = conditionRaw.find("==");
+                        std::string a = trim(conditionRaw.substr(0, opPos));
+                        std::string b = trim(conditionRaw.substr(opPos + 2));
+                        std::string tmp = "_while_tmp_" + std::to_string(state.labelCounter);
+
+                        f.instructions.push_back({ OpType::EQ, tmp, a, b });
+                        finalCondVar = tmp;
+                    }
+
+                    // 4. Skaczemy do END jeśli warunek (obliczona zmienna) jest fałszywy
+                    f.instructions.push_back({ OpType::JMP_FALSE, labelEnd, finalCondVar, "" });
+
+                    // 5. Wrzucamy info na stos
+                    state.blockStack.push("WHILE|" + labelStart + "|" + labelEnd);
+                }
+                continue;
+                }
+
+            // G. MSGBOX
+            else if (line.substr(0, 6) == "msgbox") {
+                // ... (Twoja logika msgbox, jest OK) ...
+                size_t open = line.find("(");
+                size_t close = line.rfind(")");
+                if (open != std::string::npos && close > open) {
+                    std::string args = line.substr(open + 1, close - open - 1);
+                    size_t comma = args.find(",");
+                    if (comma != std::string::npos) {
+                        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, "" });
+                    }
+                }
+                continue;
+            }
+
+            // =========================================================
+            // H. PRZYPISANIE / OPERACJE (Linie z "=")
+            // =========================================================
+            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();
+
+                // 1. CZY TO ZAPIS DO TABLICY? t[0] = 5
+                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 });
+                    continue;
+                }
+
+                // Pobieramy nazwę zmiennej (usuwamy "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));
+                else if (leftSide.rfind("string ", 0) == 0) varName = trim(leftSide.substr(7));
+
+                // 2. CZY TO ODCZYT Z TABLICY? x = t[0]
+                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));
+
+                    // Specjalna flaga w arg3: ARRAY_IDX:indeks
+                    f.instructions.push_back({ OpType::ASSIGN, varName, arrName, "ARRAY_IDX:" + index });
+                }
+                // 3. Wywołanie funkcji: x = func()
+                else 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);
+
+                    f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
+                    f.instructions.push_back({ OpType::ASSIGN, varName, "RAX", "" });
+                }
+                // 4. Operacje arytmetyczne
+                else if (rightSide.find("+") != std::string::npos) {
+                    size_t opPos = rightSide.find("+");
+                    f.instructions.push_back({ OpType::ADD, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 1)) });
+                }
+                else if (rightSide.find("-") != std::string::npos) {
+                    size_t opPos = rightSide.find("-");
+                    f.instructions.push_back({ OpType::SUB, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 1)) });
+                }
+                else if (rightSide.find("*") != std::string::npos) {
+                    size_t opPos = rightSide.find("*");
+                    f.instructions.push_back({ OpType::MUL, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 1)) });
+                }
+                else if (rightSide.find("/") != std::string::npos) {
+                    size_t opPos = rightSide.find("/");
+                    f.instructions.push_back({ OpType::DIV, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 1)) });
+                }
+                else if (rightSide.find("%") != std::string::npos) {
+                    size_t opPos = rightSide.find("%");
+                    f.instructions.push_back({ OpType::MOD, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 1)) });
+                }
+                // 5. Logika
+                else if (rightSide.find("&&") != std::string::npos) {
+                    size_t opPos = rightSide.find("&&");
+                    f.instructions.push_back({ OpType::LOGIC_AND, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 2)) });
+                }
+                else if (rightSide.find("||") != std::string::npos) {
+                    size_t opPos = rightSide.find("||");
+                    f.instructions.push_back({ OpType::LOGIC_OR, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 2)) });
+                }
+                else if (rightSide.find("==") != std::string::npos) {
+                    size_t opPos = rightSide.find("==");
+                    f.instructions.push_back({ OpType::EQ, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 2)) });
+                }
+                // 6. Zwykłe przypisanie stringa
+                else 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, "" });
+                }
+                // 7. Zwykłe przypisanie wartości
+                else {
+                    f.instructions.push_back({ OpType::ASSIGN, varName, rightSide, "" });
+                }
+                continue;
+            }
+
+            // I. SAMODZIELNE WYWOŁANIE FUNKCJI (np. input(); )
+            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/parser.h

@@ -0,0 +1,7 @@
+#ifndef PARSER_H
+#define PARSER_H
+#include "compiler_types.h"
+
+void processSource(const std::string& src, CompilerState& state);
+void calculateExpressions(CompilerState& state);
+#endif

PCCcompiler/preprocessor.cpp

@@ -0,0 +1,79 @@
+#include "preprocessor.h"
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <filesystem>
+#include <regex>
+
+namespace fs = std::filesystem;
+
+// Funkcja pomocnicza do wczytania pliku
+std::string loadFileContent(const std::string& path) {
+    std::ifstream in(path);
+    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>());
+}
+
+std::string preprocessSource(const std::string& src, const std::string& projectDir, const std::string& compilerDir) {
+    std::istringstream iss(src);
+    std::string line;
+    std::stringstream output;
+
+    while (std::getline(iss, line)) {
+        // Szukamy: #include "..." lub #include <...>
+        // U¿ywamy prostego find, ¿eby by³o szybko
+        std::string trimLine = line;
+        // Usuwamy bia³e znaki z pocz¹tku
+        size_t first = trimLine.find_first_not_of(" \t");
+        if (first != std::string::npos) trimLine = trimLine.substr(first);
+
+        if (trimLine.rfind("#include", 0) == 0) {
+            // Mamy include!
+            size_t openQuote = trimLine.find('"');
+            size_t closeQuote = trimLine.rfind('"');
+            size_t openAngle = trimLine.find('<');
+            size_t closeAngle = trimLine.rfind('>');
+
+            std::string includePath;
+            bool isStdLib = false;
+
+            // Wersja: #include "plik.pcc"
+            if (openQuote != std::string::npos && closeQuote > openQuote) {
+                includePath = trimLine.substr(openQuote + 1, closeQuote - openQuote - 1);
+            }
+            // Wersja: #include <plik.pcc>
+            else if (openAngle != std::string::npos && closeAngle > openAngle) {
+                includePath = trimLine.substr(openAngle + 1, closeAngle - openAngle - 1);
+                isStdLib = true;
+            }
+
+            if (!includePath.empty()) {
+                std::string fullPath;
+                if (isStdLib) {
+                    fullPath = compilerDir + "/std/" + includePath;
+                    std::cout << "[PREPROCESSOR] Including STD lib: " << fullPath << "\n";
+                }
+                else {
+                    // Plik lokalny: Szukamy w folderze projektu
+                    if (projectDir.empty()) fullPath = includePath;
+                    else fullPath = projectDir + "/" + includePath;
+                    std::cout << "[PREPROCESSOR] Including local file: " << fullPath << "\n";
+                }
+                std::string content = loadFileContent(fullPath);
+                std::string processedContent = preprocessSource(content, projectDir, compilerDir);
+
+                output << "\n// --- BEGIN INCLUDE: " << includePath << " ---\n";
+                output << processedContent;
+                output << "\n// --- END INCLUDE ---\n";
+            }
+        }
+        else {
+            output << line << "\n";
+        }
+    }
+
+    return output.str();
+}

PCCcompiler/preprocessor.h

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

PCCcompiler/utils.cpp

@@ -0,0 +1,8 @@
+#include "utils.h"
+
+std::string trim(const std::string& str) {
+    size_t first = str.find_first_not_of(" \t");
+    if (first == std::string::npos) return "";
+    size_t last = str.find_last_not_of(" \t");
+    return str.substr(first, last - first + 1);
+}

PCCcompiler/utils.h

@@ -0,0 +1,6 @@
+#ifndef UTILS_H
+#define UTILS_H
+#include <string>
+
+std::string trim(const std::string& str);
+#endif

README.md

@@ -1,2 +1,29 @@
-# PCCCompiler
+# PCC Compiler (My C++ Compiler)
 
+![Version](https://img.shields.io/badge/version-0.0.6-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`, `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.
+2. Unzip the archive to C:/PCC/
+3. Run `start.bat` as Administrator.
+4. Compile your code: `PCC.exe code.pcc`.
+
+---
+*Created by Michał Lewandowski*

push.bat

@@ -0,0 +1,35 @@
+@echo off
+echo --- AUTO GIT PUSHER ---
+echo.
+
+:: 1. Dodajemy wszystkie pliki
+echo [1/3] Adding files...
+git add .
+
+:: 2. Pytamy o nazwę commita
+echo.
+set /p commit_msg="Enter commit message: "
+
+:: Jeśli użytkownik nic nie wpisze, ustaw domyślną
+if "%commit_msg%"=="" set commit_msg="Auto update"
+
+:: 3. Robimy commit
+echo.
+echo [2/3] Committing...
+git commit -m "%commit_msg%"
+
+:: 4. Wysyłamy (używamy origin, który już skonfigurowałeś)
+echo.
+echo [3/3] Pushing to Gitea...
+git push origin main
+
+:: Jeśli push się nie uda (np. konflikt), spróbuj wymusić
+if %errorlevel% neq 0 (
+    echo.
+    echo [WARNING] Standard push failed. Trying force push...
+    git push origin main --force
+)
+
+echo.
+echo DONE!
+pause