Merge pull request #1 from frame-lab/antes-bug-critico

Corrigindo Bug crítico, melhorando intervalos de inteiros, pré processamento, e mais

headers/Enum.h

@@ -4,14 +4,14 @@
 
 //typedef enum {false, true} bool;
 
-typedef enum SCOPE_TYPE { GLOBAL, FUNC, LOOP, IF_BLOCK, ELSE_BLOCK, SMV_PORTS, SMV_V_MAIN ,SIMPLE_HASH} SCOPE_TYPE;
+typedef enum SCOPE_TYPE { GLOBAL, FUNC, LOOP, IF_BLOCK, ELSE_BLOCK, SMV_PORTS, SMV_V_MAIN, SIMPLE_HASH} SCOPE_TYPE;
 
 typedef enum ENTRY_TYPE {NUMBER_ENTRY, LOGICAL_ENTRY, LABEL_ENTRY ,T_DIRECTIVE_ENTRY, TDS_ENTRY, NULL_ENTRY, FUNCTION_ENTRY, WRITE_SMV_INFO ,TYPE_SET } ENTRY_TYPE;
 			 // permitir lista de tipos diferentes? permitir lista de TDS's?
 			 // comentado por enquanto, devemos decidir oque fazer sobre os enums do node
 
 
-typedef enum smvtype {MAIN = 1, AUTOMATA = 2, PORTS = 3} smvtype;
+typedef enum smvtype {MAIN = 1, AUTOMATA = 2, PORTS = 3, FUNCTION_SMV = 4} smvtype;
 
 
 
@@ -25,7 +25,9 @@ typedef enum smvtype {MAIN = 1, AUTOMATA = 2, PORTS = 3} smvtype;
 
 
 // COLOCAR OS MAIS IMPORTANTES PRIMEIRO
-
+// NOTA, alguns ENUMS só existem para validações, outros que são usados para dar evaluate.
+// esses que só existem para validações as vezes estão já dentro de outro eval (o que poderiamos separar em diferntes evals para deixar,
+// mais modularizado (VAMOS TENTAR FAZER ISSO COM AS IMPLEMENTAÇÕES MAIS RECENTES)
 typedef enum EVAL_TYPE { 
 
 	NUMBER, L_BOOL, STRING, D_NULL, IDVAR, TIME_DIRECTIVE, 
@@ -34,19 +36,19 @@ typedef enum EVAL_TYPE {
 
 	AC_V, OTHER_ASSIGN, V_PROP, ADD_V, ADD_V_PROP, V_PROP_TDS,
 
-	EXPR, CMD_IF, MATCH_IF,
+	EXPR, CMD_IF, TDS_DEF_COMPLETE, TD_DEF_DEPEN,
 
-	ASSIGN_IDVAR, ASSIGN_AC_V, ASSIGN_TDIRECTIVE,
+    TIME_LIST, TIME_COMP, DOMAIN_FUNCTION,
 
-	TDS_DEF_COMPLETE, TD_DEF_DEPEN,
+    MATCH_IF,
 
-	DOMAIN_FUNCTION, TIME_LIST, TIME_COMP,
+    ASSIGN_IDVAR, ASSIGN_AC_V, ASSIGN_TDIRECTIVE,
 
 	DEF_EXTRAS_LINKED, DEF_EXTRAS_DELAYED,
 
     HEADERS_E_PROG, PROG, FUNC_DEFS, CMD,
 
-	FUNC_DEF, PROC_DEF, F_BODY, OPT_RETURN, PARAMS, PARAM, 
+	FUNC_DEF, PROC_DEF, OPT_RETURN, PARAMS, PARAM,
 
 	CMD_OTHER,
 

headers/HeaderSmv.h

@@ -2,19 +2,23 @@
 
 #define HEADER_H
 
-enum headerPart {CREATE_MODULE = -1, VAR = 0, ASSIGN = 1, TRANS = 2};
+#include "Enum.h"
+#include "STable.h"
+#include "textManager.h"
+
+typedef enum headerpart {CREATE_MODULE = -1, VAR = 0, ASSIGN = 1, TRANS = 2} headerpart;
 
 typedef struct headersmv
 {
-  int type;
+  smvtype type;
   char* moduleName;
   char** varBuffer; // poderia transormar em uma tabela hash(facilidade em achar a variavel, mas acredito que uma vez escrito aqui não vai ter alteração!)
   char** transBuffer; // vai ser inalterado durante a execução (só no pré processamento, ou seja já é criado preeenchido)
   char** assignBuffer; // aqui a ordem é importante não pode ser uma tabela hash
   int VAR_POINTER;
   int TRANS_POINTER;
   int ASSIGN_POINTER;
-  //char** declaredPorts; // usar para impedir o usuário de se "sabotar" usando ports que não existem
+  int VAR_RENAME_POINTER; // aponta para a referência a portsModule que vai ser passada para os demais módulos (e será centralizada no main agora)
 
 }HeaderSmv;
 
@@ -23,32 +27,102 @@ HeaderSmv* createHeader(int type, char* moduleName, int varP, int assignP, int t
 void letgoHeader(HeaderSmv* h);
 
 
-/*Controlador de Header(auxiliar)*/
-HeaderSmv** initHeadersStruct(int size);
+typedef struct headerController
+{
+    HeaderSmv* MAIN;
+    HeaderSmv** AUTOMATA_RELATED;
+    HeaderSmv** PORTS_RELATED; // ports module e as tds (vão ter referência para esse header na sua declaração, assim como tabela auxiliar)
+    HeaderSmv** FUNCTIONS; // as funções usadas por main e tds (vão ter referência para seu header na sua declaração, assim como tabela auxiliar)
 
-void letGoHeadersStruct(HeaderSmv** hs, int size);
+    int H_FUNCTION_CURRENT_SIZE;
+    int H_AUTOMATA_CURRENT_SIZE;
+    int H_PORTS_CURRENT_SIZE;
+
+    STable* mainInfo; // tabela de simbolos auxiliar para main
+    //STable** portsInfo; // para cada tds (talvez não va precisar, a lógica vai estar TODA nas funções ou nele mesmo (de maneira constante)
+    STable** functionsInfo; // para cada função
+
+    STable* originalPorts; // tabela de simbolos auxiliar para ports (necessária?) (só vai ter o módulo de cada porta) (pode ser na verdade para as portas declaradas)
+    int expectedPorts;
+    // ai ele verifica se foram usadas (não tem declarações de funções)
+    int declaredPorts;
 
 
-typedef struct headerController
-{
-  HeaderSmv ** headers;
-  int declaredPorts;
-  int CURRENT_SIZE; // usar current size com -1 (se vc está processando o indice atual(ultimo) é porque ele já alocou para o seguinte!)
-                    // ex:  sétimo membro(6) (CURRENT_SIZE = 7) (ou seja para referenciar o último é só pegar CURRENT-1)
-
 }HeaderController;
 
-HeaderController* createController(int size);
 
+HeaderController *createController();
+
+/**
+ * Libera o controlador e todas as estruturas armazenadas por ele
+ * @SideEffects: Chama o liberar dos headers e  tabelas de simbolos
+ * */
 void letGoHeaderControl(HeaderController* Hcontrol);
 
-/*Controlador de Header(auxiliar)*/
+/**
+ * Printa cada componente: VAR, ASSIGN, TRANS de um módulo SMV
+ * */
 void printHeaderBuffer(HeaderSmv* h, int type, char* typeString);
 
+/**
+ * Printa o módulo SMV e suas componentes: VAR, ASSIGN, TRANS
+ * */
 void printHeader(HeaderSmv* h);
 
+/**
+ * Printa todas os headers armazenados pelo controlador
+ * */
+void printAllHeaders(HeaderController* Hcontrol);
+
 void writeHeaderBuffer(HeaderSmv* h, int part, FILE* smvoutput);
 
 void writeHeader(HeaderSmv* header, FILE* smvoutput);
 
+void writeHeaderBuffer(HeaderSmv* h, int part, FILE* smvoutput);
+
+void writeHeader(HeaderSmv* header, FILE* smvoutput);
+
+/**
+* Considerando a refatoração do controller e header, encapsulamos o header apropriado pela estrutura, e esse deve
+* ser recuperado usando o enum de smvtype e o indice.
+*
+* Caso o indice não seja informado o último header salvo (tanto do agrupamento main, automato, ou ports) é retornado
+* Esse comportamento é usado pelo pré processamento, considerando que cada agrupamento é consultado para verificar o
+        * progresso de algumas alterações (ex: trocar FROZENVAR de portsModule), e otimizações da leitura
+*
+* @param controller o controlador de headers
+* @param cat o tipo smv de parte de intesse (main, automato/modulo generico, ports)
+* @param indexOfHeader a ordem de headers de cada parte de interesse (ex: 0 = portsModule, 1: função1 associada a tds)
+*
+* @returns o header apropriado com a parte de interesse do arquivo SMV
+* */
+HeaderSmv* accessHeader(HeaderController* controller, smvtype cat, int indexOfHeader);
+
+/**
+ * Considerando a refatoração do controller e header, encapsulamos as tabelas de simbolo auxiliares (SMV_INFO)
+ * ser recuperado usando o enum de smvtype.
+ *
+ * @param controller o controlador de headers
+ * @param cat o tipo smv de parte de intesse (main, automato/modulo generico, funções)
+ * @param SMV_INFO_ID o identificador daquela tabela auxiliar (usado atualmente só para as funções)
+ * @returns a tabela de simbolos SMV_INFO apropriada
+ * */
+STable* accessSmvInfo(HeaderController* controller, smvtype cat, int SMV_INFO_ID);
+
+/**
+ * Adiciona um novo header ao controller encapsulando suas operações e categorizando apropriadamente
+ * @param o controller
+ * @param o novo header retornado por createHeader
+ */
+void addNewHeader(HeaderController* controller, HeaderSmv* newHeader);
+
+/**
+ * Adiciona um novo parâmetro a portModule, e resolve as depêndencias nos demais módulos main e automato.
+ * @param o controller
+ * @param o novo parâmetro
+ * @SideEffects: Para cada módulo (main, automato ...) é atualizada a linha com depdência a ports e essa operação chama
+ * o módulo textManager e seus método addParams, criando uma string nova e liberando a antiga
+ */
+void addParamToPortsModule(HeaderController *controller, char *param, int first);
+
 #endif

headers/Interpreter.h

@@ -12,7 +12,19 @@
 #include "Node.h"
 #include "Object.h"
 
-Object * eval(Node* node, STable* scope, STable** writeSmvTypeTable, HeaderController* controllerSmv);
+Object *eval(Node *n, STable *scope, HeaderController *controllerSmv);
+
+// usar depois para criar executores genericos
+// caso a gente queira simplificar os parâmetros (note que muitos são desnecessários em alguns evals (MELHORIA))
+//typedef Object* (*generic_fp)(void);
+/*
+ * generic_fp executores[80] = {
+        (generic_fp ) evalNUM, (generic_fp ) evalBOOL, (generic_fp ) evalSTRING, (generic_fp ) evalNULL, (generic_fp ) evalIDVAR, (generic_fp ) evalTIME_DIRECTIVE,
+        (generic_fp ) evalDataV, (generic_fp ) evalPARAMS_CALL, (generic_fp ) evalDEFINE_INTERVAL , (generic_fp ) evalAC_V,
+        (generic_fp ) evalOTHER_ASSIGN, (generic_fp ) evalV_PROP, (generic_fp ) evalADD_V, (generic_fp ) evalADD_V_PROP, (generic_fp ) evalV_PROP_TDS, (generic_fp ) evalEXPR, (generic_fp )
+        (generic_fp ) evalCMD_IF, (generic_fp ) evalMATCH_IF
+};
+ * */
 
 
 #endif

headers/Object.h

@@ -8,22 +8,22 @@
 // pode permitir lazy evalution no futuro
 typedef struct SYNTH_OBJECT
 {
-  int type;
-  int OBJECT_SIZE;
-  int* STR; // tamanho strings mapeado
-  void ** values; // a pergunta é ... lista de valores ou valor único ?(em geral vai ser unico, pode ser também um ponteiro para uma lista)
-  int redef; // serve para auxiliar na escrita no nuXmv (e talvez em um futuro se permitir lista de valores diferentes)
-  char* SINTH_BIND; // serve para auxiliar a limpeza de memória e escrever no nuXmv
-  int timeContext;
+    ENTRY_TYPE type;
+    int OBJECT_SIZE;
+    int* STR; // tamanho strings mapeado
+    void ** values; // a pergunta é ... lista de valores ou valor único ?(em geral vai ser unico, pode ser também um ponteiro para uma lista)
+    int redef; // serve para auxiliar na escrita no nuXmv (e talvez em um futuro se permitir lista de valores diferentes)
+    char* SINTH_BIND; // auxilia a variavel anterior, // serve para auxiliar a limpeza de memória e escrever no nuXmv
+    int timeContext;
 
 } Object;
 
 // mudar depois o tipo
-Object *createObject(int type, int OBJECT_SIZE, void **values, int timeContext, char *SYNTH_BIND);
+Object *createObject(int type, int OBJECT_SIZE, void **values, int timeContext, char *BIND);
 
 void printObject(Object* o);
 
-void letgoObject(Object* o, int always);
+void letgoObject(Object *o);
 
 /*
 	Copia um objeto "o"

headers/PostProcess.h

@@ -21,8 +21,6 @@
  * @SideEffects Aletra o conteúdo em memória vindo de SINTH_BIND
  *
  * */
-
-
 void copyValueBind(Object* o, char* bind,int index,int defaultValue);
 
 
@@ -60,7 +58,15 @@ char *createConditionCube(char *opBind1, char *opBind2, char *operation, char *e
 
 /***/
 void createExprBind(char *result, Object *o1, Object *o2, char *op);
-/***/
+
+/**
+ * Cria uma condição para um escopo if/else. Caso esse seja filho de outro escopo if/else, cria uma condição composta
+ * em um "cubo".
+ * @param scope o escopo atual sendo criado (if/else)
+ * @param conditionExpr a condição a ser associada a esse escopo ou ao cubo de "condições herdadas"
+ *
+ * @sideEffects: Aloca string de condição para o escopo e intermediária para o cubo.
+ * */
 void bindCondition(STable* scope, Object* conditionExpr);
 
 /**
@@ -86,7 +92,8 @@ void bindCondition(STable* scope, Object* conditionExpr);
  * @Return "cubo : expressão;"
  * */
 
-char* formatBinds(int ctime, int changeContext, char* directiveValueBind, char* valueBind, char* defaultValueBind, Object* expr, STable* scope, int firstCondition);
+char *formatBinds(int ctime, int changeContext, char *directiveValueBind, char *valueBind, char *defaultValueBind,
+                  Object *expr, STable *scope, int firstCondition, int initVar, int ignoreTemporal, int ignoreCond);
 
 /**
  *  Cria uma declaração do tipo init(varName) := newValue ; ou  init(varName) := case condition : newValue esac;
@@ -128,15 +135,29 @@ void createAssign(char *varName, HeaderSmv *header, STable *writeSmvTypeTable, c
  * */
 void updateAssign(char* varName ,HeaderSmv* header, STable* writeSmvTypeTable, char* newValue, char* condition, int type ,int typeExpr, int minmax);
 
+/**
+ * Devolve uma referência a um objeto, considerando seu bind com redefinições e escopo original onde foi criado
+ * @param a entrada original na tabela de simbolos da linguagem
+ * @sideEffects:  Todos os criar uma copia do Object referênciado por var, e passa uma string do nome referênciado para o seu SYNTH_OBJECT
+ * */
+Object* refCopyOfVariable(TableEntry* var);
+
 /**
  * Escolhe entre update/create Assign de casos init/next tratando casos de redefinição e condições
  * @param
  * @sideEffects:  Todos os colaterais de updateAssign ou createAssign
  * */
-void specAssign(char *varName, HeaderSmv *header, STable *writeSmvTypeTable, char *newValue, char *condition,
-                char *defaultValue, int redef, char *funcRef, int order, int level, int type, int typeExpr, int minmax);
+void specAssign(int varInit, char *varName, int contextChange, HeaderSmv *header, STable *scope, STable *writeSmvTypeTable,
+           Object *newValue, int redef, int typeExpr, int C_TIME);
 
 
+/**
+ * Para casos de redefinição, libera a entrada anterior dessa variável já que a mesma não será mais referênciada
+ * @param a entrada com o nome da variável
+ * @param a tabela de  simbolos auxiliar
+ * @sideEffects:  Computa uma string para o nome referência e depois o libera da tabela de simbolos auxiliar
+ * */
+void letGoOldEntry(TableEntry* var, STable* auxTable);
 
 
 void writeResultantHeaders(HeaderController* controller, const char* path);

headers/PreProcess.h

@@ -3,7 +3,6 @@
 #define PREP_H
 
 #include "HeaderSmv.h"
-#include "STable.h"
 
 
 
@@ -15,7 +14,7 @@
 					  *	cria um header (necessita de free depois) 
 */
 
-void initPreProcessHeader(int type, char* moduleName, HeaderController* Hcontrol); 
+void initPreProcessHeader(smvtype type, char* moduleName, HeaderController* Hcontrol);
 
 
 
@@ -26,34 +25,45 @@ void initPreProcessHeader(int type, char* moduleName, HeaderController* Hcontrol
 						 * ao ter controlRename como true, ele remove todas as ocorrências de determinados caracteres (no caso [])
 
 */
-void selectBuffer(int part, char* line, HeaderSmv* header, int controlRename, int readVarsPortsModule, STable** writeSmvTypeTable);
-
+void selectBuffer(headerpart part, char* line, HeaderSmv* header, int controlRename);
 
 
 /*
 	prepara para chamar a função de escolha de buffer, t
 	ratando a posição (pos) que representa o tamanho do vetor de HEADERS do controller (LEN-1)
 						 
 */
-void saveLineOnBuffer(int pos,int part, char* line, HeaderController* Hcontrol, int controlRename, int readVarsPortsModule, STable** writeSmvTypeTable);
-
+void saveLineOnBuffer(smvtype currentHeader, headerpart part, char *line, HeaderController *Hcontrol, int controlRename);
 
 
 /* fases: criação, var, assign(pode não existir), trans(pode não existir) (as partes de interesse)
  	as partes de interesse servem como delimitadores,  quebras de linha servem como delimitadores dos módulos
  	stages são os módulos 0(main), automato(2), ports(3)
 */
-void processPhase(int stage, int part, HeaderController* Hcontrol, char * line, int controlRename, int readVarsPortsModule, STable** writeSmvTypeTable);
-
-
-void preProcessSmv(FILE* smvP, HeaderController* Hcontrol, STable** writeSmvTypeTable); 
-
-/* 
-	configura a tabela de controle de escrita para a diretiva temporal do Header Main
-	inicializando com a variável time (que não possui typeset, por so poder ser X..Y)
-*/
-void setUpMainSmvTable(HeaderController* Hcontrol, STable** writeSmvTypeTable, STable* global);
-
+void processPhase(smvtype stage, headerpart part, HeaderController *Hcontrol, char *line, int controlRename);
+
+/**
+ * Salva o arquivo SMV original em headers, separados por categorias e partes de um arquivo SMV.
+ * Durante esse pré processamento, são usadas variáveis strings auxiliares para reconhecer pontos de interesse no arquivo.
+ * A cada ponto de interesse identificado, um buffer do header é escolhido, e esse atualizado.
+ * Ao se identificar o alguma referência a portsModule essa tem o parâmetro time adicionado, e uma referência é salva no header do automato,
+ * para renomações futuras. Além disso são criadas entradas na tabelas de simbolos auxiliares (SMV_INFO) usadas pelo main e ports, respectivamente,
+ * a variável time e as portas que vierem do módulo original.
+ * */
+void preProcessSmv(FILE *smvP, HeaderController *Hcontrol);
+
+/**
+ *  Configura a tabela de controle SMV info da main para a variável time a incializando
+ *  com uma tupla de inteiros (que não possui typeset, por so poder ser X..Y). Além disso,
+ *  inicializa as diretivas temporais no escopo global (main).
+ *
+ *  @param Hcontrol o controller de headers e informações SMV
+ *  @param global a tabela de simbolos global do "programa" .tds
+ *
+ *  @SideEffects:  Chama o addValue da tabela de simbolos para os casos citados, alocando memória para as Entry de
+ *  cada tupla.
+ * */
+void setUpMainSmvTable(HeaderController *Hcontrol, STable *global);
 
 #endif