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

added int func(int x, int y), return int

Browse Source
This commit is contained in:
mmichlol
2026-02-06 21:01:12 +01:00
parent 196140f9b8
commit 5fbd0f98a2
3 changed files with 355 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

309
PCCcompiler/parser.cpp
View File

@@ -2,212 +2,171 @@
#include "utils.h"
#include <iostream>
#include <sstream>
#include "compiler_types.h"
#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;
}
void processSource(const std::string& src, CompilerState& state) {
std::istringstream iss(src);
std::string line;
std::cout << "Parsuje kod:\n";
while (std::getline(iss, line)) {
line = trim(line);
if (line.empty()) continue;
if (line.empty() || line.substr(0, 2) == "//" || line[0] == '#') continue;
// FUNKCJE
if (line.length() > 4 && line.substr(0, 4) == "void") {
size_t openParen = line.find("(", 4);
size_t closeParen = line.find(")", openParen);
if (openParen != std::string::npos && closeParen != std::string::npos) {
size_t nameStart = 4;
while (nameStart < openParen && (line[nameStart] == ' ' || line[nameStart] == '\t')) nameStart++;
size_t nameEnd = openParen;
while (nameEnd > nameStart && (line[nameEnd - 1] == ' ' || line[nameEnd - 1] == '\t')) nameEnd--;
// --- 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);
// ZMIANA: używamy 'state' zamiast 'compilerState'
state.currentFunction = line.substr(nameStart, nameEnd - nameStart);
state.functions[state.currentFunction] = std::vector<std::string>();
state.inFunction = true;
std::cout << " FUNC " << state.currentFunction << "\n";
state.braceStack.push(true);
continue;
}
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;
}
// } ZAMYKANIE KLAMRY
else if (line.find("}") != std::string::npos) {
if (!state.braceStack.empty()) {
// Sprawdzamy co zamykamy PRZED zdjęciem ze stosu
bool wasFunction = state.braceStack.top();
state.braceStack.pop();
// Jeśli zdjęliśmy 'true' (czyli znacznik funkcji) ORAZ stos jest pusty
// to znaczy, że zamknęliśmy funkcję główną.
if (wasFunction && state.braceStack.empty()) {
state.inFunction = false;
state.currentFunction.clear();
std::cout << " END FUNC\n";
}
else {
// Zamknęliśmy IF-a (lub inny blok wewnętrzny)
std::cout << " END BLOCK (IF)\n";
// --- 2. ZAMYKANIE BLOKU '}' ---
if (line == "}") {
// Najpierw sprawdzamy, czy zamykamy IF-a (czy jest coś na stosie bloków)
if (!state.blockStack.empty()) {
std::string label = state.blockStack.top();
state.blockStack.pop();
if (state.currentFunction) {
state.currentFunction->instructions.push_back({ OpType::LABEL, label, "", "" });
}
std::cout << " [PARSER] } End IF block -> " << label << "\n";
}
else {
// Jeśli stos pusty, to koniec funkcji
state.currentFunction = nullptr;
std::cout << " [PARSER] } End Function\n";
}
continue;
}
// INT
if (line.length() > 3 && line.substr(0, 3) == "int") {
size_t eqPos = line.find("=", 4);
if (eqPos != std::string::npos) {
size_t semiPos = line.find(";", eqPos);
if (semiPos != std::string::npos) {
std::string name = trim(line.substr(4, eqPos - 4));
std::string rightSide = trim(line.substr(eqPos + 1, semiPos - eqPos - 1));
// --- JESTEŚMY W ŚRODKU FUNKCJI ---
if (state.currentFunction) {
Function& f = *state.currentFunction;
std::string op;
size_t opPos;
size_t eqPos2 = rightSide.find("==");
if (eqPos2 != std::string::npos && (eqPos2 + 1 < rightSide.length()) && rightSide[eqPos2 + 2] != '=') {
op = "==";
opPos = eqPos2;
}
else {
opPos = rightSide.find('+');
if (opPos == std::string::npos) opPos = rightSide.find('-');
if (opPos != std::string::npos) op = rightSide.substr(opPos, 1);
}
if (opPos != std::string::npos && !op.empty()) {
std::string leftVar = trim(rightSide.substr(0, opPos));
std::string rightVar = trim(rightSide.substr(opPos + op.length()));
// ZMIANA: używamy 'state'
Expression expr{ leftVar, op, rightVar, name };
state.expressions.push_back(expr);
state.variables[name] = 0;
std::cout << " " << op << " EXPR " << name << " = " << leftVar << " " << op << " " << rightVar << "\n";
}
else {
try {
int value = std::stoi(rightSide);
state.variables[name] = value;
std::cout << " VAR " << name << " = " << value << "\n";
}
catch (...) {
// Usunięto '❌' żeby uniknąć warningów o kodowaniu (C4566)
std::cout << " [X] BLAD: '" << rightSide << "'\n";
}
}
// A. RETURN
if (line.substr(0, 6) == "return") {
std::string val = trim(line.substr(6));
if (!val.empty() && val.back() == ';') val.pop_back();
f.instructions.push_back({ OpType::RETURN, val, "", "" });
std::cout << " [PARSER] Return: " << val << "\n";
}
// B. PRINT
else if (line.substr(0, 5) == "print") {
size_t start = line.find('(') + 1;
size_t end = line.find(')');
if (start != std::string::npos && end != std::string::npos) {
std::string var = trim(line.substr(start, end - start));
f.instructions.push_back({ OpType::PRINT, var, "", "" });
}
}
}
// BOOL
else if (!state.inFunction && line.length() > 4 && line.substr(0, 4) == "bool") {
size_t eqPos = line.find("=", 5);
if (eqPos != std::string::npos) {
size_t semiPos = line.find(";", eqPos);
if (semiPos != std::string::npos) {
std::string nameRaw = line.substr(5, eqPos - 5);
size_t nameStart = nameRaw.find_first_not_of(" \t");
size_t nameEnd = nameRaw.find_last_not_of(" \t");
std::string name = nameRaw.substr(nameStart, nameEnd - nameStart + 1);
// C. IF STATEMENT
else if (line.substr(0, 2) == "if") {
size_t openParen = line.find("(");
size_t closeParen = line.find(")");
if (openParen != std::string::npos && closeParen > openParen) {
std::string condition = trim(line.substr(openParen + 1, closeParen - openParen - 1));
std::string labelName = "L_" + std::to_string(state.labelCounter++);
std::string valueRaw = line.substr(eqPos + 1, semiPos - eqPos - 1);
size_t valStart = valueRaw.find_first_not_of(" \t");
size_t valEnd = valueRaw.find_last_not_of(" \t");
std::string valueStr = valueRaw.substr(valStart, valEnd - valStart + 1);
// Skok warunkowy
f.instructions.push_back({ OpType::JMP_FALSE, labelName, condition, "" });
state.blockStack.push(labelName);
bool value = (valueStr == "true" || valueStr == "1");
state.variables[name] = value ? 1 : 0;
std::cout << " BOOL '" << name << "' = " << (value ? "true" : "false") << "\n";
std::cout << " [PARSER] IF (" << condition << ") -> Jump to " << labelName << "\n";
}
}
}
// IF
else if (line.length() > 3 && line.substr(0, 2) == "if") {
size_t openParen = line.find("(");
size_t closeParen = line.find(")");
// D. PRZYPISANIE ZMIENNEJ (LUB DEKLARACJA)
// np. "int a = 5;" LUB "a = b + c;"
else if (line.find("=") != std::string::npos) {
size_t eqPos = line.find('=');
std::string leftSide = trim(line.substr(0, eqPos));
std::string rightSide = trim(line.substr(eqPos + 1));
if (!rightSide.empty() && rightSide.back() == ';') rightSide.pop_back();
if (openParen != std::string::npos && closeParen > openParen) {
std::string condition = trim(line.substr(openParen + 1, closeParen - openParen - 1));
// 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));
IfBlock newIf;
newIf.conditionVar = condition;
state.ifBlocks.push_back(newIf);
// 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);
// WAŻNE: Dodajemy instrukcję "IF:numer" do listy rozkazów funkcji
if (state.inFunction) {
int ifIndex = state.ifBlocks.size() - 1;
state.functions[state.currentFunction].push_back("IF:" + std::to_string(ifIndex));
// 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";
}
std::cout << " IF [" << condition << "] { <- blok #" << state.ifBlocks.size() - 1 << "\n";
state.braceStack.push(false); // false oznacza, że to klamra IFa (a nie funkcji)
continue;
}
}
// PRINT
else if (line.length() > 5 && line.substr(0, 5) == "print") {
size_t openParen = line.find("(", 5);
size_t closeParen = line.rfind(")");
if (openParen != std::string::npos && closeParen > openParen) {
std::string varName = line.substr(openParen + 1, closeParen - openParen - 1);
size_t varStart = varName.find_first_not_of(" \t");
size_t varEnd = varName.find_last_not_of(" \t");
if (varStart != std::string::npos) {
varName = varName.substr(varStart, varEnd - varStart + 1);
if (state.inFunction && !state.currentFunction.empty()) {
// SPRAWDZAMY CZY JESTEŚMY W IFIE
// (sprawdzamy szczyt stosu klamerek: false = IF, true = FUNC)
if (!state.braceStack.empty() && state.braceStack.top() == false) {
// Jesteśmy w IFie -> dodaj TYLKO do ifBlocks
if (!state.ifBlocks.empty()) {
state.ifBlocks.back().prints.push_back(varName);
std::cout << " IF PRINT: " << varName << "\n";
}
}
else {
// Jesteśmy w normalnej funkcji (poza ifem) -> dodaj jako rozkaz PRINT:
state.functions[state.currentFunction].push_back("PRINT:" + varName);
std::cout << " FUNC PRINT " << state.currentFunction << ": " << varName << "\n";
}
}
else {
// Print globalny (poza funkcjami)
state.globalPrints.push_back(varName);
std::cout << " PRINT " << varName << "\n";
}
// 2. Czy to dodawanie? a + b
else if (rightSide.find("+") != std::string::npos) {
size_t opPos = rightSide.find("+");
std::string a = trim(rightSide.substr(0, opPos));
std::string b = trim(rightSide.substr(opPos + 1));
f.instructions.push_back({ OpType::ADD, varName, a, b });
}
// 3. Czy to porównanie? a == b (Ważne: == może być w IFie, ale tu jesteśmy w linii z '=')
// UWAGA: To rzadkie w C++ (bool x = a == b), ale obsłużmy proste przypisanie wartości logicznej
else if (rightSide.find("==") != std::string::npos) {
size_t opPos = rightSide.find("==");
std::string a = trim(rightSide.substr(0, opPos));
std::string b = trim(rightSide.substr(opPos + 2));
f.instructions.push_back({ OpType::EQ, varName, a, b });
}
// 4. Zwykłe przypisanie: a = 5
else {
f.instructions.push_back({ OpType::ASSIGN, varName, rightSide, "" });
}
}
}
// WYWOLYWANIE FUNKCJI;
else if (line.length() > 3 && line.find("();") != std::string::npos) {
size_t openParen = line.find("(");
if (openParen != std::string::npos) {
std::string funcName = line.substr(0, openParen);
size_t nameStart = funcName.find_first_not_of(" \t");
size_t nameEnd = funcName.find_last_not_of(" \t");
funcName = funcName.substr(nameStart, nameEnd - nameStart + 1);
// E. SAMODZIELNE WYWOŁANIE FUNKCJI (bez =)
// np. func();
else if (line.find("(") != std::string::npos && line.find(")") != std::string::npos) {
size_t open = line.find('(');
std::string funcName = trim(line.substr(0, open));
std::string argsContent = line.substr(open + 1, line.find(')') - open - 1);
state.printCalls.push_back("CALL_" + funcName); // ZMIANA: state
std::cout << " CALL FUNC " << funcName << "\n";
f.instructions.push_back({ OpType::CALL, funcName, argsContent, "" });
std::cout << " [PARSER] Call void: " << funcName << "\n";
}
}
}
}
void calculateExpressions(CompilerState& state) {
for (const auto& expr : state.expressions) {
if (state.variables.count(expr.leftVar) && state.variables.count(expr.rightVar)) {
int left = state.variables[expr.leftVar];
int right = state.variables[expr.rightVar];
int result = 0;
if (expr.op == "+") result = left + right;
else if (expr.op == "==") result = (left == right);
state.variables[expr.resultVar] = result;
}
}
}
void calculateExpressions(CompilerState& state) {}