-
Notifications
You must be signed in to change notification settings - Fork 0
/
semantics.h
163 lines (147 loc) · 6.22 KB
/
semantics.h
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
/**
* @file semantics.h
* Projekt: Implementace prekladace imperativniho jazyka IFJ21.
* @author Tadeas Vintrlik <xvintr04@stud.fit.vutbr.cz>
* @author Krystof Albrecht <xalbre05@stud.fit.vutbr.cz>
* @brief Header for semantic functions mostly for type checks.
*/
#ifndef _SEMANTICS_H_
#define _SEMANTICS_H_
#include "symtable.h"
#include "token_stack.h"
#include <stdio.h>
void print_unexpected_token(T_token *bad_token, token_type expected_type, char *expected_content);
/**
* @brief Check if token types are compatible. Integer is a subset of number.
*
* @param first First type.
* @param second Second type.
* @return true Token types are compatible.
* @return false Token types are not compatible.
*/
bool sem_check_type_compatible(symbol_type_e first, symbol_type_e second);
/**
* @brief Checks if function call has compatible paramaters.
*
* @note This function is usefull for checking of call parameters.
*
* @param[in] function The function token to check for parmeters.
* @param[in] call_params Stack with parameters of the call.
* @param[in] line Line of the call to generate a helpful error.
* @param[out] rc Return code to set.
*
* @return true All tokens have compatible types.
* @return false Some tokens don't have compatible type.
*/
bool sem_call_types_compatible(T_token *function, tstack_s *call_params, unsigned line, rc_e *rc);
/**
* @brief Check if called function was properly defined or declared.
*
* @param[in] token The input token to check if it was a defined or declared function.
* @param[in] symtable The symtable where to find the declaration or definition.
* @param[out] function The definition or declaration found in symtable.
* @param[out] rc Return code to set.
* @return true Function call was proper and the function name was decalred.
* @return false The function name was not declared.
*/
bool sem_check_call_function(T_token *token, symtable_s *symtable, T_token **function, rc_e *rc);
/**
* @brief Check if function was not redeclared.
*
* @param[in] token The token with the function name.
* @param[in] symtable The symtable where to check for redeclaration.
* @param[out] rc Return code to set.
* @return true Function was not redeclared.
* @return false Function was redeclared.
*/
bool sem_check_redecl(T_token *token, symtable_s *symtable, rc_e *rc);
/**
* @brief Check if function was not redefined.
*
* @param[in] token The token with the function name.
* @param[in] symtable The symtable where to check for redefinition.
* @param[out] function The function token found in symtable will contain declaration.
* @param[out] rc Return code to set.
* @return true The function was not redefined.
* @return false The function was redefined or defined after declaration (function->defined will be
* false, this return is not an error)
*/
bool sem_check_redef(T_token *token, symtable_s *symtable, T_token **function, rc_e *rc);
/**
* @brief Check if function declaration and definition parameter types match.
*
* @param[in] token The token with the fun_info from symtable.
* @param[in] in_params The stack of collected in parameters. WILL BE FREED IF MATCHING.
* @param[out] rc Return code to set.
* @return true The definition was ok.
* @return false The definition did not match the declaration.
*/
bool sem_check_decl_def_params(T_token *token, tstack_s *in_params, rc_e *rc);
/**
* @brief Check if function declaration and definition return types match.
*
* @param[in] token The token with the fun_info from symtable.
* @param[in] out_params The stack of collected return types. WILL BE FREED IF MATCHING.
* @param[out] rc Return code to set.
* @return true The definition was ok.
* @return false The definition did not match the declaration.
*/
bool sem_check_decl_def_returns(T_token *token, tstack_s *out_params, rc_e *rc);
/**
* @brief Check if identifier was declared.
*
* @param[in] token The identifier to check.
* @param[in] symtable The symtable where to find the identifier.
* @param[out] identifier The token found with this identifier.
* @param[out] rc Return code to set.
* @return true Identifier was declared
* @return false Identifier was not declared.
*/
bool sem_check_id_decl(T_token *token, symtable_s *symtable, T_token **identifier, rc_e *rc);
/**
* @brief Check if identifier is not being redeclared
*
* @param[in] token The identifier to check.
* @param[in] symtable The symtable where to find the identifier.
* @param[out] rc Return code to set.
* @return true The identifier was NOT being redecalred. OK.
* @return false The identifier was redeclared. ERROR.
*/
bool sem_check_id_redecl(T_token *token, symtable_s *symtable, rc_e *rc);
/**
* @brief Check if the expression passed to string length has correct type.
*
* @param[in] token The expression passed to string length.
* @param[out] rc Return code to set.
* @return true Called with correct expression.
* @return false Called with incorrect expression.
*/
bool sem_check_string_length(T_token *token, rc_e *rc);
/**
* @brief Check if two operand, one operator expression is semantically correct.
*
* @param[in] first First operand. Non-terminal.
* @param[in] second The operator.
* @param[in] third Second operand. Non-terminal. Type of this operand will be set to the type of
* the result.
* @param[out] rc Return code to set.
* @return true The expression was correct.
* @return false The expression was incorrect.
*/
bool sem_check_expr_type(T_token *first, T_token *second, T_token *third, rc_e *rc);
/**
* @brief Checks if it is semantically correct to assign from @p second to @p first. That means the
*following: 1) @p first is the same length or shorter than @p second 2) the types for each token
*are compatible number in @p first and integer in @p second are compatible as integer is a subset
*of number but the other way around is not legal.
*
* @param[in] first First stack. The variables to assign to.
* @param[in] second Second stack. The function out parameters.
* @param[in] line Line of the assignment to generate a helpful error.
* @param[out] rc Return code to set.
*
* @return true All tokens have the same type.
* @return false Some tokens don't have the same type.
*/
bool sem_check_call_assign(tstack_s *first, tstack_s *second, unsigned line, rc_e *rc);
#endif /* _SEMANTICS_H_ */