Merge pull request #11 from BeyondMagic/feat/array

feat(semantic): organize code

Author: andrelopesdesousa

Cronograma.md

@@ -16,6 +16,13 @@ LEX_OUT = lex.yy.c
 YACC_OUT = parser.tab.c
 YACC_HEADER = parser.tab.h
 
+PASS_DIR = tests/pass
+PASS_SOURCES := $(wildcard $(PASS_DIR)/*.c)
+PASS_CASES := $(basename $(notdir $(PASS_SOURCES)))
+FAIL_DIR = tests/fail
+FAIL_SOURCES := $(wildcard $(FAIL_DIR)/*.c)
+FAIL_CASES := $(basename $(notdir $(FAIL_SOURCES)))
+
 all: $(TARGET)
 
 $(TARGET): $(LEX_OUT) $(YACC_OUT) $(SRC)
@@ -30,22 +37,66 @@ $(YACC_OUT) $(YACC_HEADER): $(YACC_SRC) src/ast.h src/ast.c
 clean:
 	rm -f $(TARGET) $(LEX_OUT) $(YACC_OUT) $(YACC_HEADER)
 
-TEST_CASES = \
-	expressions \
-	variable
-
-test: all
-	@echo "== Running sample tests =="
-	@for case in $(TEST_CASES); do \
-		output=$$(./c2lua tests/$$case.c); \
-		expected=$$(cat tests/$$case.lua); \
-		printf '%s' "-- $$case... "; \
-		if [ "$$output" = "$$expected" ]; then \
-			echo "ok"; \
-		else \
-			echo "fail"; \
-			printf 'Expected:\n%s\n\nGot:\n%s\n' "$$expected" "$$output"; \
-			exit 1; \
-		fi; \
-	done
-	@echo "All tests passed."
+test: test-pass test-fail
+
+test-pass: all
+	@echo "== Running pass tests =="
+	@if [ -z "$(PASS_CASES)" ]; then \
+		echo "No pass tests found under $(PASS_DIR)"; \
+	else \
+		for case in $(PASS_CASES); do \
+			input="$(PASS_DIR)/$$case.c"; \
+			expected_file="$(PASS_DIR)/$$case.lua"; \
+			if [ ! -f "$$expected_file" ]; then \
+				echo "Missing expected Lua file for $$case"; \
+				exit 1; \
+			fi; \
+			output=$$(./c2lua "$$input"); \
+			expected=$$(cat "$$expected_file"); \
+			printf '%s' "-- $$case... "; \
+			if [ "$$output" = "$$expected" ]; then \
+				echo "ok"; \
+			else \
+				echo "fail"; \
+				printf 'Expected:\n%s\n\nGot:\n%s\n' "$$expected" "$$output"; \
+				exit 1; \
+			fi; \
+		done; \
+		echo "All pass tests passed."; \
+	fi
+
+test-fail: all
+	@echo "== Running fail tests =="
+	@if [ -z "$(FAIL_CASES)" ]; then \
+		echo "No fail tests found under $(FAIL_DIR)"; \
+	else \
+		for case in $(FAIL_CASES); do \
+			input="$(FAIL_DIR)/$$case.c"; \
+			expected_err="$(FAIL_DIR)/$$case.err"; \
+			if [ ! -f "$$expected_err" ]; then \
+				echo "Missing expected .err file for $$case"; \
+				exit 1; \
+			fi; \
+			tmp_err=$$(mktemp); \
+			if ./c2lua "$$input" > /dev/null 2> "$$tmp_err"; then \
+				echo "-- $$case... fail"; \
+				echo "Expected compilation error but succeeded."; \
+				rm -f "$$tmp_err"; \
+				exit 1; \
+			fi; \
+			if diff -u "$$expected_err" "$$tmp_err" > /dev/null; then \
+				echo "-- $$case... ok"; \
+			else \
+				echo "-- $$case... fail"; \
+				echo "Expected:"; \
+				cat "$$expected_err"; \
+				echo; \
+				echo "Got:"; \
+				cat "$$tmp_err"; \
+				rm -f "$$tmp_err"; \
+				exit 1; \
+			fi; \
+			rm -f "$$tmp_err"; \
+		done; \
+		echo "All fail tests passed."; \
+	fi

Makefile

@@ -14,36 +14,59 @@ O que não será suportado:
 
 ```
 .
-├── lexer/        # regras léxicas (lexer.l)
-├── parser/       # gramática e ações (parser.y)
-├── src/          # main.c, AST, tabela de símbolos, gerador Lua
-├── tests/        # entradas C e saídas Lua esperadas
+├── lexer/       # regras léxicas (lexer.l)
+├── parser/      # gramática e ações (parser.y)
+├── src/         # main.c, AST, tabela de símbolos, gerador Lua
+├── tests/
+│   ├── pass/    # casos que devem passar
+│   └── fail/    # casos que precisam falhar
 └── Makefile
 ```
 
-Ambiente rápido (Linux):
-```nu
+## Ambiente de Desenvolvimento
+
+Ubuntu Linux:
+```bash
 sudo apt update
 sudo apt install -y flex bison build-essential git
 ```
 
+Arch Linux:
+```bash
+sudo pacman -Syu flex bison base-devel git
+```
+
 Build local (exemplo mínimo):
-```nu
-flex lexer/lexer.l
-bison -d parser/parser.y
-gcc -o c2lua lex.yy.c parser.tab.c src/*.c -lfl
-./c2lua < tests/exemplo.c > out.lua
+```bash
+make 
+./c2lua tests/pass/expressions.c
 ```
 
 # Documentação de cada sprint
 
 - [1ª sprint](./docs/sprints/1.md);
 - [2ª sprint](./docs/sprints/2.md);
-- 3ª sprint;
-- 4ª sprint;
+- [3ª sprint](./docs/sprints/3.md);
+- [4ª sprint](./docs/sprints/4.md);
 
 # Testes
 
-A pasta `tests/` contém arquivos `.c` de entrada e os correspondentes `.lua` esperados. Use `diff` para comparar a saída gerada com a esperada.
+A pasta `tests/` está organizada em:
+- `tests/semantic/pass`: casos que devem gerar Lua válido e executar com sucesso;
+- `tests/semantic/fail`: casos que precisam falhar na análise semântica (arquivos `.err` com a mensagem esperada);
+
+Execute as suítes pelo Makefile:
+
+```bash
+make test            # verifica os smoke tests (tradução direta C -> Lua)
+```
+
+Os golden files utilizam o mesmo nome-base do arquivo `.c`, com extensão `.lua` (para PASS) ou `.golden`/`.err` (para FAIL).
+
+# Membros
 
-Padrão de nomenclatura: `descricao_curta_teste.c` para entrada, e `descricao_curta_teste.lua` para saída esperada.
+- Andre Lopes de Sousa - 211031593
+- João Victor da Silva Batista de Farias - 221022604
+- Livia Rodrigues Reis - 180105051
+- Marco Marques de Castro - 211062197
+- Sophia Souza da Silva - 231026886

README.md

@@ -1,8 +1,8 @@
-## Sprint 3 (D21–D30) — AST, símbolos e semântica básica
+## Sprint 3 (D21–D40) — AST, símbolos e semântica básica
 
 ### Núcleo semântico unificado: definir AST (expr/stmt/decl/fun), tabela de símbolos com escopos, checagem/conversão int↔float e mensagens de erro com linha/coluna
 
-  - [ ] responsáveis: @Sophiassilva
+  - [x] responsáveis: @Sophiassilva
   - **Entregáveis obrigatórios:**
       - `src/ast.h` / `src/ast.c` com a hierarquia de nós (expressões, comandos, declarações, funções) e utilitários de criação/destruição.
       - `src/symbol_table.h` / `src/symbol_table.c` com pilha de escopos (funções para `enter_scope`, `leave_scope`, `insert_symbol`, `lookup`).
@@ -25,16 +25,16 @@
       - **Promoção numérica:** `float y = 2 + 3.5;` deve produzir um nó Binário cujo resultado tem `TYPE_FLOAT`, convertendo o `2` para `2.0` automaticamente.
       - **Mensagem de erro rica:** `Erro [5:3]: variável 'z' não declarada; escopo atual possui {x, y}.`
 
-### Suporte sintático essencial: declarações, atribuições, blocos, if/else, while/for, curto-circuito lógico e comparações (==, \!=, \<, \<=, \>, \>=)
+### Suporte sintático essencial: declarações, atribuições, blocos, if/else, while/for, lógico e comparações (==, \!=, \<, \<=, \>, \>=)
 
-  - [ ] responsáveis: @marcomarquesdc
+  - [x] responsáveis: @marcomarquesdc
   - **Entregáveis obrigatórios:**
     - Regras no `src/parser.y` cobrindo:
     - Declaração de variáveis (com inicialização opcional) e de vetores 1D.
     - Atribuições simples e compostas (ex.: `+=`, se decidirmos suportar, documentar).
     - Blocos `{ ... }` com criação/destruição de escopo.
     - Estruturas de controle `if/else`, `while`, `for (init; cond; step)` e `do ... while`.
-    - Operadores lógicos com curto-circuito (`&&`, `||`) e comparações.
+    - Operadores lógicos (`&&`, `||`) e comparações.
     - Ações semânticas que instanciam nós da AST definidos na tarefa anterior.
     - Atualização dos tokens na `src/lexer.l` se novos operadores forem necessários (ex.: `<=`, `>=`, `!=` já existem; avaliar `+=`, `-=` etc.).
     - Casos de teste em `tests/syntax/` validando cada construção (happy path + caso de erro por falta de `;`).
@@ -43,7 +43,7 @@
     - Reutilizar a regra `program` para aceitar múltiplas declarações e funções.
     - Garantir que `for` seja reescrito em AST como um nó com três componentes (init/cond/update) e um corpo `Block`.
     - Incluir ações de `yyerror` informando token esperado, aproveitando localizações.
-  - **Exemplo alvo:** além do snippet abaixo, teste `for` com incremento, e `if` aninhados com `&&`/`||` para confirmar curto-circuito.
+  - **Exemplo alvo:** além do snippet abaixo, teste `for` com incremento, e `if` aninhados com `&&`/`||`.
   ```c
   int i = 0;
   for (; i < 5 && i != 3; i = i + 1) {
@@ -57,17 +57,16 @@
 
 ### Análise Semântica: missão Lua abrangente: variáveis locais, expressões, operadores lógicos, arrays 1D como tabelas, mapeamento de printf/puts, helpers de runtime quando necessário
 
-  - [ ] responsáveis: @Liviarodrigues1
+  - [x] responsáveis: @Liviarodrigues1
   - **Entregáveis obrigatórios:**
-      - Módulo `src/semantics.c` com passagens sobre a AST para checar tipos, resolver identificadores e anotar cada nó com tipo final.
       - Implementação das regras de promoção (int→float, char→int, bool→int quando permitido) e erros quando a combinação é inválida (`int + string`, `if` com expressão não booleana, etc.).
       - Representação de arrays como vetores Lua (`{}`) incluindo deslocamento +1 no índice.
       - Funções helper em `runtime/printf.lua` ou similar para cobrir `printf`/`puts` e conversões básicas.
       - Relatório de semântica (ex.: `docs/relatorios/semantica_sprint3.md`) com casos validados e conhecidos a resolver.
   - **Passos sugeridos:**
       - Percorrer a AST pós-parsing: primeiro declaração de variáveis/funções, depois corpo.
       - Armazenar em cada nó `AstExpression` os campos `type` e flags (`is_const`, `is_lvalue`).
-      - Sempre que gerar Lua, garantir que `&&` e `||` se tornem `and`/`or` e mantenham curto-circuito (uso direto já atende).
+      - Sempre que gerar Lua, garantir que `&&` e `||` se tornem `and`/`or`.
       - Para arrays, converter `arr[i]` em `arr[i + 1]` no código gerado.
       - Incluir testes: `tests/semantic/pass/*.c` (sem erros) e `tests/semantic/fail/*.c` (erro esperado com golden file da mensagem).
   - **Exemplos ampliados de tradução C → Lua:**
@@ -81,16 +80,6 @@
         local arr = {10, 20, 30}
         arr[2] = 99
         ```
-      - **Curto-circuito com ponteiros simulados:**
-        ```c
-        if (ptr != NULL && ptr->val > 10) { log(ptr->val); }
-        ```
-        ↓
-        ```lua
-        if ptr ~= nil and ptr.val > 10 then
-            log(ptr.val)
-        end
-        ```
       - **Mapeamento de `printf`:**
         ```c
         printf("Valor: %d e %f\n", a, b);
@@ -102,7 +91,7 @@
 
 ### Funções completas: traduzir assinaturas e return de C para function Lua, preservar escopos e chamadas
 
-  - [ ] responsáveis: @BeyondMagic
+  - [x] responsáveis: @BeyondMagic
   - **Entregáveis obrigatórios:**
     - Tradução de declarações de função para AST (`AstFunction`) com lista de parâmetros, tipo de retorno e bloco corpo.
     - Geração Lua correspondente em `src/codegen_lua.c` (novo arquivo) ou módulo existente, incluindo:
@@ -140,7 +129,7 @@
 
 ### Garantia de qualidade: testes de semântica (erros de escopo/tipo), golden files de erro, pipeline end-to-end (C → Lua → execução), linemap/diagnóstico e atualização de docs/demo
 
-  - [ ] responsáveis: @andrelopesdesousa
+  - [x] responsáveis: @andrelopesdesousa
   - **Entregáveis obrigatórios:**
       - Estrutura de testes automatizados:
         - `tests/semantic/pass/*.c` + `.lua` esperados.