SemanticErrors.java

Go to the documentation of this file.

import java.util.*;
import org.antlr.runtime.*;

enum SemErrorCodes {
    identAlreadyDeclared,
    identIsNotDeclared,
    incompatibleAssignment,
    nonReferenceableLeftAssigment,
    incompatibleOperation,
    fieldAlreadyDefined,
    fieldIsNotDefined,
    booleanExpressionRequired,
    readWriteRequireBasic,
    referenciableExpressionRequired,
    integerIndexRequired,
    identIsNotProcedure,
    identIsNotFunction,
    incompatibleParameter,
    nonReferenceableParameter,
    incorrectNumberOfParameters,
    incompatibleReturnExpression
};


final class SemanticError implements Comparable<SemanticError> {
    private int line;

    private int charPositionInLine;

    private SemErrorCodes errorCode;

    private String text;

    private int    num;

    //    // Atributo adicional para describir y localizar mejor algunos errores
    //    private CL_AST expr;

    SemanticError(SemErrorCodes code, CL_AST ast) {
        errorCode = code;
        line = ast.getLine();
        charPositionInLine = ast.getCharPositionInLine();
        text = ast.getText();
    }
    
    SemanticError(SemErrorCodes code, CL_AST ast, int n) {
        errorCode = code;
        line = ast.getLine();
        charPositionInLine = ast.getCharPositionInLine();
        text = ast.getText();
        num = n;
    }

    public int compareTo(SemanticError error) {
        if (line < error.line) return -1;
        if (error.line < line) return +1;
        if (charPositionInLine < error.charPositionInLine) return -1;
        if (error.charPositionInLine < charPositionInLine) return +1;
        if (errorCode.compareTo(error.errorCode) == -1) return -1;
        if (errorCode.compareTo(error.errorCode) == +1) return +1;
        return 0;
    }
    
    boolean equals(SemanticError error) {
        return line == error.line &&
               charPositionInLine == error.charPositionInLine &&
               errorCode == error.errorCode;
    }

    public String toString( ) {
        String s = "L. " + line + ":" + charPositionInLine + ": ";
        switch (errorCode) {
        case identAlreadyDeclared:
            s += "Identifier '" + text + "' already declared in this scope.";
            return s;
        case identIsNotDeclared:
            s += "Identifier '" + text + "' is undeclared.";
            return s;
        case incompatibleAssignment:
            s += "Assigment with incompatible types.";
            return s;
        case nonReferenceableLeftAssigment:
            s += "Left expression of assignment is not referenceable.";
            return s;
        case incompatibleOperation:
            s += "Operator '" + text + "' with incompatible types.";
            return s;
        case fieldAlreadyDefined:
            s += "Field '" + text + "' already defined in the struct.";
            return s;
        case fieldIsNotDefined:
            s += "Field '" + text + "' is not defined in the struct.";
            return s;
        case booleanExpressionRequired:
            s += "Instruction '" + text + "' requires a boolean condition.";
            return s;
        case readWriteRequireBasic:
            s += "Instruction '" + text + "' requires a basic type.";
            return s;
        case referenciableExpressionRequired:
            s += "Instruction '" + text + "' requires a referenceable expression.";
            return s;
        case integerIndexRequired:
            s += "Array index must be of type integer.";
            return s;
        case identIsNotProcedure:
            s += "Procedure call instruction where '" + text + "' is not a procedure.";
            return s;
        case identIsNotFunction:
            s += "Function call expression where '" + text + "' is not a function.";
            return s;
        case incompatibleParameter:
            s += "Parameter #" +  num + " with incompatible types.";
            return s;
        case nonReferenceableParameter:
            s += "Parameter #" +  num + " is expected to be referenciable.";
            return s;
        case incorrectNumberOfParameters:
            s += "The number of parameters in the call to '" + text + "' does not match.";
            return s;
        case incompatibleReturnExpression:
            s += "Function return with incompatible type.";
            return s;
        default:
            s += "Unknown Semantic Error.";
            return s;
        }
    }

}


final class SemanticErrors {
    private List<SemanticError> errors;

    SemanticErrors() {
        errors = new ArrayList<SemanticError>();
    }

    void add_IdentAlreadyDeclared(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.identAlreadyDeclared, ast));
    }

    void add_IdentIsNotDeclared(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.identIsNotDeclared, ast));
    }

    void add_IncompatibleAssignment(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.incompatibleAssignment, ast));
    }

    void add_NonReferenceableLeftAssigment(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.nonReferenceableLeftAssigment, ast));
    }

    void add_IncompatibleOperation(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.incompatibleOperation, ast));
    }

    void add_FieldAlreadyDefined(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.fieldAlreadyDefined, ast));
    }

    void add_FieldIsNotDefined(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.fieldIsNotDefined, ast));
    }

    void add_BooleanExpressionRequired(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.booleanExpressionRequired, ast));
    }

    void add_ReadWriteRequireBasic(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.readWriteRequireBasic, ast));
    }

    void add_ReferenciableExpressionRequired(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.referenciableExpressionRequired, ast));
    }

    void add_IntegerIndexRequired(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.integerIndexRequired, ast));
    }

    void add_IdentIsNotProcedure(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.identIsNotProcedure, ast));
    }

    void add_IdentIsNotFunction(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.identIsNotFunction, ast));
    }

    void add_IncompatibleParameter(CL_AST ast, int n) {
        errors.add(new SemanticError(SemErrorCodes.incompatibleParameter, ast, n));
    }

    void add_NonReferenceableParameter(CL_AST ast, int n) {
        errors.add(new SemanticError(SemErrorCodes.nonReferenceableParameter, ast, n));
    }

    void add_IncorrectNumberOfParameters(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.incorrectNumberOfParameters, ast));
    }

    void add_IncompatibleReturnExpression(CL_AST ast) {
        errors.add(new SemanticError(SemErrorCodes.incompatibleReturnExpression, ast));
    }

    int getNumberOfSemanticErrors() {
        return errors.size();
    }

    public String toString() {
        String s = "";
        Collections.sort(errors);
        for (int i = 0; i < errors.size(); i++) {
            s += errors.get(i).toString() + "\n";
        }
        return s;
    }

}