Compiler_Design_And_Implementation_Project/SymbolTable.py at main · AlipourIm/Compiler_Design_And_Implementation_Project · 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
class SymbolTable:
    f = open("symbol_table.txt", "w")
    symbol_table = []
    keywords = ["if", "else", "void", "int", "repeat", "break", "until", "return", "endif"]

    def __init__(self):
        for keyword in SymbolTable.keywords:
            self.symbol_table.append(SymbolRecord(keyword, is_keyword=True))

        # put special symbol for output function which will handle PRINT
        self.symbol_table.append(SymbolRecord(lexeme = 'output', type_='void', address=-1, scope=0, var_arr_func='func', no_arg_cell=1, arg_type_list=[('int', 'var')]))

    @staticmethod
    def add_symbol(lexeme):
        for symbol_record in SymbolTable.symbol_table:
            if lexeme == symbol_record.lexeme:
                return symbol_record
        SymbolTable.symbol_table.append(SymbolRecord(lexeme))

    @staticmethod
    def declare_global_variable(lexeme, address, type_arg, scope, no_arg_cell=0):
        SymbolTable.symbol_table.append(
            SymbolRecord(lexeme=lexeme, address=address, type_=type_arg, scope=scope, no_arg_cell=no_arg_cell,
                         var_arr_func='array' if no_arg_cell else 'var'))

    @staticmethod
    def declare_local_variable(lexeme, offset, type_arg, scope, no_arg_cell=0):
        SymbolTable.symbol_table.append(
            SymbolRecord(lexeme=lexeme, offset=offset, type_=type_arg, scope=scope, no_arg_cell=no_arg_cell,
                         var_arr_func='array' if no_arg_cell else 'var'))

    @staticmethod
    def declare_param_variable(lexeme, offset, type_arg, scope, no_arg_cell=0):
        SymbolTable.symbol_table.append(
            SymbolRecord(lexeme=lexeme, offset=offset, type_=type_arg, scope=scope, no_arg_cell=no_arg_cell,
                         var_arr_func='array' if no_arg_cell else 'var', is_param=True))

    @staticmethod
    def declare_function(lexeme, type_arg, address):
        no_arg_cell = 0
        arg_type_list = []
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                symbol_record.type = type_arg
                symbol_record.no_arg_cell = no_arg_cell
                symbol_record.var_arr_func = 'func'
                symbol_record.address = address
                symbol_record.scope = 0
                symbol_record.arg_type_list = arg_type_list[::-1]
                return
            else:
                no_arg_cell += 1
                arg_type_list.append((symbol_record.type, symbol_record.var_arr_func))

    @staticmethod
    def pop_function_locals(lexeme):
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                return
            else:
                SymbolTable.symbol_table.pop()

    @staticmethod
    def is_global(lexeme):
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                return symbol_record.scope == 0

    @staticmethod
    def is_function(lexeme):
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                return symbol_record.var_arr_func == 'func'

    @staticmethod
    def exists(lexeme):
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                return True
        return False

    @staticmethod
    def find_function(lexeme):
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                return symbol_record.arg_type_list, symbol_record.address, symbol_record.lexeme, symbol_record.type
        return None

    @staticmethod
    def find_address(lexeme):
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                return [symbol_record.address, symbol_record.type, symbol_record.var_arr_func]
        return None

    @staticmethod
    def find_offset(lexeme):
        tmp_table = SymbolTable.symbol_table[::-1]
        for symbol_record in tmp_table:
            if symbol_record.lexeme == lexeme:
                return ['!' + str(symbol_record.offset), symbol_record.type, symbol_record.var_arr_func]
        return None

    @staticmethod
    def get_token_type(lexeme):  # ID or KEYWORD.
        return "KEYWORD" if (lexeme in SymbolTable.keywords) else "ID"

    @staticmethod
    def print_symbols():
        for i in range(len(SymbolTable.symbol_table)):
            SymbolTable.f.write(str(i + 1) + ".\t" + str(SymbolTable.symbol_table[i]) + "\n")

    @staticmethod
    def close_file():
        SymbolTable.f.close()


class SymbolRecord:
    def __init__(self, lexeme, is_keyword=False, address=None, type_=None, scope=None, var_arr_func=None,
                 no_arg_cell=None, offset=None, is_param=False, arg_type_list=[]):
        self.lexeme = lexeme
        self.is_keyword = is_keyword
        self.address = address
        self.type = type_
        self.scope = scope
        self.var_arr_func = var_arr_func
        self.no_arg_cell = no_arg_cell
        self.offset = offset
        self.is_param = is_param
        self.arg_type_list = arg_type_list

    def __str__(self):
        return f'lexeme: {self.lexeme}, isKeyword: {self.is_keyword}, address: {self.address}, offset: {self.offset}, ' \
               f'type: {self.type}, var_arr_func: {self.var_arr_func}, no_arg_cell: {self.no_arg_cell}, ' \
               f'scope: {self.scope} ' \
               f'arg_type_list: {self.arg_type_list}'