compilers-hw2/OffsetCalculator.java at main · theodoroug13/compilers-hw2 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

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

    public OffsetCalculator(LinkedHashMap<String,ClassInfo> symbolTable){
        this.symbolTable=symbolTable;
    }

    //Linked hashmap to preserve order
    //String:identifier, Integer:offset
    LinkedHashMap<String,Integer>fieldOffsets=new LinkedHashMap<>();
    HashMap<String,Integer>classFieldSize=new HashMap<>();


    LinkedHashMap<String,Integer>methodOffsets=new LinkedHashMap<>();
    HashMap<String,Integer>methodFieldSize=new HashMap<>();


    //helper that checks inheritance chain for overriden methods
    boolean methodInParents(String parentname, String methodname){
        if(parentname==null){
            return false;
        }
        if(symbolTable.get(parentname).methods.containsKey(methodname)){
            return true;
        }
        return methodInParents(symbolTable.get(parentname).parent, methodname);
    }


    // Calculate offsets of fields in each class
    // Ints-> 4bytes
    // Boolean-> 1 byte
    // Pointers-> 8bytes
    void fieldOffsetCalculator(){

        for(String classname:symbolTable.keySet()){

            //ignore MainClass
            if(symbolTable.get(classname).methods.containsKey("main")) {
                continue;
            }
            int offset=0;

            //check if class extends other class
            //if yes then add the parents offset to current offset
            String parentname=symbolTable.get(classname).parent;

            //continue offset from the parents offset
            //if parentname==null then the class extends the main class->offset=0
            if(parentname!=null){
                Integer parentSize=classFieldSize.get(parentname);
                if(parentSize!=null){
                    offset=classFieldSize.get(parentname).intValue();
                }
            }

            HashMap<String,String> varsMap=symbolTable.get(classname).vars;
            for(String fieldname:varsMap.keySet()){
                fieldOffsets.put(classname+"."+fieldname, offset);
                if(varsMap.get(fieldname).equals("int")){
                    offset+=4;
                }
                else if(varsMap.get(fieldname).equals("boolean")){
                    offset+=1;
                }
                else{
                    offset+=8;
                }
            }
            classFieldSize.put(classname,offset);

        }
    }


    //Methods-> 8bytes
    void methodOffsetCalculator(){

        for(String classname:symbolTable.keySet()){
            //ignore MainClass
            if(symbolTable.get(classname).methods.containsKey("main")) {
                continue;
            }
            int offset=0;

            //check if class extends other class
            //if yes then add the parents offset to current offset
            String parentname=symbolTable.get(classname).parent;
            if(parentname!=null){
                Integer parentSize=methodFieldSize.get(parentname);
                if(parentSize!=null){
                    offset=methodFieldSize.get(parentname).intValue();
                }
            }

            HashMap<String,List<MethodInfo>> methodsMap=symbolTable.get(classname).methods;
            for(String methodname: methodsMap.keySet()){

                //check for overriden methods to not give them new offset slot
                if(methodInParents(parentname, methodname)){
                    continue;
                }

                methodOffsets.put(classname+"."+methodname, offset);
                offset+=8;
            }
            methodFieldSize.put(classname,offset);

        }
    }

    void printOffsets(){
        for(String classname:symbolTable.keySet()){
            if(symbolTable.get(classname).methods.containsKey("main")){
                continue;
            }
            System.out.println("-----------Class "+classname+"-----------");
            System.out.println("--Variables---");
            for(Map.Entry<String, Integer> entry:fieldOffsets.entrySet()){
               if(entry.getKey().startsWith(classname + ".")){
                    System.out.println(entry.getKey() + " : " + entry.getValue());
                }
            }
            System.out.println("---Methods---");
            for(Map.Entry<String, Integer> entry : methodOffsets.entrySet()){
                if(entry.getKey().startsWith(classname + ".")){
                    System.out.println(entry.getKey() + " : " + entry.getValue());
                }
            }
        }
    }


}