Пример #1
0
void DiffMoranVarSettingDlg::CreateControls()
{
    wxPanel *panel = new wxPanel(this);
    
    wxBoxSizer *vbox = new wxBoxSizer(wxVERTICAL);
     wxBoxSizer *vbox1 = new wxBoxSizer(wxVERTICAL);
    wxBoxSizer *hbox = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *hbox1 = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *hbox2 = new wxBoxSizer(wxHORIZONTAL);
    
    wxSize var_size(100, -1);
    wxSize  time_size(100,-1);
    
    wxStaticText  *st = new wxStaticText (panel, wxID_ANY, _("Select variable "),
                                          wxDefaultPosition, wxDefaultSize);
    
    wxComboBox* box = new wxComboBox(panel, wxID_ANY, "", wxDefaultPosition,
                                     var_size, 0, NULL, wxCB_READONLY);
    
    wxStaticText  *st1 = new wxStaticText (panel, wxID_ANY,
                                           _(" and two time periods: "),
                                           wxDefaultPosition, wxDefaultSize);
    
    wxComboBox* box1 = new wxComboBox(panel, wxID_ANY, "", wxDefaultPosition,
                                      time_size, 0, NULL, wxCB_READONLY);
    
    wxStaticText  *st2 = new wxStaticText (panel, wxID_ANY, _(" and "),
                                           wxDefaultPosition, wxDefaultSize);
    
    wxComboBox* box2 = new wxComboBox(panel, wxID_ANY, "", wxDefaultPosition,
                                      time_size, 0, NULL, wxCB_READONLY);
    
    hbox->Add(st, 1, wxALIGN_CENTER | wxLEFT| wxTOP | wxBOTTOM, 10);
    hbox->Add(box, 1, wxALIGN_CENTER | wxTOP | wxBOTTOM, 10);
    hbox->Add(st1, 1, wxALIGN_CENTER | wxTOP | wxBOTTOM, 10);
    hbox->Add(box1, 1, wxALIGN_CENTER | wxTOP | wxBOTTOM, 10);
    hbox->Add(st2, 1, wxALIGN_CENTER | wxTOP | wxBOTTOM, 10);
    hbox->Add(box2, 1, wxALIGN_CENTER | wxTOP | wxBOTTOM |wxRIGHT, 10);
    
    
    wxStaticText  *st3 = new wxStaticText (panel, wxID_ANY, _("Weights"),
                                           wxDefaultPosition, wxSize(70,-1));
    
    wxComboBox* box3 = new wxComboBox(panel, wxID_ANY, _(""), wxDefaultPosition,
                                      wxSize(160,-1), 0, NULL, wxCB_READONLY);
    
    hbox1->Add(st3, 0, wxALIGN_CENTER | wxLEFT| wxTOP | wxBOTTOM, 10);
    hbox1->Add(box3, 0, wxALIGN_LEFT | wxTOP | wxBOTTOM, 10);
    
    vbox->Add(hbox, 1);
    vbox->Add(hbox1, 1, wxALIGN_LEFT | wxTOP , 30);
    
    panel->SetSizer(vbox);
    
    wxButton *okButton = new wxButton(this, wxID_OK, _("OK"), wxDefaultPosition,
                                      wxSize(70, 30));
    wxButton *closeButton = new wxButton(this, wxID_EXIT, _("Close"),
                                         wxDefaultPosition, wxSize(70, 30));
    
    hbox2->Add(okButton, 1);
    hbox2->Add(closeButton, 1, wxLEFT, 5);
    
    vbox1->Add(panel, 1);
    vbox1->Add(hbox2, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, 10);
    
    SetSizer(vbox1);
    
    Centre();
    
    // Content
    InitVariableCombobox(box);
    InitTimeComboboxes(box1, box2);
    InitWeightsCombobox(box3);
    
    combo_var = box;
    combo_time1 = box1;
    combo_time2 = box2;
    combo_weights = box3;
    
    // Events
    okButton->Bind(wxEVT_BUTTON, &DiffMoranVarSettingDlg::OnOK, this);
    closeButton->Bind(wxEVT_BUTTON, &DiffMoranVarSettingDlg::OnClose, this);
}
Пример #2
0
void StackPopCommands(STACK* stack_pointer, List* global, List* global_vet, List* local, List* function_list, List* AllParams){
	if(stack_pointer!=NULL){ 
		List* InUseFunction  = TILL_NULL(function_list);	/*A ultima funcao da lista de funcoes sera a funcao em uso
										cujos comandos serao desempilhados*/
		int NumVal;	
		List *GlobalSearch, *LocalSearch, *VectorialSearch, *FunctionSearch, *aux;
		ASTREE* Variable,*RightSon,*LeftSon,*Left_RightGrandSon;
		switch(stack_pointer->disc->type){
		case IKS_AST_ARIM_SUBTRACAO:
		case IKS_AST_ARIM_MULTIPLICACAO: 
		case IKS_AST_LOGICO_E:
		case IKS_AST_LOGICO_OU:
		case IKS_AST_ARIM_DIVISAO:
		case IKS_AST_LOGICO_COMP_DIF:     
		case IKS_AST_LOGICO_COMP_IGUAL:   
		case IKS_AST_LOGICO_COMP_LE:      
		case IKS_AST_LOGICO_COMP_GE:      
		case IKS_AST_LOGICO_COMP_L:       
		case IKS_AST_LOGICO_COMP_G:       
		case IKS_AST_ARIM_SOMA:
						stack_pointer->disc->node_type = inference(stack_pointer->disc->scc[0]->node_type,stack_pointer->disc->scc[1]->node_type);
						break;
		case IKS_AST_CHAMADA_DE_FUNCAO:
						/*Primeiramente, teremos de verificar a existencia da função chamada*/
						LeftSon = stack_pointer->disc->scc[0];
						RightSon = stack_pointer->disc->scc[1]; 
						FunctionSearch = list_lookup(function_list,LeftSon->symbol->text); /*retorna a função chamada*/
						if(FunctionSearch != NULL){
							AllParams = FunctionParamList(AllParams,FunctionSearch->tam); /*Retorna a lista de parametros da função chamada*/
							Variable = ParamLookup(RightSon,AllParams);
							if(Variable == NULL && RightSon!= NULL)
								stack_pointer->disc->node_type = inference(RightSon->type,LeftSon->type);
							else if(Variable == NULL && RightSon == NULL)
								stack_pointer->disc->node_type = LeftSon->node_type;
						}
						else{
							printf("->Funcao nao declarada (linha %d)\n", getLineNumber()-1);
							exit(IKS_ERROR_UNDECLARED);
							break;
						}
						break;
		case IKS_AST_IDENTIFICADOR: 	
						GlobalSearch = list_lookup(global,stack_pointer->disc->symbol->text);
						LocalSearch  = list_lookup(local,stack_pointer->disc->symbol->text);
						VectorialSearch = list_lookup(global_vet,stack_pointer->disc->symbol->text); 
						FunctionSearch = list_lookup(function_list,stack_pointer->disc->symbol->text);
						if(GlobalSearch !=NULL){
							if(LocalSearch !=NULL){
								printf("->Identificador de variavel global foi declarado como variavel local (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else if(FunctionSearch !=NULL){
								printf("->Identificador de variavel global foi declarado como funcao (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else{
								stack_pointer->disc->node_type = GlobalSearch->type;
								stack_pointer->disc->size = var_size(stack_pointer->disc->node_type);
								break;
							}
						}
						else if(LocalSearch != NULL){
							if(GlobalSearch != NULL){
								printf("->Identificador de variavel local foi declarado como variavel global (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else if(FunctionSearch != NULL){
								printf("->Identificador de variavel local foi declarado como funcao (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else{
								stack_pointer->disc->node_type = LocalSearch->type;
								stack_pointer->disc->size = var_size(stack_pointer->disc->node_type);
								break;
							}
						}
						else if(FunctionSearch != NULL){
							if(GlobalSearch != NULL){
								printf("->Identificador de funcao foi declarado como variavel global (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else if(LocalSearch !=NULL){
								printf("->Identificador de funcao foi declarado como variavel local (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else{
								stack_pointer->disc->node_type = FunctionSearch->type;
								stack_pointer->disc->size = var_size(stack_pointer->disc->node_type);
								break;
							}
						}
						else if (VectorialSearch ==NULL){
							printf("->Identificador nao declarado (linha %d)\n", getLineNumber()-1);
							exit(IKS_ERROR_UNDECLARED);
							break;
						}
						break;
		case IKS_AST_LITERAL:
						stack_pointer->disc->node_type = stack_pointer->disc->symbol->type;
						stack_pointer->disc->size = var_size(stack_pointer->disc->symbol->type);
						break;
		case IKS_AST_VETOR_INDEXADO:	
						/*O primeiro filho de um vetor indexado será o TK_IDENTIFICADOR referente ao nome da variavel*/ 
						LeftSon = stack_pointer->disc->scc[0];		/*Variavel do vetor*/
						RightSon = stack_pointer->disc->scc[1];		/*Quantidade de termos do vetor*/
						GlobalSearch = list_lookup(global,stack_pointer->disc->scc[0]->symbol->text);
						LocalSearch  = list_lookup(local,stack_pointer->disc->scc[0]->symbol->text);
						VectorialSearch = list_lookup(global_vet,stack_pointer->disc->scc[0]->symbol->text);
						FunctionSearch = list_lookup(function_list,stack_pointer->disc->scc[0]->symbol->text);
						if(VectorialSearch !=NULL){
							LeftSon->node_type = VectorialSearch->type;
							stack_pointer->disc->node_type = VectorialSearch->type;		
							LeftSon->size =VectorialSearch->tam*var_size(LeftSon->node_type);
							stack_pointer->disc->size = LeftSon->size;
							break;
						}
						else{
							if(GlobalSearch !=NULL){
								printf("->Identificador de vetor foi declarado como variavel global (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else if(LocalSearch !=NULL){
								printf("->Identificador de vetor foi declarado como variavel local (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
							else if(FunctionSearch !=NULL){
								printf("->Identificador de vetor foi declarado como funcao (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
								break;
							}
						}
						break;
		case IKS_AST_ATRIBUICAO: 	
						/*Quando chegarmos no nó atribuição já teremos os nós filhos definidos: leftson e rightson
 									filho direito do filho da esquerda*/
						LeftSon = stack_pointer->disc->scc[0];	
						RightSon = stack_pointer->disc->scc[1];	
						Left_RightGrandSon = LeftSon->scc[1]; 
						if(stack_pointer->disc->scc[0]->type == IKS_AST_VETOR_INDEXADO){
							Variable = stack_pointer->disc->scc[0]->scc[0];
							GlobalSearch = list_lookup(global,Variable->symbol->text);
							LocalSearch  = list_lookup(local,Variable->symbol->text);
							VectorialSearch = list_lookup(global_vet,Variable->symbol->text);
							FunctionSearch = list_lookup(function_list,Variable->symbol->text);		
							if(GlobalSearch !=NULL){
								printf("-> Identificador de vetor foi declarado como variavel global (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
							 }
							 else if(FunctionSearch !=NULL){
								printf("-> Identificador de vetor foi declarado como funcao (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_FUNCTION);
							 }
							 else if(LocalSearch !=NULL){
								printf("-> Identificador de vetor foi declarado como variavel local (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VARIABLE);
							 }
							 else{
								Left_RightGrandSon->node_type = coertion(IKS_INT,Left_RightGrandSon->node_type);
								stack_pointer->disc->node_type = inference(LeftSon->node_type,RightSon->node_type); /* atribuição de tipo ao nodo indexado*/
								
							 }
						}
						else if(stack_pointer->disc->scc[0]->type == IKS_AST_IDENTIFICADOR){
							Variable = stack_pointer->disc->scc[0];
							GlobalSearch = list_lookup(global,Variable->symbol->text);
							LocalSearch  = list_lookup(local,Variable->symbol->text);
							VectorialSearch = list_lookup(global_vet,Variable->symbol->text);
							FunctionSearch = list_lookup(function_list,Variable->symbol->text);
							if(VectorialSearch !=NULL){
								printf("-> Identificador de variavel foi declarado como vetor (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_VECTOR);
							}
							else if(FunctionSearch !=NULL){
								printf("-> Identificador de variavel foi declarado como funcao (linha %d)\n", getLineNumber()-1);
								exit(IKS_ERROR_FUNCTION);
							}
							else
								stack_pointer->disc->node_type = coertion(LeftSon->node_type,RightSon->node_type);				
						}
						break;
		case IKS_AST_INPUT:		
						LeftSon = stack_pointer->disc->scc[0];
						if(LeftSon->type != IKS_AST_IDENTIFICADOR){
							printf("O parametro do comando input (linha %d) nao se trata de um identificador\n",getLineNumber()-1);
							exit(IKS_ERROR_WRONG_PAR_INPUT);			
						}
						else
							 stack_pointer->disc->node_type = LeftSon->node_type;				
						break;
		case IKS_AST_OUTPUT:		
						LeftSon = stack_pointer->disc->scc[0];

						if(LeftSon->node_type == IKS_CHAR){
							printf("O parametro do comando output (linha %d) deve ser literal string ou expressao\n",getLineNumber()-1);
							exit(IKS_ERROR_WRONG_PAR_OUTPUT);			
						}
						else
							 stack_pointer->disc->node_type = LeftSon->node_type;	
						break;
		case IKS_AST_RETURN:
						LeftSon = stack_pointer->disc->scc[0];
						if(InUseFunction->type != LeftSon->node_type){
							if((LeftSon->node_type == IKS_CHAR) ||(LeftSon->node_type == IKS_STRING)){
								printf("A variavel do comando return deve ter o mesmo tipo da funcao %s (linha %d)\n",InUseFunction->text,getLineNumber()-1);
								exit(IKS_ERROR_WRONG_PAR_RETURN);
							}
							else{
								InUseFunction->type = coertion(InUseFunction->type,LeftSon->node_type);
							}	stack_pointer->disc->node_type = LeftSon->node_type;
						}
						else{
							stack_pointer->disc->node_type = LeftSon->node_type;
						}
						break;   
		}
		stack_pointer= stack_pointer->next;
		return  StackPopCommands(stack_pointer,global,global_vet,local,function_list, AllParams);
	}
}