mmichlol/PCCCompiler
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 6 Wiki Activity

Compare commits

base: mmichlol:V0.0.9-beta
Branches Tags
mmichlol:main
mmichlol:V0.0.9-beta mmichlol:V0.0.7-beta mmichlol:V0.0.6-beta mmichlol:V0.0.5 mmichlol:V0.0.3-beta mmichlol:V0.0.2-beta
..
compare: mmichlol:0d016f8ae9d798ad78df6164befb88370483642e
Branches Tags
mmichlol:main
mmichlol:V0.0.9-beta mmichlol:V0.0.7-beta mmichlol:V0.0.6-beta mmichlol:V0.0.5 mmichlol:V0.0.3-beta mmichlol:V0.0.2-beta

1 Commits
V0.0.9-bet ... 0d016f8ae9

Author SHA1 Message Date
mmichlol
0d016f8ae9 Add README.md 2026-02-07 13:08:24 +00:00
5 changed files with 195 additions and 645 deletions
Expand all files Collapse all files

374
PCCcompiler/codegen.cpp
View File

@@ -37,31 +37,24 @@ std::string getVarLocation(const std::string& name, const std::map<std::string,
}
std::string generateAssembly(const CompilerState& state) {
// 1. NAG£ÓWEK I DEKLARACJE EXTERN
std::string result = "default rel\n";
std::string result;
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 += "extern _getch\n"; // ZMIANA: Dodajemy _getch (zamiast lub obok getchar)
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
result += " fmt db '%d', 10, 0\n";
result += "section .data\n";
result += " fmt_int db '%d', 10, 0\n"; // Format dla liczb
result += " fmt_str db '%s', 10, 0\n"; // NOWOŒÆ: 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";
// --- WYPISYWANIE STRINGÓW ---
for (const auto& pair : state.stringLiterals) {
// Nazwa etykiety: db 'Tresc', 0
// Uwaga: ASM nie lubi pewnych znaków, ale zak³adamy proste litery
result += " " + pair.second + " db '" + pair.first + "', 0\n";
}
// 3. SEKCJA TEXT (Kod programu)
result += "section .text\n";
result += "section .text\n\n";
for (const auto& pair : state.functions) {
const Function& func = pair.second;
@@ -74,7 +67,7 @@ std::string generateAssembly(const CompilerState& state) {
std::map<std::string, int> stackMap;
int currentStack = 8;
// ARGUMENTY FUNKCJI
// 1. ARGUMENTY
if (func.args.size() > 0) {
stackMap[func.args[0]] = currentStack;
result += " mov [rbp-" + std::to_string(currentStack) + "], rcx ; arg " + func.args[0] + "\n";
@@ -86,22 +79,16 @@ std::string generateAssembly(const CompilerState& state) {
currentStack += 8;
}
// GENEROWANIE INSTRUKCJI
// 2. INSTRUKCJE
for (const auto& instr : func.instructions) {
// Rezerwacja miejsca na stosie
// Rezerwacja miejsca dla nowych zmiennych (wynikowych)
// Dodajemy tu OpType::SUB i OpType::MUL
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);
instr.type == OpType::MUL);
if (isWriteOp && stackMap.find(instr.arg1) == stackMap.end() && instr.arg1 != "RAX") {
stackMap[instr.arg1] = currentStack;
@@ -111,49 +98,15 @@ std::string generateAssembly(const CompilerState& state) {
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)
if (instr.arg3 == "STRING") {
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;
@@ -168,55 +121,29 @@ std::string generateAssembly(const CompilerState& state) {
break;
}
case OpType::SUB: {
// a = b - c
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 += " sub eax, " + op2 + "\n"; // sub = odejmowanie
result += " mov " + dst + ", eax\n";
break;
}
case OpType::MUL: {
// a = b * c
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";
// Mno¿enie w x86 jest specyficzne: imul eax, operand
// Wynik l¹duje w eax (i edx jeœli du¿y, ale ignorujemy nadmiar dla prostoty)
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);
@@ -228,184 +155,80 @@ 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("==");
if (eqPos != std::string::npos) {
// 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 + "\n";
result += " jne " + instr.arg1 + " ; jump if NOT equal\n";
}
else {
// Zwyk³a zmienna boolowska (if test)
std::string cond = getVarLocation(condRaw, stackMap);
result += " mov eax, " + cond + "\n";
result += " test eax, eax\n";
result += " jz " + instr.arg1 + "\n";
result += " jz " + instr.arg1 + " ; jump if zero\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::RETURN: {
std::string val = getVarLocation(instr.arg1, stackMap);
if (val.empty() || val == ";");
else {
result += " mov eax, " + val + " ; return value\n";
}
result += " leave\n";
result += " ret\n";
break;
}
case OpType::PRINT: {
// Instrukcja PRINT zwyk³a (liczba)
if (instr.arg2 == "STRING") {
result += " lea rdx, [rel " + instr.arg1 + "]\n";
result += " lea rcx, [rel fmt_str]\n";
result += " call printf\n";
}
else {
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: {
// Parsowanie argumentów
std::string argsRaw = instr.arg2;
std::vector<std::string> callArgs;
// --- SPECJALNE FUNKCJE SYSTEMOWE ---
// 1. input() - czeka na ENTER (stare)
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;
// 2. read_key() - zwraca kod wciœniêtego klawisza (NOWOŒÆ)
if (instr.arg1 == "read_key") {
result += " call _getch\n"; // Zwraca kod znaku w EAX
// Jeœli to klawisz specjalny (strza³ki), _getch zwraca 0 lub 224,
// a potem trzeba wywo³aæ go drugi raz.
// Na razie zróbmy prosto: zwracamy to co zwróci³ pierwszy _getch.
break;
}
if (!argsRaw.empty()) {
size_t comma = argsRaw.find(',');
if (comma != std::string::npos) {
@@ -416,67 +239,34 @@ std::string generateAssembly(const CompilerState& state) {
callArgs.push_back(argsRaw);
}
}
// Obs³uga RDX (arg 2)
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 (isNumber(val)) {
// Jeœli liczba: mov rdx, 100
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)
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";
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;
}
}
}

44
PCCcompiler/compiler_types.h
View File

@@ -6,32 +6,23 @@
#include <map>
#include <stack>
// Typy operacji
// Typy operacji, które nasz kompilator rozumie
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
PRINT, // print(a)
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
// Pojedynczy rozkaz kompilatora (Intermediate Representation)
struct Instruction {
OpType type;
std::string arg1;
@@ -42,36 +33,27 @@ struct Instruction {
// Definicja funkcji
struct Function {
std::string name;
std::string returnType;
std::vector<std::string> args;
std::vector<Instruction> instructions;
std::string returnType; // "int", "void", "bool"
std::vector<std::string> args; // Nazwy argumentów (np. "a", "b")
std::vector<Instruction> instructions; // Lista rozkazów w funkcji
};
// G£ÓWNY STAN KOMPILATORA
struct CompilerState {
// Mapa funkcji
// Mapa wszystkich funkcji (klucz to nazwa)
std::map<std::string, Function> functions;
// Zmienne globalne
// Zmienne globalne (tylko nazwa -> wartoœæ pocz¹tkowa)
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;
Function* currentFunction = nullptr; // WskaŸnik na aktualnie parsuj¹c¹ siê funkcjê
int labelCounter = 0; // Do generowania unikalnych nazw etykiet (L1, L2...)
std::stack<std::string> loopStack; // Do break/continue (przysz³oœciowo)
// 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;
std::map<std::string, std::string> stringLiterals;
int stringCounter = 0; // Licznik do generowania nazw str_1, str_2...
};
#endif

2
PCCcompiler/main.cpp
View File

@@ -19,7 +19,7 @@ std::string getExecutablePath() {
int main(int argc, char* argv[]) {
std::string inputFile, outputName;
std::string Version = "v0.0.7-beta";
std::string Version = "v0.0.5-beta";
bool showHelp = false, showVersion = false, showCredits = false;
// --- PARSOWANIE ARGUMENTÓW ---

381
PCCcompiler/parser.cpp
View File

@@ -26,18 +26,6 @@ std::vector<std::string> parseArgs(const std::string& line) {
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;
@@ -46,10 +34,10 @@ void processSource(const std::string& src, CompilerState& state) {
line = trim(line);
if (line.empty() || line.substr(0, 2) == "//" || line[0] == '#') continue;
// =========================================================
// 1. DEFINICJA FUNKCJI (np. void main() { )
// =========================================================
// --- 1. DEFINICJA FUNKCJI ---
// Warunki: zaczyna się od typu, ma '(', ma '{' i NIE ma '=' (żeby nie mylić ze zmienną)
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('(');
@@ -69,48 +57,26 @@ void processSource(const std::string& src, CompilerState& state) {
continue;
}
// =========================================================
// 2. ZAMYKANIE BLOKU '}' (Koniec funkcji, IF-a lub WHILE)
// =========================================================
// --- 2. ZAMYKANIE BLOKU '}' ---
if (line == "}") {
// Najpierw sprawdzamy, czy zamykamy IF-a (czy jest coś na stosie bloków)
if (!state.blockStack.empty()) {
std::string blockInfo = state.blockStack.top();
std::string label = 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, "", "" });
state.currentFunction->instructions.push_back({ OpType::LABEL, label, "", "" });
}
std::cout << " [PARSER] } End WHILE loop\n";
std::cout << " [PARSER] } End IF block -> " << label << "\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
// Jeśli stos pusty, to koniec funkcji
state.currentFunction = nullptr;
std::cout << " [PARSER] } End Function\n";
}
continue;
}
// =========================================================
// JESTEŚMY W ŚRODKU FUNKCJI
// =========================================================
// --- JESTEŚMY W ŚRODKU FUNKCJI ---
if (state.currentFunction) {
Function& f = *state.currentFunction;
@@ -119,296 +85,144 @@ void processSource(const std::string& src, CompilerState& state) {
std::string val = trim(line.substr(6));
if (!val.empty() && val.back() == ';') val.pop_back();
f.instructions.push_back({ OpType::RETURN, val, "", "" });
continue;
std::cout << " [PARSER] Return: " << val << "\n";
}
// 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)
// B. 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));
size_t start = line.find('(') + 1;
size_t end = line.find(')');
if (start != std::string::npos && end != std::string::npos) {
std::string arg = trim(line.substr(start, end - start));
// 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);
// Czy to bezpośredni napis? np. print("Hello")
if (arg.size() >= 2 && arg.front() == '"' && arg.back() == '"') {
std::string content = arg.substr(1, arg.size() - 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, "", "" });
// Rejestrujemy
std::string label;
if (state.stringLiterals.count(content)) {
label = state.stringLiterals[content];
}
// 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;
label = "str_" + std::to_string(state.stringCounter++);
state.stringLiterals[content] = label;
}
// E. IF STATEMENT
// Dajemy znać generatorowi, że to typ STRING
f.instructions.push_back({ OpType::PRINT, label, "STRING", "" });
}
else {
// Zwykła zmienna (int lub string - generator musi zgadnąć lub my musimy wiedzieć)
// Na razie załóżmy, że jeśli zmienna ma w nazwie "msg" lub "txt", to string
// (To hack, w przyszłości dodamy tabelę typów zmiennych)
f.instructions.push_back({ OpType::PRINT, arg, "VAR", "" });
}
}
}
// C. IF STATEMENT
else if (line.substr(0, 2) == "if") {
size_t openParen = line.find("(");
size_t closeParen = line.rfind(")");
size_t closeParen = line.find(")");
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 condition = trim(line.substr(openParen + 1, closeParen - openParen - 1));
std::string labelName = "L_" + std::to_string(state.labelCounter++);
f.instructions.push_back({ OpType::JMP_FALSE, labelName, finalConditionVar, "" });
// Skok warunkowy
f.instructions.push_back({ OpType::JMP_FALSE, labelName, condition, "" });
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, "" });
std::cout << " [PARSER] IF (" << condition << ") -> Jump to " << labelName << "\n";
}
}
continue;
}
// =========================================================
// H. PRZYPISANIE / OPERACJE (Linie z "=")
// =========================================================
// 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));
bool isStringDecl = false; // Flaga, czy to string
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 ")
// 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));
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 });
else if (leftSide.rfind("string ", 0) == 0) { // NOWOŚĆ
varName = trim(leftSide.substr(7));
isStringDecl = true;
}
// 3. Wywołanie funkcji: x = func()
else if (rightSide.find("(") != std::string::npos && rightSide.find(")") != std::string::npos) {
// 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";
}
// 4. Operacje arytmetyczne
// 2. Czy to dodawanie? a + b
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)) });
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. NOWOŚĆ: Czy to odejmowanie? a - b
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)) });
std::string a = trim(rightSide.substr(0, opPos));
std::string b = trim(rightSide.substr(opPos + 1));
f.instructions.push_back({ OpType::SUB, varName, a, b }); // <--- Używamy SUB
}
// 4. NOWOŚĆ: Czy to mnożenie? a * b
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)) });
std::string a = trim(rightSide.substr(0, opPos));
std::string b = trim(rightSide.substr(opPos + 1));
f.instructions.push_back({ OpType::MUL, varName, a, b }); // <--- Używamy MUL
}
// 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("==");
f.instructions.push_back({ OpType::EQ, varName, trim(rightSide.substr(0, opPos)), trim(rightSide.substr(opPos + 2)) });
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 });
}
// 6. Zwykłe przypisanie stringa
else if (rightSide.size() >= 2 && rightSide.front() == '"') {
else if (rightSide.size() >= 2 && rightSide.front() == '"' && rightSide.back() == '"')
{
{
// Wyciągamy treść bez cudzysłowów
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, "" });
// Rejestrujemy stringa w sekcji danych, jeśli jeszcze go nie ma
std::string label;
if (state.stringLiterals.count(content)) {
label = state.stringLiterals[content];
}
// 7. Zwykłe przypisanie wartości
else {
label = "str_" + std::to_string(state.stringCounter++);
state.stringLiterals[content] = label;
}
// Generujemy instrukcję przypisania ADRESU etykiety do zmiennej
f.instructions.push_back({ OpType::ASSIGN, varName, label, "STRING" });
}
}
// 4. Zwykłe przypisanie: a = 5
else {
f.instructions.push_back({ OpType::ASSIGN, varName, rightSide, "" });
}
continue;
}
// I. SAMODZIELNE WYWOŁANIE FUNKCJI (np. input(); )
// 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));
@@ -420,5 +234,4 @@ void processSource(const std::string& src, CompilerState& state) {
}
}
}
void calculateExpressions(CompilerState& state) {}

35
push.bat
View File

@@ -1,35 +0,0 @@
@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