Пример #1
0
    public override string Eval(Dictionary <string, TYPEDEF> typedefTable, Dictionary <string, VARDECL> symbolTable)
    {
        if (typedefTable.ContainsKey(Variable) && !symbolTable.ContainsKey(Variable))
        {
            return(typedefTable[Variable].Name);
        }

        if (!symbolTable.ContainsKey(Variable))
        {
            throw new SemanticException("No such VARDECL: " + Variable);
        }

        VARDECL decl = symbolTable[Variable];

        if (!typedefTable.ContainsKey(decl.Type))
        {
            throw new SemanticException("No such TYPEDEF: " + decl.Type);
        }

        return(typedefTable[decl.Type].Name);
    }
Пример #2
0
    public override string Eval(List <Expression> expList, Dictionary <string, TYPEDEF> typedefTable, Dictionary <string, VARDECL> symbolTable)
    {
        if (expList.Count != 2 && !(expList[0] is ListExpression))
        {
            throw new SemanticException("ACCESSP Operator requires an expression and field parameter (ACCESSP <exp> <field>).");
        }

        object param1;
        object param2;

        if (expList.Count != 2 && expList[0] is ListExpression)
        {
            param1 = expList[0].First();
            param2 = expList[0].Rest();
        }
        else
        {
            param1 = expList[0];
            param2 = expList[1];
        }

        string prodtype = (param1 as Expression).Eval(typedefTable, symbolTable);

        if (!typedefTable.ContainsKey(prodtype))
        {
            throw new SemanticException("A Product of type " + prodtype + " was never defined, please add a TYPEDEF " + prodtype + " PRODUCT ... above.");
        }

        if (typedefTable[prodtype].Type != "PRODUCT" &&
            typedefTable[prodtype].Name != "MKPROD" &&
            typedefTable[prodtype].Type != "SUM" &&
            typedefTable[prodtype].Name != "TREATAS" &&
            typedefTable[prodtype].Type != "SUBTYPE" &&
            typedefTable[prodtype].Name != "EMBED")
        {
            throw new SemanticException("Expression " + (param1 as Expression) + " evaluates to type " + prodtype + " but ACCESSP  requires a second parameter type of " + "PRODUCT");
        }

        PRODUCT prod = typedefTable[prodtype] as PRODUCT;


        if (null == prod ||
            typedefTable[prodtype].Name == "MKPROD" ||
            typedefTable[prodtype].Name == "TREATAS" ||
            typedefTable[prodtype].Name == "EMBED")
        {
            ListExpression foobar = (param2 as ListExpression);
            prodtype = foobar.expList[0].Variable;

            VARDECL vardecl = symbolTable[prodtype];
            prod = typedefTable[vardecl.Type] as PRODUCT;

            string prod_field = foobar.expList[foobar.expList.Count - 1].Variable;

            return(prod.ArgPairs[prod_field]);
        }

        if (null == prod)
        {
            throw new SemanticException("First param to ACCESSP is not actually a PRODUCT.");
        }

        VariableExpression varexp = (param2 as VariableExpression);

        if (null == varexp)
        {
            throw new SemanticException("Second param to ACCESSP is not actually a field value, but an expression");
        }

        if (!prod.ArgPairs.ContainsKey(varexp.Variable))
        {
            throw new SemanticException("The PRODUCT " + prod.Name + " does not have a field with name " + varexp.Variable + ".");
        }

        return(prod.ArgPairs[varexp.Variable]);
    }