コード例 #1
0
        public void execute(Token token)
        {
            string valor = token.Lexeme;
            TpTipo tipo  = Semantico.GetInstance().tipoDoValor(Semantico.GetInstance().tipoIdentificador);

            List <string> listaIds = new List <string>(); // Nesta lista deve estar os nomes das variaveis

//            KeyValuePair<string, Sintatico.Semantico.ItensTabela> it in Semantico.GetInstance().tabelaSimbolos
            foreach (var x in Semantico.GetInstance().pilha_de_identificadores)
            {
                var it = Semantico.GetInstance().tabelaSimbolos[x];
                if (!it.variavelDeclarada)
                {
                    listaIds.Add(x);
                    Semantico.GetInstance().tabelaSimbolos[x].variavelDeclarada = true;
                    Semantico.GetInstance().tabelaSimbolos[x].tipoIdentificador = tipo;
                }
                else
                {
                    throw new SemanticError("Erro na linha " + token.Position + " - identificador (" + x + ") já declarado");
                }
            }

            if (tipo != null)
            {
                declararIds(listaIds, tipo, valor);
            }

            Semantico.GetInstance().pilha_de_identificadores.Clear();
        }
コード例 #2
0
        public void execute(Token token)
        {
            /*
             * Faz a comparacao AND
             */
            TpTipo tipo1 = Semantico.GetInstance().pilha_de_tipos.Pop();
            TpTipo tipo2 = Semantico.GetInstance().pilha_de_tipos.Pop();

            if (tipo1.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }
            if (tipo2.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            if (!(tipo1 is TpBoolean) || !(tipo2 is TpBoolean))
            {
                throw new SemanticError("Tipo incompatível na expressão da linha " + token.Position);
            }
            Semantico.GetInstance().codigoGerado.AppendLine("and");

            Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
        }
コード例 #3
0
        public void execute(Token token)
        {
            /*
             * Faz a comparacao OR
             */
            TpTipo tipo1 = Semantico.GetInstance().pilha_de_tipos.Pop();
            TpTipo tipo2 = Semantico.GetInstance().pilha_de_tipos.Pop();

            if (tipo1.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }
            if (tipo2.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            if (!(tipo1 is TpBoolean) || !(tipo2 is TpBoolean))
            {
                throw new SemanticError("Erro na linha " + token.Position + " - Tipos incompatível ao realizar a comparação (OR)");
            }
            Semantico.GetInstance().codigoGerado.AppendLine("or");

            Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
        }
コード例 #4
0
        public void execute(Token token)
        {
            /*
             * tipo:= pilha.desempilha
             * se(tipo=bool)
             * então pilha.empilha (bool)
             * senão erro semântico: tipo incompatível no operador not, halt
             * código.adiciona (ldc.i4.1)
             * código.adiciona (xor)
             */
            TpTipo tipo = Semantico.GetInstance().pilha_de_tipos.Pop();

            if (tipo.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            if (tipo is TpBoolean)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
            }
            else
            {
                throw new SemanticError("Erro na linha " + token.Position + " - Tipos incompatível no operador not");
            }
            Semantico.GetInstance().codigoGerado.AppendLine("ldc.i4.1").AppendLine("xor");
        }
コード例 #5
0
        public void execute(Token token)
        {
            /*
             * ação #17:
             * tipo:= pilha.desempilha
             * código.adiciona (call void [mscorlib]System.Console::Write(tipo))
             */
            TpTipo tipo = Semantico.GetInstance().pilha_de_tipos.Pop();

            Semantico.GetInstance().codigoGerado.AppendLine("call void [mscorlib]System.Console::Write(" + tipo + ")");
        }
コード例 #6
0
        public void execute(Token token)
        {
            /*
             * código.adiciona (sub)
             */
            TpTipo tipo1 = Semantico.GetInstance().pilha_de_tipos.Pop();
            TpTipo tipo2 = Semantico.GetInstance().pilha_de_tipos.Pop();

            if (tipo1.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            if (tipo2.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            /*  if (tipo1.ehIdentificador())
             *    Semantico.GetInstance().pilha_de_identificadores.Pop();
             * if (tipo2.ehIdentificador())
             *    Semantico.GetInstance().pilha_de_identificadores.Pop();*/

            if (tipo1 is TpInteger && tipo2 is TpInteger)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpInteger(false));
            }
            else if (tipo1 is TpFloat && tipo2 is TpFloat)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else if (tipo1 is TpFloat && tipo2 is TpInteger)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else if (tipo1 is TpInteger && tipo2 is TpFloat)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else
            {
                throw new SemanticError("Erro na linha " + token.Position + " - Tipos inválidos no operador de subtração (-)");
            }

            Semantico.GetInstance().codigoGerado.AppendLine("sub");
        }
コード例 #7
0
        public void execute(Token token)
        {
            /*
             * tipo1:= pilha.desempilha
             * tipo2:= pilha.desempilha
             * se (tipo1=float64) ou (tipo2=float64)
             * então pilha.empilha (float64)
             * senão pilha.empilha (int64)
             * código.adiciona (mul)
             */
            TpTipo tipo1 = Semantico.GetInstance().pilha_de_tipos.Pop();
            TpTipo tipo2 = Semantico.GetInstance().pilha_de_tipos.Pop();

            if (tipo1.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }
            if (tipo2.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            if (tipo1 is TpInteger && tipo2 is TpInteger)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpInteger(false));
            }
            else if (tipo1 is TpFloat && tipo2 is TpFloat)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else if (tipo1 is TpFloat && tipo2 is TpInteger)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else if (tipo1 is TpInteger && tipo2 is TpFloat)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else
            {
                throw new SemanticError("Erro na linha " + token.Position + " - Tipos inválidos no operador de multiplicação (*)");
            }

            Semantico.GetInstance().codigoGerado.AppendLine("mul");
        }
コード例 #8
0
        public void execute(Token token)
        {
            /*
             * tipo1:= pilha.desempilha
             * tipo2:= pilha.desempilha
             * se (tipo1=tipo2)
             * então pilha.empilha (tipo1)
             * senão erro semântico, halt
             * código.adiciona (div)
             */
            TpTipo tipo1 = Semantico.GetInstance().pilha_de_tipos.Pop();
            TpTipo tipo2 = Semantico.GetInstance().pilha_de_tipos.Pop();

            if (tipo1.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }
            if (tipo2.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            if (tipo1 is TpInteger && tipo2 is TpInteger)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else if (tipo1 is TpFloat && tipo2 is TpFloat)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else if (tipo1 is TpFloat && tipo2 is TpInteger)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else if (tipo1 is TpInteger && tipo2 is TpFloat)
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpFloat(false));
            }
            else
            {
                throw new SemanticError("Erro na linha " + token.Position + " - Tipos inválidos no operador de divição (/)");
            }

            Semantico.GetInstance().codigoGerado.AppendLine("div");
        }
コード例 #9
0
        private void declararIds(List <string> listaIds, TpTipo tipo, string valor)
        {
            string codigoTipo = "";
            string codigoMSIL = "";

            if (tipo is TpInteger)
            {
                codigoTipo = "int64";
                codigoMSIL = "ldc.i8 {0}";
            }
            else if (tipo is TpFloat)
            {
                codigoTipo = "float64";
                codigoMSIL = "ldc.r8 {0}";
            }
            else if (tipo is TpBoolean)
            {
                codigoTipo = "bool";
                codigoMSIL = "ldc.i4 {0}";
            }
            else if (tipo is TpCaracter)
            {
                codigoTipo = "string";
                codigoMSIL = "ldstr {0}";
            }
            else if (tipo is TpString)
            {
                codigoTipo = "string";
                codigoMSIL = "ldstr {0}";
            }

            if (listaIds.Count > 0)
            {
                Semantico.GetInstance().codigoGerado.Append(".locals (");
                for (int i = 0; i < listaIds.Count; i++)
                {
                    Semantico.GetInstance().codigoGerado.Append(codigoTipo + " " + listaIds[i]);
                    if ((i + 1) < listaIds.Count)
                    {
                        Semantico.GetInstance().codigoGerado.Append(", ");
                    }
                }
                Semantico.GetInstance().codigoGerado.AppendLine(")");
            }

            if (Semantico.GetInstance().validaTipoValor(valor))
            {
                for (int i = 0; i < listaIds.Count; i++)
                {
                    if (tipo is TpBoolean)
                    {
                        if (valor == "true")
                        {
                            Semantico.GetInstance().codigoGerado.AppendLine("ldc.i4.1");
                        }
                        else
                        {
                            Semantico.GetInstance().codigoGerado.AppendLine("ldc.i4.0");
                        }
                    }
                    else
                    {
                        Semantico.GetInstance().codigoGerado.AppendLine(string.Format(codigoMSIL, valor));
                    }

                    Semantico.GetInstance().codigoGerado.AppendLine("stloc " + listaIds[i]);
                }
            }
        }
コード例 #10
0
        public void execute(Token token)
        {
            /*
             * tipo1:= pilha.desempilha
             * tipo2:= pilha.desempilha
             * se (tipo1 = tipo2)
             * então pilha.empilha (bool)
             * senão erro semântico, halt
             * caso operador_relacional
             * < : código.adiciona (clt)
             * > : código.adiciona (cgt)
             * = : código.adiciona (ceq)
             */
            TpTipo tipo1 = Semantico.GetInstance().pilha_de_tipos.Pop();
            TpTipo tipo2 = Semantico.GetInstance().pilha_de_tipos.Pop();

            if (tipo1.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }
            if (tipo2.ehIdentificador())
            {
                Semantico.GetInstance().pilha_de_identificadores.Pop();
            }

            if (tipo1.GetType() == new TpInteger(false).GetType() && new TpInteger(false).GetType() == tipo2.GetType())
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
            }
            else if (tipo1.GetType() == new TpFloat(false).GetType() && new TpInteger(false).GetType() == tipo2.GetType())
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
            }
            else if (tipo1.GetType() == new TpInteger(false).GetType() && new TpFloat(false).GetType() == tipo2.GetType())
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
            }
            else if (tipo1.GetType() == new TpFloat(false).GetType() && new TpFloat(false).GetType() == tipo2.GetType())
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
            }
            else if (tipo1.GetType() == new TpString(false).GetType() && new TpString(false).GetType() == tipo2.GetType())
            {
                Semantico.GetInstance().pilha_de_tipos.Push(new TpBoolean(false));
            }
            else
            {
                throw new SemanticError("Erro na linha " + token.Position + " - Tipos incompativeis em expressão relacional");
            }

            switch (Semantico.GetInstance().OperadorRelacional)
            {
            case "<":
                Semantico.GetInstance().codigoGerado.AppendLine("clt");
                break;

            case ">":
                Semantico.GetInstance().codigoGerado.AppendLine("cgt");
                break;

            case "==":
                Semantico.GetInstance().codigoGerado.AppendLine("ceq");
                break;

            case "<>":
            {
                Semantico.GetInstance().codigoGerado.AppendLine("ceq");
                Semantico.GetInstance().codigoGerado.AppendLine("ldc.i4.1");
                Semantico.GetInstance().codigoGerado.AppendLine("xor");
                break;
            }

            case "<=":
            {
                Semantico.GetInstance().codigoGerado.AppendLine("dup");
                Semantico.GetInstance().codigoGerado.AppendLine("stloc TOPO__ALTO");
                Semantico.GetInstance().codigoGerado.AppendLine("clt");
                Semantico.GetInstance().codigoGerado.AppendLine("ldloc TOPO__BAIXO");
                Semantico.GetInstance().codigoGerado.AppendLine("ldloc TOPO__ALTO");
                Semantico.GetInstance().codigoGerado.AppendLine("ceq");
                Semantico.GetInstance().codigoGerado.AppendLine("or");
                break;
            }

            case ">=":
            {
                Semantico.GetInstance().codigoGerado.AppendLine("dup");
                Semantico.GetInstance().codigoGerado.AppendLine("stloc TOPO__ALTO");
                Semantico.GetInstance().codigoGerado.AppendLine("cgt");
                Semantico.GetInstance().codigoGerado.AppendLine("ldloc TOPO__BAIXO");
                Semantico.GetInstance().codigoGerado.AppendLine("ldloc TOPO__ALTO");
                Semantico.GetInstance().codigoGerado.AppendLine("ceq");
                Semantico.GetInstance().codigoGerado.AppendLine("or");
                break;
            }
            }
        }