SymTableVisitor.java

import java.util.LinkedHashMap;
import java.util.List;
import java.util.ArrayList;

import syntaxtree.*;
import visitor.GJDepthFirst;


/*This visitor is called first to add all identifiers to a symbol table*/
/*AND also checks for duplicated CLASSES and VARIABLES(in the same scope)*/
public class SymTableVisitor extends GJDepthFirst<String, Argu> {    

    public LinkedHashMap<String,ClassInfo> symbolTable= new LinkedHashMap<>();

    /*Helper Methods */
    
    //returns the current method from the MethodInfo list
    MethodInfo getCurrentMethod(String className, String methodName){
        List<MethodInfo> list = symbolTable.get(className).methods.get(methodName);
        return list.get(list.size() - 1);  // last added is the current one
    }



    /*MAIN CLASS */
/**
 * Grammar production:
 * f0 -> "class"
 * f1 -> Identifier()
 * f2 -> "{"
 * f3 -> "public"
 * f4 -> "static"
 * f5 -> "void"
 * f6 -> "main"
 * f7 -> "("
 * f8 -> "String"
 * f9 -> "["
 * f10 -> "]"
 * f11 -> Identifier()
 * f12 -> ")"
 * f13 -> "{"
 * f14 -> ( VarDeclaration() )*
 * f15 -> ( Statement() )*
 * f16 -> "}"
 * f17 -> "}"
 */

    @Override
    public String visit(MainClass mc, Argu argu){

        String classname=mc.f1.accept(this,null);
        ClassInfo cInfo= new ClassInfo(null);
        Argu argu2= new Argu(classname,"main");
        symbolTable.put(classname, cInfo);
        MethodInfo mainInfo=new MethodInfo("main", "void");

        List<MethodInfo> mainList=new ArrayList<>();
        mainList.add(mainInfo);

        cInfo.methods.put("main", mainList);
        mc.f14.accept(this,argu2);

        return null;
    }




    /*Class Declaration */
/**
 * Grammar production:
 * f0 -> "class"
 * f1 -> Identifier()
 * f2 -> "{"
 * f3 -> ( VarDeclaration() )*
 * f4 -> ( MethodDeclaration() )*
 * f5 -> "}"
 */
    @Override   
    public String visit(ClassDeclaration cd, Argu argu){
        
        String  classname=cd.f1.accept(this,null);
        // tries creates class with existing name
        if(symbolTable.containsKey(classname)){
            throw new RuntimeException("Class "+classname+" already exists");
        }
        ClassInfo cInfo = new ClassInfo(null);
        
        symbolTable.put(classname, cInfo);
        Argu argu2=new Argu(classname,null) ;

        cd.f3.accept(this,argu2);
        cd.f4.accept(this,argu2);


        return null;
    }




    /*CLASS EXTENDS DECLARATION */
/**
 * Grammar production:
 * f0 -> "class"
 * f1 -> Identifier()
 * f2 -> "extends"
 * f3 -> Identifier()
 * f4 -> "{"
 * f5 -> ( VarDeclaration() )*
 * f6 -> ( MethodDeclaration() )*
 * f7 -> "}"
 */
    @Override
    public String visit(ClassExtendsDeclaration ced, Argu argu){
        String classname=ced.f1.accept(this, null);
        String parentclassname=ced.f3.accept(this,null);

        
        //  creates class with existing name
        if( symbolTable.containsKey(classname)){
            throw new RuntimeException("Class "+classname+" already exists");
        }

        ClassInfo cInfo=new ClassInfo(parentclassname);

        Argu argu2=new Argu(classname,null);
        symbolTable.put(classname, cInfo);

        ced.f5.accept(this,argu2);
        ced.f6.accept(this,argu2);
        return null;
    }


    /*VAR DECLARATION */
    /**
 * Grammar production:
 * f0 -> Type()
 * f1 -> Identifier()
 * f2 -> ";"
 */
    @Override
    public String visit(VarDeclaration vd, Argu argu){
        String vartype=vd.f0.accept(this,null);
        String varname=vd.f1.accept(this,null);
        //so its just a class field
        if(argu.methodName==null){
            //already existing variable
            if (symbolTable.get(argu.className).vars.containsKey(varname)){
                throw new RuntimeException("Variable "+varname+" already exists");
            }
            symbolTable.get(argu.className).vars.put(varname, vartype);
        }
        //its in the method scope
        else{
            MethodInfo current= getCurrentMethod(argu.className,argu.methodName);
            if(current.vars.containsKey(varname)){
                throw new RuntimeException("Variable "+varname+" already exists");
            }
            //check formal params too( DoubleDeclaration1.java )
            if(current.formalParams.containsKey(varname)){
                throw new RuntimeException("Variable " + varname + " already exists as a parameter");
            }
            current.vars.put(varname,vartype);
        }
        
        return null;
    }


    /*METHOD DECLARATION */
/**
 * Grammar production:
 * f0 -> "public"
 * f1 -> Type()
 * f2 -> Identifier()
 * f3 -> "("
 * f4 -> ( FormalParameterList() )?
 * f5 -> ")"
 * f6 -> "{"
 * f7 -> ( VarDeclaration() )*
 * f8 -> ( Statement() )*
 * f9 -> "return"
 * f10 -> Expression()
 * f11 -> ";"
 * f12 -> "}"
 */

    @Override
    public String visit(MethodDeclaration md,Argu argu){
        
        String methodtype=md.f1.accept(this,null);
        String methodname=md.f2.accept(this,null);

        Argu argu2= new Argu(argu.className, methodname);
        MethodInfo mi= new MethodInfo(methodname, methodtype);
        if(!symbolTable.get(argu.className).methods.containsKey(methodname)){
            symbolTable.get(argu.className).methods.put(methodname, new ArrayList<>());
        }
        symbolTable.get(argu.className).methods.get(methodname).add(mi);
        md.f4.accept(this,argu2);
        md.f7.accept(this,argu2);

        return null;


    }
    

    /*FORMAL PARAMETER */
    /**
 * Grammar production:
 * f0 -> Type()
 * f1 -> Identifier()
 */

    @Override
    public String visit(FormalParameter fp,Argu argu){
        
        String formalparametertype=fp.f0.accept(this,null);
        String formalparametername=fp.f1.accept(this,null);
        if(getCurrentMethod(argu.className,argu.methodName).formalParams.containsKey(formalparametername)){
            throw new RuntimeException("Formal parameter "+formalparametername+ " already exists");
        }
        getCurrentMethod(argu.className, argu.methodName).formalParams.put(formalparametername, formalparametertype);
        return null;
    }
    
        /*TYPE */
        /**
         * Grammar production:
         * f0 -> ArrayType()
         *       | BooleanType()
         *       | IntegerType()
         *       | Identifier()
         */

    @Override
    public String visit(Type t, Argu argu){
        return t.f0.accept(this,null);
    }


    /*ARRAY TYPE */
    @Override 
    public String visit(ArrayType at, Argu argu){
        return "int[]";
    }

    
    /*BOOLEAN TYPE */
    @Override 
    public String visit(BooleanType bt, Argu argu){
        return "boolean";
    }

    
    /*INTEGER TYPE */
    @Override 
    public String visit(IntegerType it, Argu argu){
        return "int";
    }

    /*IDENTIFIER  */
    @Override
    public String visit(Identifier i, Argu argu){
        return i.f0.toString();
    }

}