author | Edouard Tisserant |
Wed, 28 Nov 2012 11:52:03 +0900 | |
changeset 709 | bca119630cf6 |
parent 552 | 3c39d80fdede |
child 652 | 7fe1533d2260 |
permissions | -rwxr-xr-x |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1 |
/* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
2 |
* matiec - a compiler for the programming languages defined in IEC 61131-3 |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
3 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
4 |
* Copyright (C) 2009-2012 Mario de Sousa (msousa@fe.up.pt) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
5 |
* Copyright (C) 2012 Manuele Conti (manuele.conti@sirius-es.it) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
6 |
* Copyright (C) 2012 Matteo Facchinetti (matteo.facchinetti@sirius-es.it) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
7 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
8 |
* This program is free software: you can redistribute it and/or modify |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
9 |
* it under the terms of the GNU General Public License as published by |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
10 |
* the Free Software Foundation, either version 3 of the License, or |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
11 |
* (at your option) any later version. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
12 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
13 |
* This program is distributed in the hope that it will be useful, |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
16 |
* GNU General Public License for more details. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
17 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
18 |
* You should have received a copy of the GNU General Public License |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
19 |
* along with this program. If not, see <http://www.gnu.org/licenses/>. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
20 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
21 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
22 |
* This code is made available on the understanding that it will not be |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
23 |
* used in safety-critical situations without a full and competent review. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
24 |
*/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
25 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
26 |
/* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
27 |
* An IEC 61131-3 compiler. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
28 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
29 |
* Based on the |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
30 |
* FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
31 |
* |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
32 |
*/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
33 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
34 |
|
552 | 35 |
/* NOTE: The algorithm implemented here assumes that candidate datatype lists have already been filled! |
36 |
* BEFORE running this visitor, be sure to CALL the fill_candidate_datatype_c visitor! |
|
37 |
*/ |
|
38 |
||
39 |
||
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
40 |
/* |
552 | 41 |
* Choose, from the list of all the possible datatypes each expression may take, the single datatype that it will in fact take. |
42 |
* The resulting (chosen) datatype, will be stored in the symbol_c.datatype variable, leaving the candidate datatype list untouched! |
|
43 |
* |
|
44 |
* For rvalue expressions, this decision will be based on the datatype of the lvalue expression. |
|
45 |
* For lvalue expressions, the candidate datatype list should have a single entry. |
|
46 |
* |
|
47 |
* For example, the very simple literal '0' in 'foo := 0', may represent a: |
|
48 |
* BOOL, BYTE, WORD, DWORD, LWORD, USINT, SINT, UINT, INT, UDINT, DINT, ULINT, LINT (as well as the SAFE versions of these data tyes too!) |
|
49 |
* |
|
50 |
* In this class, the datatype of '0' will be set to the same datatype as the 'foo' variable. |
|
51 |
* If the intersection of the candidate datatype lists of the left and right side expressions is empty, |
|
52 |
* then a datatype error has been found, and the datatype is either left at NULL, or set to a pointer of an invalid_type_name_c object! |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
53 |
*/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
54 |
|
552 | 55 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
56 |
#include "narrow_candidate_datatypes.hh" |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
57 |
#include "datatype_functions.hh" |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
58 |
#include <typeinfo> |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
59 |
#include <list> |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
60 |
#include <string> |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
61 |
#include <string.h> |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
62 |
#include <strings.h> |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
63 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
64 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
65 |
/* set to 1 to see debug info during execution */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
66 |
static int debug = 0; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
67 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
68 |
narrow_candidate_datatypes_c::narrow_candidate_datatypes_c(symbol_c *ignore) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
69 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
70 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
71 |
narrow_candidate_datatypes_c::~narrow_candidate_datatypes_c(void) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
72 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
73 |
|
425
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
74 |
|
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
75 |
/* Only set the symbol's desired datatype to 'datatype' if that datatype is in the candidate_datatype list */ |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
76 |
static void set_datatype(symbol_c *datatype, symbol_c *symbol) { |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
77 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
78 |
/* If we are trying to set to the undefined type, and the symbol's datatype has already been set to something else, |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
79 |
* we abort the compoiler as I don't think this should ever occur. |
466
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
80 |
* NOTE: In order to handle JMPs to labels that come before the JMP itself, we run the narrow algorithm twice. |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
81 |
* This means that this situation may legally occur, so we cannot abort the compiler here! |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
82 |
*/ |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
83 |
// if ((NULL == datatype) && (NULL != symbol->datatype)) ERROR; |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
84 |
if ((NULL == datatype) && (NULL != symbol->datatype)) return; |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
85 |
if ((NULL == datatype) && (NULL == symbol->datatype)) return; |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
86 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
87 |
if (search_in_candidate_datatype_list(datatype, symbol->candidate_datatypes) < 0) |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
88 |
symbol->datatype = &(search_constant_type_c::invalid_type_name); |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
89 |
else { |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
90 |
if (NULL == symbol->datatype) |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
91 |
/* not yet set to anything, so we set it to the requested data type */ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
92 |
symbol->datatype = datatype; |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
93 |
else { |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
94 |
/* had already been set previously to some data type. Let's check if they are the same! */ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
95 |
if (!is_type_equal(symbol->datatype, datatype)) |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
96 |
symbol->datatype = &(search_constant_type_c::invalid_type_name); |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
97 |
// else |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
98 |
/* we leave it unchanged, as it is the same as the requested data type! */ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
99 |
} |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
100 |
} |
425
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
101 |
} |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
102 |
|
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
103 |
|
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
104 |
|
457
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
105 |
/* Only set the symbol's desired datatype to 'datatype' if that datatype is in the candidate_datatype list */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
106 |
// static void set_datatype_in_prev_il_instructions(symbol_c *datatype, std::vector <symbol_c *> prev_il_instructions) { |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
107 |
static void set_datatype_in_prev_il_instructions(symbol_c *datatype, il_instruction_c *symbol) { |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
108 |
if (NULL == symbol) ERROR; |
457
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
109 |
for (unsigned int i = 0; i < symbol->prev_il_instruction.size(); i++) |
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
110 |
set_datatype(datatype, symbol->prev_il_instruction[i]); |
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
111 |
} |
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
112 |
|
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
113 |
|
425
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
114 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
115 |
bool narrow_candidate_datatypes_c::is_widening_compatible(const struct widen_entry widen_table[], symbol_c *left_type, symbol_c *right_type, symbol_c *result_type, bool *deprecated_status) { |
515
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
116 |
/* NOTE: According to our algorithm, left_type and right_type should never by NULL (if they are, we have an internal compiler error! |
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
117 |
* However, result_type may be NULL if the code has a data type semantic error! |
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
118 |
*/ |
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
119 |
if ((NULL == left_type) || (NULL == right_type) || (NULL == result_type)) |
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
120 |
return false; |
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
121 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
122 |
for (int k = 0; NULL != widen_table[k].left; k++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
123 |
if ((typeid(*left_type) == typeid(*widen_table[k].left)) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
124 |
&& (typeid(*right_type) == typeid(*widen_table[k].right)) |
478
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
125 |
&& (typeid(*result_type) == typeid(*widen_table[k].result))) { |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
126 |
if (NULL != deprecated_status) |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
127 |
*deprecated_status = (widen_table[k].status == widen_entry::deprecated); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
128 |
return true; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
129 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
130 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
131 |
return false; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
132 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
133 |
|
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
134 |
/* |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
135 |
* All parameters being passed to the called function MUST be in the parameter list to which f_call points to! |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
136 |
* This means that, for non formal function calls in IL, de current (default value) must be artificially added to the |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
137 |
* beginning of the parameter list BEFORE calling handle_function_call(). |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
138 |
*/ |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
139 |
void narrow_candidate_datatypes_c::narrow_nonformal_call(symbol_c *f_call, symbol_c *f_decl, int *ext_parm_count) { |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
140 |
symbol_c *call_param_value, *param_type; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
141 |
identifier_c *param_name; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
142 |
function_param_iterator_c fp_iterator(f_decl); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
143 |
function_call_param_iterator_c fcp_iterator(f_call); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
144 |
int extensible_parameter_highest_index = -1; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
145 |
unsigned int i; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
146 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
147 |
if (NULL != ext_parm_count) *ext_parm_count = -1; |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
148 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
149 |
/* Iterating through the non-formal parameters of the function call */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
150 |
while((call_param_value = fcp_iterator.next_nf()) != NULL) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
151 |
/* Obtaining the type of the value being passed in the function call */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
152 |
/* Iterate to the next parameter of the function being called. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
153 |
* Get the name of that parameter, and ignore if EN or ENO. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
154 |
*/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
155 |
do { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
156 |
param_name = fp_iterator.next(); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
157 |
/* If there is no other parameter declared, then we are passing too many parameters... */ |
424
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
158 |
/* This error should have been caught in fill_candidate_datatypes_c, but may occur here again when we handle FB invocations! |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
159 |
* In this case, we carry on analysing the code in order to be able to provide relevant error messages |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
160 |
* for that code too! |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
161 |
*/ |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
162 |
if(param_name == NULL) break; |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
163 |
} while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0)); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
164 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
165 |
/* Set the desired datatype for this parameter, and call it recursively. */ |
424
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
166 |
/* Note that if the call has more parameters than those declared in the function/FB declaration, |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
167 |
* we may be setting this to NULL! |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
168 |
*/ |
425
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
169 |
symbol_c *desired_datatype = base_type(fp_iterator.param_type()); |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
170 |
if ((NULL != param_name) && (NULL == desired_datatype)) ERROR; |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
171 |
if ((NULL == param_name) && (NULL != desired_datatype)) ERROR; |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
172 |
|
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
173 |
/* NOTE: When we are handling a nonformal function call made from IL, the first parameter is the 'default' or 'current' |
451 | 174 |
* il value. However, a pointer to a copy of the prev_il_instruction is pre-pended into the operand list, so |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
175 |
* the call |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
176 |
* call_param_value->accept(*this); |
451 | 177 |
* may actually be calling an object of the base symbol_c . |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
178 |
*/ |
425
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
179 |
set_datatype(desired_datatype, call_param_value); |
451 | 180 |
call_param_value->accept(*this); |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
181 |
|
424
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
182 |
if (NULL != param_name) |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
183 |
if (extensible_parameter_highest_index < fp_iterator.extensible_param_index()) |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
184 |
extensible_parameter_highest_index = fp_iterator.extensible_param_index(); |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
185 |
} |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
186 |
/* In the case of a call to an extensible function, we store the highest index |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
187 |
* of the extensible parameters this particular call uses, in the symbol_c object |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
188 |
* of the function call itself! |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
189 |
* In calls to non-extensible functions, this value will be set to -1. |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
190 |
* This information is later used in stage4 to correctly generate the |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
191 |
* output code. |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
192 |
*/ |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
193 |
if ((NULL != ext_parm_count) && (extensible_parameter_highest_index >=0) /* if call to extensible function */) |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
194 |
*ext_parm_count = 1 + extensible_parameter_highest_index - fp_iterator.first_extensible_param_index(); |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
195 |
} |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
196 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
197 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
198 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
199 |
void narrow_candidate_datatypes_c::narrow_formal_call(symbol_c *f_call, symbol_c *f_decl, int *ext_parm_count) { |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
200 |
symbol_c *call_param_value, *call_param_name, *param_type; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
201 |
symbol_c *verify_duplicate_param; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
202 |
identifier_c *param_name; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
203 |
function_param_iterator_c fp_iterator(f_decl); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
204 |
function_call_param_iterator_c fcp_iterator(f_call); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
205 |
int extensible_parameter_highest_index = -1; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
206 |
identifier_c *extensible_parameter_name; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
207 |
unsigned int i; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
208 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
209 |
if (NULL != ext_parm_count) *ext_parm_count = -1; |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
210 |
/* Iterating through the formal parameters of the function call */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
211 |
while((call_param_name = fcp_iterator.next_f()) != NULL) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
212 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
213 |
/* Obtaining the value being passed in the function call */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
214 |
call_param_value = fcp_iterator.get_current_value(); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
215 |
/* the following should never occur. If it does, then we have a bug in our code... */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
216 |
if (NULL == call_param_value) ERROR; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
217 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
218 |
/* Find the corresponding parameter in function declaration */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
219 |
param_name = fp_iterator.search(call_param_name); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
220 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
221 |
/* Set the desired datatype for this parameter, and call it recursively. */ |
424
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
222 |
/* NOTE: When handling a FB call, this narrow_formal_call() may be called to analyse |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
223 |
* an invalid FB call (call with parameters that do not exist on the FB declaration). |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
224 |
* For this reason, the param_name may come out as NULL! |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
225 |
*/ |
425
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
226 |
symbol_c *desired_datatype = base_type(fp_iterator.param_type()); |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
227 |
if ((NULL != param_name) && (NULL == desired_datatype)) ERROR; |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
228 |
if ((NULL == param_name) && (NULL != desired_datatype)) ERROR; |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
229 |
|
450
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
230 |
/* set the desired data type for this parameter */ |
425
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
231 |
set_datatype(desired_datatype, call_param_value); |
450
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
232 |
/* And recursively call that parameter/expression, so it can propagate that info */ |
451 | 233 |
call_param_value->accept(*this); |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
234 |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
235 |
/* set the extensible_parameter_highest_index, which will be needed in stage 4 */ |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
236 |
/* This value says how many extensible parameters are being passed to the standard function */ |
424
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
237 |
if (NULL != param_name) |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
238 |
if (extensible_parameter_highest_index < fp_iterator.extensible_param_index()) |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
239 |
extensible_parameter_highest_index = fp_iterator.extensible_param_index(); |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
240 |
} |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
241 |
/* call is compatible! */ |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
242 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
243 |
/* In the case of a call to an extensible function, we store the highest index |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
244 |
* of the extensible parameters this particular call uses, in the symbol_c object |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
245 |
* of the function call itself! |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
246 |
* In calls to non-extensible functions, this value will be set to -1. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
247 |
* This information is later used in stage4 to correctly generate the |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
248 |
* output code. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
249 |
*/ |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
250 |
if ((NULL != ext_parm_count) && (extensible_parameter_highest_index >=0) /* if call to extensible function */) |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
251 |
*ext_parm_count = 1 + extensible_parameter_highest_index - fp_iterator.first_extensible_param_index(); |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
252 |
} |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
253 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
254 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
255 |
/* |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
256 |
typedef struct { |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
257 |
symbol_c *function_name, |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
258 |
symbol_c *nonformal_operand_list, |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
259 |
symbol_c * formal_operand_list, |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
260 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
261 |
std::vector <symbol_c *> &candidate_functions, |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
262 |
symbol_c &*called_function_declaration, |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
263 |
int &extensible_param_count |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
264 |
} generic_function_call_t; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
265 |
*/ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
266 |
void narrow_candidate_datatypes_c::narrow_function_invocation(symbol_c *fcall, generic_function_call_t fcall_data) { |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
267 |
/* set the called_function_declaration. */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
268 |
fcall_data.called_function_declaration = NULL; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
269 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
270 |
/* set the called_function_declaration taking into account the datatype that we need to return */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
271 |
for(unsigned int i = 0; i < fcall->candidate_datatypes.size(); i++) { |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
272 |
if (is_type_equal(fcall->candidate_datatypes[i], fcall->datatype)) { |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
273 |
fcall_data.called_function_declaration = fcall_data.candidate_functions[i]; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
274 |
break; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
275 |
} |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
276 |
} |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
277 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
278 |
/* NOTE: If we can't figure out the declaration of the function being called, this is not |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
279 |
* necessarily an internal compiler error. It could be because the symbol->datatype is NULL |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
280 |
* (because the ST code being analysed has an error _before_ this function invocation). |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
281 |
* However, we don't just give, up, we carry on recursivly analysing the code, so as to be |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
282 |
* able to print out any error messages related to the parameters being passed in this function |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
283 |
* invocation. |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
284 |
*/ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
285 |
/* if (NULL == symbol->called_function_declaration) ERROR; */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
286 |
if (fcall->candidate_datatypes.size() == 1) { |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
287 |
/* If only one function declaration, then we use that (even if symbol->datatypes == NULL) |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
288 |
* so we can check for errors in the expressions used to pass parameters in this |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
289 |
* function invocation. |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
290 |
*/ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
291 |
fcall_data.called_function_declaration = fcall_data.candidate_functions[0]; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
292 |
} |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
293 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
294 |
/* If an overloaded function is being invoked, and we cannot determine which version to use, |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
295 |
* then we can not meaningfully verify the expressions used inside that function invocation. |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
296 |
* We simply give up! |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
297 |
*/ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
298 |
if (NULL == fcall_data.called_function_declaration) |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
299 |
return; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
300 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
301 |
if (NULL != fcall_data.nonformal_operand_list) narrow_nonformal_call(fcall, fcall_data.called_function_declaration, &(fcall_data.extensible_param_count)); |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
302 |
if (NULL != fcall_data. formal_operand_list) narrow_formal_call(fcall, fcall_data.called_function_declaration, &(fcall_data.extensible_param_count)); |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
303 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
304 |
return; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
305 |
} |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
306 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
307 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
308 |
|
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
309 |
|
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
310 |
/* narrow implicit FB call in IL. |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
311 |
* e.g. CLK ton_var |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
312 |
* CU counter_var |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
313 |
* |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
314 |
* The algorithm will be to build a fake il_fb_call_c equivalent to the implicit IL FB call, and let |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
315 |
* the visit(il_fb_call_c *) method handle it! |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
316 |
*/ |
456 | 317 |
void *narrow_candidate_datatypes_c::narrow_implicit_il_fb_call(symbol_c *il_instruction, const char *param_name, symbol_c *&called_fb_declaration) { |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
318 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
319 |
/* set the datatype of the il_operand, this is, the FB being called! */ |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
320 |
if (NULL != il_operand) { |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
321 |
/* only set it if it is in the candidate datatypes list! */ |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
322 |
set_datatype(called_fb_declaration, il_operand); |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
323 |
il_operand->accept(*this); |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
324 |
} |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
325 |
symbol_c *fb_decl = il_operand->datatype; |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
326 |
|
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
327 |
if (0 == fake_prev_il_instruction->prev_il_instruction.size()) { |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
328 |
/* This IL implicit FB call (e.g. CLK ton_var) is not preceded by another IL instruction |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
329 |
* (or list of instructions) that will set the IL current/default value. |
451 | 330 |
* We cannot proceed verifying type compatibility of something that does not exist. |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
331 |
*/ |
456 | 332 |
return NULL; |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
333 |
} |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
334 |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
335 |
if (NULL == fb_decl) { |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
336 |
/* the il_operand is a not FB instance */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
337 |
/* so we simply pass on the required datatype to the prev_il_instructions */ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
338 |
/* The invalid FB invocation will be caught in the print_datatypes_error_c by analysing NULL value in il_operand->datatype! */ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
339 |
set_datatype_in_prev_il_instructions(il_instruction->datatype, fake_prev_il_instruction); |
456 | 340 |
return NULL; |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
341 |
} |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
342 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
343 |
|
451 | 344 |
/* The value being passed to the 'param_name' parameter is actually the prev_il_instruction. |
345 |
* However, we do not place that object directly in the fake il_param_list_c that we will be |
|
346 |
* creating, since the visit(il_fb_call_c *) method will recursively call every object in that list. |
|
347 |
* The il_prev_intruction object will be visited once we have handled this implici IL FB call |
|
348 |
* (called from the instruction_list_c for() loop that works backwards). We DO NOT want to visit it twice. |
|
349 |
* (Anyway, if we let the visit(il_fb_call_c *) recursively visit the current prev_il_instruction, this pointer |
|
350 |
* would be changed to the IL instruction coming before the current prev_il_instruction! => things would get all messed up!) |
|
351 |
* The easiest way to work around this is to simply use a new object, and copy the relevant details to that object! |
|
352 |
*/ |
|
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
353 |
symbol_c param_value = *fake_prev_il_instruction; /* copy the candidate_datatypes list ! */ |
461
fcbc0927fc96
Remove spurious printf()s, used during debugging session.
Mario de Sousa <msousa@fe.up.pt>
parents:
459
diff
changeset
|
354 |
|
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
355 |
identifier_c variable_name(param_name); |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
356 |
// SYM_REF1(il_assign_operator_c, variable_name) |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
357 |
il_assign_operator_c il_assign_operator(&variable_name); |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
358 |
// SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list) |
451 | 359 |
il_param_assignment_c il_param_assignment(&il_assign_operator, ¶m_value/*il_operand*/, NULL); |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
360 |
il_param_list_c il_param_list; |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
361 |
il_param_list.add_element(&il_param_assignment); |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
362 |
// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list, symbol_c *called_fb_declaration) |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
363 |
CAL_operator_c CAL_operator; |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
364 |
il_fb_call_c il_fb_call(&CAL_operator, il_operand, NULL, &il_param_list); |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
365 |
|
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
366 |
/* A FB call does not return any datatype, but the IL instructions that come after this |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
367 |
* FB call may require a specific datatype in the il current/default variable, |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
368 |
* so we must pass this information up to the IL instruction before the FB call, since it will |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
369 |
* be that IL instruction that will be required to produce the desired dtataype. |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
370 |
* |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
371 |
* The above will be done by the visit(il_fb_call_c *) method, so we must make sure to |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
372 |
* correctly set up the il_fb_call.datatype variable! |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
373 |
*/ |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
374 |
il_fb_call.called_fb_declaration = called_fb_declaration; |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
375 |
il_fb_call.accept(*this); |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
376 |
|
451 | 377 |
/* set the required datatype of the previous IL instruction! */ |
378 |
/* NOTE: |
|
379 |
* When handling these implicit IL calls, the parameter_value being passed to the FB parameter |
|
380 |
* is actually the prev_il_instruction. |
|
381 |
* |
|
382 |
* However, since the FB call does not change the value in the current/default IL variable, this value |
|
383 |
* must also be used ny the IL instruction coming after this FB call. |
|
384 |
* |
|
385 |
* This means that we have two consumers/users for the same value. |
|
386 |
* We must therefore check whether the datatype required by the IL instructions following this FB call |
|
387 |
* is the same as that required for the first parameter. If not, then we have a semantic error, |
|
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
388 |
* and we set it to invalid_type_name. |
451 | 389 |
* |
390 |
* However, we only do that if: |
|
391 |
* - The IL instruction that comes after this IL FB call actually asked this FB call for a specific |
|
392 |
* datatype in the current/default vairable, once this IL FB call returns. |
|
393 |
* However, sometimes, (for e.g., this FB call is the last in the IL list) the subsequent FB to not aks this |
|
394 |
* FB call for any datatype. In that case, then the datatype required to pass to the first parameter of the |
|
395 |
* FB call must be left unchanged! |
|
396 |
*/ |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
397 |
if ((NULL == il_instruction->datatype) || (is_type_equal(param_value.datatype, il_instruction->datatype))) { |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
398 |
set_datatype_in_prev_il_instructions(param_value.datatype, fake_prev_il_instruction); |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
399 |
} else { |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
400 |
set_datatype_in_prev_il_instructions(&search_constant_type_c::invalid_type_name, fake_prev_il_instruction); |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
401 |
} |
456 | 402 |
return NULL; |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
403 |
} |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
404 |
|
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
405 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
406 |
/* a helper function... */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
407 |
symbol_c *narrow_candidate_datatypes_c::base_type(symbol_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
408 |
/* NOTE: symbol == NULL is valid. It will occur when, for e.g., an undefined/undeclared symbolic_variable is used |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
409 |
* in the code. |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
410 |
*/ |
423
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
411 |
if (symbol == NULL) return NULL; |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
412 |
return (symbol_c *)symbol->accept(search_base_type); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
413 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
414 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
415 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
416 |
/* B 1.2 - Constants */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
417 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
418 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
419 |
/**********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
420 |
/* B 1.3 - Data types */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
421 |
/**********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
422 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
423 |
/* B 1.3.3 - Derived data types */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
424 |
/********************************/ |
502
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
425 |
/* simple_specification ASSIGN constant */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
426 |
// SYM_REF2(simple_spec_init_c, simple_specification, constant) |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
427 |
void *narrow_candidate_datatypes_c::visit(simple_spec_init_c *symbol) { |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
428 |
if (symbol->candidate_datatypes.size() == 1) |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
429 |
symbol->datatype = symbol->candidate_datatypes[0]; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
430 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
431 |
if (symbol->simple_specification->candidate_datatypes.size() == 1) |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
432 |
symbol->simple_specification->datatype = symbol->simple_specification->candidate_datatypes[0]; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
433 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
434 |
if (NULL != symbol->constant) { |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
435 |
set_datatype(symbol->datatype, symbol->constant); |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
436 |
symbol->constant->accept(*this); |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
437 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
438 |
return NULL; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
439 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
440 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
441 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
442 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
443 |
/* signed_integer DOTDOT signed_integer */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
444 |
// SYM_REF2(subrange_c, lower_limit, upper_limit) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
445 |
void *narrow_candidate_datatypes_c::visit(subrange_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
446 |
symbol->lower_limit->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
447 |
symbol->lower_limit->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
448 |
symbol->upper_limit->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
449 |
symbol->upper_limit->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
450 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
451 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
452 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
453 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
454 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
455 |
/* B 1.4 - Variables */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
456 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
457 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
458 |
/********************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
459 |
/* B 1.4.1 - Directly Represented Variables */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
460 |
/********************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
461 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
462 |
/*************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
463 |
/* B 1.4.2 - Multi-element variables */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
464 |
/*************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
465 |
/* subscripted_variable '[' subscript_list ']' */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
466 |
// SYM_REF2(array_variable_c, subscripted_variable, subscript_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
467 |
void *narrow_candidate_datatypes_c::visit(array_variable_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
468 |
/* we need to check the data types of the expressions used for the subscripts... */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
469 |
symbol->subscript_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
470 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
471 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
472 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
473 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
474 |
/* subscript_list ',' subscript */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
475 |
// SYM_LIST(subscript_list_c) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
476 |
void *narrow_candidate_datatypes_c::visit(subscript_list_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
477 |
for (int i = 0; i < symbol->n; i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
478 |
for (unsigned int k = 0; k < symbol->elements[i]->candidate_datatypes.size(); k++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
479 |
if (is_ANY_INT_type(symbol->elements[i]->candidate_datatypes[k])) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
480 |
symbol->elements[i]->datatype = symbol->elements[i]->candidate_datatypes[k]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
481 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
482 |
symbol->elements[i]->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
483 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
484 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
485 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
486 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
487 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
488 |
|
502
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
489 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
490 |
/******************************************/ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
491 |
/* B 1.4.3 - Declaration & Initialisation */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
492 |
/******************************************/ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
493 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
494 |
void *narrow_candidate_datatypes_c::visit(var1_list_c *symbol) { |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
495 |
#if 0 /* We don't really need to set the datatype of each variable. We just check the declaration itself! */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
496 |
for(int i = 0; i < symbol->n; i++) { |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
497 |
if (symbol->elements[i]->candidate_datatypes.size() == 1) |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
498 |
symbol->elements[i]->datatype = symbol->elements[i]->candidate_datatypes[0]; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
499 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
500 |
#endif |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
501 |
return NULL; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
502 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
503 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
504 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
505 |
/* AT direct_variable */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
506 |
// SYM_REF1(location_c, direct_variable) |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
507 |
void *narrow_candidate_datatypes_c::visit(location_c *symbol) { |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
508 |
set_datatype(symbol->datatype, symbol->direct_variable); |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
509 |
symbol->direct_variable->accept(*this); /* currently does nothing! */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
510 |
return NULL; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
511 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
512 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
513 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
514 |
/* [variable_name] location ':' located_var_spec_init */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
515 |
/* variable_name -> may be NULL ! */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
516 |
// SYM_REF3(located_var_decl_c, variable_name, location, located_var_spec_init) |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
517 |
void *narrow_candidate_datatypes_c::visit(located_var_decl_c *symbol) { |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
518 |
/* let the var_spec_init set its own symbol->datatype value */ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
519 |
symbol->located_var_spec_init->accept(*this); |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
520 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
521 |
if (NULL != symbol->variable_name) |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
522 |
set_datatype(symbol->located_var_spec_init->datatype, symbol->variable_name); |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
523 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
524 |
set_datatype(symbol->located_var_spec_init->datatype, symbol->location); |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
525 |
symbol->location->accept(*this); |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
526 |
return NULL; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
527 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
528 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
529 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
530 |
/************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
531 |
/* B 1.5 Program organization units */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
532 |
/************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
533 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
534 |
/* B 1.5.1 Functions */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
535 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
536 |
void *narrow_candidate_datatypes_c::visit(function_declaration_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
537 |
search_varfb_instance_type = new search_varfb_instance_type_c(symbol); |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
538 |
symbol->var_declarations_list->accept(*this); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
539 |
if (debug) printf("Narrowing candidate data types list in body of function %s\n", ((token_c *)(symbol->derived_function_name))->value); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
540 |
symbol->function_body->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
541 |
delete search_varfb_instance_type; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
542 |
search_varfb_instance_type = NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
543 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
544 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
545 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
546 |
/***************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
547 |
/* B 1.5.2 Function blocks */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
548 |
/***************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
549 |
void *narrow_candidate_datatypes_c::visit(function_block_declaration_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
550 |
search_varfb_instance_type = new search_varfb_instance_type_c(symbol); |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
551 |
symbol->var_declarations->accept(*this); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
552 |
if (debug) printf("Narrowing candidate data types list in body of FB %s\n", ((token_c *)(symbol->fblock_name))->value); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
553 |
symbol->fblock_body->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
554 |
delete search_varfb_instance_type; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
555 |
search_varfb_instance_type = NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
556 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
557 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
558 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
559 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
560 |
/* B 1.5.3 Programs */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
561 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
562 |
void *narrow_candidate_datatypes_c::visit(program_declaration_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
563 |
search_varfb_instance_type = new search_varfb_instance_type_c(symbol); |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
564 |
symbol->var_declarations->accept(*this); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
565 |
if (debug) printf("Narrowing candidate data types list in body of program %s\n", ((token_c *)(symbol->program_type_name))->value); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
566 |
symbol->function_block_body->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
567 |
delete search_varfb_instance_type; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
568 |
search_varfb_instance_type = NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
569 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
570 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
571 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
572 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
573 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
574 |
/* B 1.7 Configuration elements */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
575 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
576 |
void *narrow_candidate_datatypes_c::visit(configuration_declaration_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
577 |
// TODO !!! |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
578 |
/* for the moment we must return NULL so semantic analysis of remaining code is not interrupted! */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
579 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
580 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
581 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
582 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
583 |
/****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
584 |
/* B.2 - Language IL (Instruction List) */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
585 |
/****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
586 |
/***********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
587 |
/* B 2.1 Instructions and Operands */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
588 |
/***********************************/ |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
589 |
|
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
590 |
/*| instruction_list il_instruction */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
591 |
// SYM_LIST(instruction_list_c) |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
592 |
void *narrow_candidate_datatypes_c::visit(instruction_list_c *symbol) { |
450
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
593 |
/* In order to execute the narrow algoritm correctly, we need to go through the instructions backwards, |
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
594 |
* so we can not use the base class' visitor |
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
595 |
*/ |
466
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
596 |
/* In order to execute the narrow algoritm correctly |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
597 |
* in IL instruction lists containing JMPs to labels that come before the JMP instruction |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
598 |
* itself, we need to run the narrow algorithm twice on the Instruction List. |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
599 |
* e.g.: ... |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
600 |
* ld 23 |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
601 |
* label1:st byte_var |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
602 |
* ld 34 |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
603 |
* JMP label1 |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
604 |
* |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
605 |
* Note that the second time we run the narrow, most of the datatypes are already filled |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
606 |
* in, so it will be able to produce tha correct datatypes for the IL instruction referenced |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
607 |
* by the label, as in the 2nd pass we already know the datatypes of the JMP instruction! |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
608 |
*/ |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
609 |
for(int j = 0; j < 2; j++) { |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
610 |
for(int i = symbol->n-1; i >= 0; i--) { |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
611 |
symbol->elements[i]->accept(*this); |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
612 |
} |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
613 |
} |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
614 |
return NULL; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
615 |
} |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
616 |
|
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
617 |
/* | label ':' [il_incomplete_instruction] eol_list */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
618 |
// SYM_REF2(il_instruction_c, label, il_instruction) |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
619 |
// void *visit(instruction_list_c *symbol); |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
620 |
void *narrow_candidate_datatypes_c::visit(il_instruction_c *symbol) { |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
621 |
if (NULL == symbol->il_instruction) { |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
622 |
/* this empty/null il_instruction cannot generate the desired datatype. We pass on the request to the previous il instruction. */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
623 |
set_datatype_in_prev_il_instructions(symbol->datatype, symbol); |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
624 |
} else { |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
625 |
il_instruction_c tmp_prev_il_instruction(NULL, NULL); |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
626 |
/* the narrow algorithm will need access to the intersected candidate_datatype lists of all prev_il_instructions, as well as the |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
627 |
* list of the prev_il_instructions. |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
628 |
* Instead of creating two 'global' (within the class) variables, we create a single il_instruction_c variable (fake_prev_il_instruction), |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
629 |
* and shove that data into this single variable. |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
630 |
*/ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
631 |
tmp_prev_il_instruction.prev_il_instruction = symbol->prev_il_instruction; |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
632 |
intersect_prev_candidate_datatype_lists(&tmp_prev_il_instruction); |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
633 |
/* Tell the il_instruction the datatype that it must generate - this was chosen by the next il_instruction (remember: we are iterating backwards!) */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
634 |
fake_prev_il_instruction = &tmp_prev_il_instruction; |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
635 |
symbol->il_instruction->datatype = symbol->datatype; |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
636 |
symbol->il_instruction->accept(*this); |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
637 |
fake_prev_il_instruction = NULL; |
450
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
638 |
} |
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
639 |
return NULL; |
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
640 |
} |
444
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
641 |
|
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
642 |
|
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
643 |
|
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
644 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
645 |
// void *visit(instruction_list_c *symbol); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
646 |
void *narrow_candidate_datatypes_c::visit(il_simple_operation_c *symbol) { |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
647 |
/* Tell the il_simple_operator the datatype that it must generate - this was chosen by the next il_instruction (we iterate backwards!) */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
648 |
symbol->il_simple_operator->datatype = symbol->datatype; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
649 |
/* recursive call to see whether data types are compatible */ |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
650 |
il_operand = symbol->il_operand; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
651 |
symbol->il_simple_operator->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
652 |
il_operand = NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
653 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
654 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
655 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
656 |
/* | function_name [il_operand_list] */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
657 |
/* NOTE: The parameters 'called_function_declaration' and 'extensible_param_count' are used to pass data between the stage 3 and stage 4. */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
658 |
// SYM_REF2(il_function_call_c, function_name, il_operand_list, symbol_c *called_function_declaration; int extensible_param_count;) |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
659 |
void *narrow_candidate_datatypes_c::visit(il_function_call_c *symbol) { |
451 | 660 |
/* The first parameter of a non formal function call in IL will be the 'current value' (i.e. the prev_il_instruction) |
661 |
* In order to be able to handle this without coding special cases, we will simply prepend that symbol |
|
662 |
* to the il_operand_list, and remove it after calling handle_function_call(). |
|
663 |
* However, since handle_function_call() will be recursively calling all parameter, and we don't want |
|
664 |
* to do that for the prev_il_instruction (since it has already been visited by the fill_candidate_datatypes_c) |
|
665 |
* we create a new ____ symbol_c ____ object, and copy the relevant info to/from that object before/after |
|
666 |
* the call to handle_function_call(). |
|
667 |
* |
|
668 |
* However, if no further paramters are given, then il_operand_list will be NULL, and we will |
|
669 |
* need to create a new object to hold the pointer to prev_il_instruction. |
|
534 | 670 |
* This change will also be undone at the end of this method. |
451 | 671 |
*/ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
672 |
symbol_c param_value = *fake_prev_il_instruction; /* copy the candidate_datatypes list */ |
451 | 673 |
if (NULL == symbol->il_operand_list) symbol->il_operand_list = new il_operand_list_c; |
674 |
if (NULL == symbol->il_operand_list) ERROR; |
|
675 |
||
676 |
((list_c *)symbol->il_operand_list)->insert_element(¶m_value, 0); |
|
677 |
||
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
678 |
generic_function_call_t fcall_param = { |
441
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
679 |
/* fcall_param.function_name = */ symbol->function_name, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
680 |
/* fcall_param.nonformal_operand_list = */ symbol->il_operand_list, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
681 |
/* fcall_param.formal_operand_list = */ NULL, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
682 |
/* enum {POU_FB, POU_function} POU_type = */ generic_function_call_t::POU_function, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
683 |
/* fcall_param.candidate_functions = */ symbol->candidate_functions, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
684 |
/* fcall_param.called_function_declaration = */ symbol->called_function_declaration, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
685 |
/* fcall_param.extensible_param_count = */ symbol->extensible_param_count |
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
686 |
}; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
687 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
688 |
narrow_function_invocation(symbol, fcall_param); |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
689 |
set_datatype_in_prev_il_instructions(param_value.datatype, fake_prev_il_instruction); |
451 | 690 |
|
691 |
/* Undo the changes to the abstract syntax tree we made above... */ |
|
692 |
((list_c *)symbol->il_operand_list)->remove_element(0); |
|
693 |
if (((list_c *)symbol->il_operand_list)->n == 0) { |
|
694 |
/* if the list becomes empty, then that means that it did not exist before we made these changes, so we delete it! */ |
|
695 |
delete symbol->il_operand_list; |
|
696 |
symbol->il_operand_list = NULL; |
|
697 |
} |
|
698 |
||
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
699 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
700 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
701 |
|
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
702 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
703 |
/* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
704 |
// SYM_REF3(il_expression_c, il_expr_operator, il_operand, simple_instr_list); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
705 |
void *narrow_candidate_datatypes_c::visit(il_expression_c *symbol) { |
453
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
706 |
/* first handle the operation (il_expr_operator) that will use the result coming from the parenthesised IL list (i.e. simple_instr_list) */ |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
707 |
symbol->il_expr_operator->datatype = symbol->datatype; |
454
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
708 |
il_operand = symbol->simple_instr_list; /* This is not a bug! The parenthesised expression will be used as the operator! */ |
453
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
709 |
symbol->il_expr_operator->accept(*this); |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
710 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
711 |
/* now give the parenthesised IL list a chance to narrow the datatypes */ |
454
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
712 |
/* The datatype that is must return was set by the call symbol->il_expr_operator->accept(*this) */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
713 |
il_instruction_c *save_fake_prev_il_instruction = fake_prev_il_instruction; /*this is not really necessary, but lets play it safe */ |
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
714 |
symbol->simple_instr_list->accept(*this); |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
715 |
fake_prev_il_instruction = save_fake_prev_il_instruction; |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
716 |
return NULL; |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
717 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
718 |
|
456 | 719 |
|
466
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
720 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
721 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
722 |
/* il_jump_operator label */ |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
723 |
void *narrow_candidate_datatypes_c::visit(il_jump_operation_c *symbol) { |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
724 |
/* recursive call to fill the datatype */ |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
725 |
symbol->il_jump_operator->datatype = symbol->datatype; |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
726 |
symbol->il_jump_operator->accept(*this); |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
727 |
return NULL; |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
728 |
} |
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
729 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
730 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
731 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
732 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
733 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
734 |
|
d97a29b7fa8b
Narrow IL lists twice, in order to handle JMP to labels before the JMP itself.
Mario de Sousa <msousa@fe.up.pt>
parents:
461
diff
changeset
|
735 |
|
439
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
736 |
/* il_call_operator prev_declared_fb_name |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
737 |
* | il_call_operator prev_declared_fb_name '(' ')' |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
738 |
* | il_call_operator prev_declared_fb_name '(' eol_list ')' |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
739 |
* | il_call_operator prev_declared_fb_name '(' il_operand_list ')' |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
740 |
* | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')' |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
741 |
*/ |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
742 |
/* NOTE: The parameter 'called_fb_declaration'is used to pass data between stage 3 and stage4 (although currently it is not used in stage 4 */ |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
743 |
// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list, symbol_c *called_fb_declaration) |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
744 |
void *narrow_candidate_datatypes_c::visit(il_fb_call_c *symbol) { |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
745 |
symbol_c *fb_decl = symbol->called_fb_declaration; |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
746 |
|
439
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
747 |
/* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */ |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
748 |
if (NULL == fb_decl) ERROR; |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
749 |
if (NULL != symbol->il_operand_list) narrow_nonformal_call(symbol, fb_decl); |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
750 |
if (NULL != symbol-> il_param_list) narrow_formal_call(symbol, fb_decl); |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
751 |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
752 |
/* Let the il_call_operator (CAL, CALC, or CALCN) set the datatype of prev_il_instruction... */ |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
753 |
symbol->il_call_operator->datatype = symbol->datatype; |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
754 |
symbol->il_call_operator->accept(*this); |
439
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
755 |
return NULL; |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
756 |
} |
cf7d6862033d
Add semantic verification of FB calls in IL (not yet complete - missing printing of errors!)
Mario de Sousa <msousa@fe.up.pt>
parents:
438
diff
changeset
|
757 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
758 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
759 |
/* | function_name '(' eol_list [il_param_list] ')' */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
760 |
/* NOTE: The parameter 'called_function_declaration' is used to pass data between the stage 3 and stage 4. */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
761 |
// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list, symbol_c *called_function_declaration; int extensible_param_count;) |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
762 |
void *narrow_candidate_datatypes_c::visit(il_formal_funct_call_c *symbol) { |
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
763 |
generic_function_call_t fcall_param = { |
441
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
764 |
/* fcall_param.function_name = */ symbol->function_name, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
765 |
/* fcall_param.nonformal_operand_list = */ NULL, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
766 |
/* fcall_param.formal_operand_list = */ symbol->il_param_list, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
767 |
/* enum {POU_FB, POU_function} POU_type = */ generic_function_call_t::POU_function, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
768 |
/* fcall_param.candidate_functions = */ symbol->candidate_functions, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
769 |
/* fcall_param.called_function_declaration = */ symbol->called_function_declaration, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
770 |
/* fcall_param.extensible_param_count = */ symbol->extensible_param_count |
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
771 |
}; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
772 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
773 |
narrow_function_invocation(symbol, fcall_param); |
450
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
774 |
/* The desired datatype of the previous il instruction was already set by narrow_function_invocation() */ |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
775 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
776 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
777 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
778 |
|
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
779 |
// void *visit(il_operand_list_c *symbol); |
453
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
780 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
781 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
782 |
/* | simple_instr_list il_simple_instruction */ |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
783 |
/* This object is referenced by il_expression_c objects */ |
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
784 |
void *narrow_candidate_datatypes_c::visit(simple_instr_list_c *symbol) { |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
785 |
if (symbol->n > 0) |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
786 |
symbol->elements[symbol->n - 1]->datatype = symbol->datatype; |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
787 |
|
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
788 |
for(int i = symbol->n-1; i >= 0; i--) { |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
789 |
symbol->elements[i]->accept(*this); |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
790 |
} |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
791 |
return NULL; |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
792 |
} |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
793 |
|
453
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
794 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
795 |
// SYM_REF1(il_simple_instruction_c, il_simple_instruction, symbol_c *prev_il_instruction;) |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
796 |
void *narrow_candidate_datatypes_c::visit(il_simple_instruction_c *symbol) { |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
797 |
if (symbol->prev_il_instruction.size() > 1) ERROR; /* There should be no labeled insructions inside an IL expression! */ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
798 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
799 |
il_instruction_c tmp_prev_il_instruction(NULL, NULL); |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
800 |
/* the narrow algorithm will need access to the intersected candidate_datatype lists of all prev_il_instructions, as well as the |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
801 |
* list of the prev_il_instructions. |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
802 |
* Instead of creating two 'global' (within the class) variables, we create a single il_instruction_c variable (fake_prev_il_instruction), |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
803 |
* and shove that data into this single variable. |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
804 |
*/ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
805 |
if (symbol->prev_il_instruction.size() > 0) |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
806 |
tmp_prev_il_instruction.candidate_datatypes = symbol->prev_il_instruction[0]->candidate_datatypes; |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
807 |
tmp_prev_il_instruction.prev_il_instruction = symbol->prev_il_instruction; |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
808 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
809 |
/* copy the candidate_datatypes list */ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
810 |
fake_prev_il_instruction = &tmp_prev_il_instruction; |
453
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
811 |
symbol->il_simple_instruction->datatype = symbol->datatype; |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
812 |
symbol->il_simple_instruction->accept(*this); |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
813 |
fake_prev_il_instruction = NULL; |
453
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
814 |
return NULL; |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
815 |
} |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
816 |
|
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
817 |
// void *visit(il_param_list_c *symbol); |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
818 |
// void *visit(il_param_assignment_c *symbol); |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
819 |
// void *visit(il_param_out_assignment_c *symbol); |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
820 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
821 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
822 |
/*******************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
823 |
/* B 2.2 Operators */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
824 |
/*******************/ |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
825 |
void *narrow_candidate_datatypes_c::narrow_binary_operator(const struct widen_entry widen_table[], symbol_c *symbol, bool *deprecated_operation) { |
478
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
826 |
symbol_c *prev_instruction_type, *operand_type; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
827 |
int count = 0; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
828 |
|
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
829 |
if (NULL == symbol->datatype) |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
830 |
/* next IL instructions were unable to determine the datatype this instruction should produce */ |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
831 |
return NULL; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
832 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
833 |
if (NULL != deprecated_operation) |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
834 |
*deprecated_operation = false; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
835 |
|
478
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
836 |
/* NOTE 1: the il_operand __may__ be pointing to a parenthesized list of IL instructions. |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
837 |
* e.g. LD 33 |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
838 |
* AND ( 45 |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
839 |
* OR 56 |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
840 |
* ) |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
841 |
* When we handle the first 'AND' IL_operator, the il_operand will point to an simple_instr_list_c. |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
842 |
* In this case, when we call il_operand->accept(*this);, the prev_il_instruction pointer will be overwritten! |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
843 |
* |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
844 |
* We must therefore set the prev_il_instruction->datatype = symbol->datatype; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
845 |
* __before__ calling il_operand->accept(*this) !! |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
846 |
* |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
847 |
* NOTE 2: We do not need to call prev_il_instruction->accept(*this), as the object to which prev_il_instruction |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
848 |
* is pointing to will be later narrowed by the call from the for() loop of the instruction_list_c |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
849 |
* (or simple_instr_list_c), which iterates backwards. |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
850 |
*/ |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
851 |
for(unsigned int i = 0; i < fake_prev_il_instruction->candidate_datatypes.size(); i++) { |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
852 |
for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) { |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
853 |
prev_instruction_type = fake_prev_il_instruction->candidate_datatypes[i]; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
854 |
operand_type = il_operand->candidate_datatypes[j]; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
855 |
if (is_widening_compatible(widen_table, prev_instruction_type, operand_type, symbol->datatype, deprecated_operation)) { |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
856 |
/* set the desired datatype of the previous il instruction */ |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
857 |
set_datatype_in_prev_il_instructions(prev_instruction_type, fake_prev_il_instruction); |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
858 |
/* set the datatype for the operand */ |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
859 |
il_operand->datatype = operand_type; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
860 |
|
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
861 |
count ++; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
862 |
} |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
863 |
} |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
864 |
} |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
865 |
// if (count > 1) ERROR; /* Since we also support SAFE data types, this assertion is not necessarily always tru! */ |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
866 |
if (is_type_valid(symbol->datatype) && (count <= 0)) ERROR; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
867 |
|
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
868 |
il_operand->accept(*this); |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
869 |
return NULL; |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
870 |
} |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
871 |
|
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
872 |
|
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
873 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
874 |
|
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
875 |
|
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
876 |
void *narrow_candidate_datatypes_c::handle_il_instruction(symbol_c *symbol) { |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
877 |
if (NULL == symbol->datatype) |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
878 |
/* next IL instructions were unable to determine the datatype this instruction should produce */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
879 |
return NULL; |
454
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
880 |
/* NOTE 1: the il_operand __may__ be pointing to a parenthesized list of IL instructions. |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
881 |
* e.g. LD 33 |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
882 |
* AND ( 45 |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
883 |
* OR 56 |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
884 |
* ) |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
885 |
* When we handle the first 'AND' IL_operator, the il_operand will point to an simple_instr_list_c. |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
886 |
* In this case, when we call il_operand->accept(*this);, the prev_il_instruction pointer will be overwritten! |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
887 |
* |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
888 |
* We must therefore set the prev_il_instruction->datatype = symbol->datatype; |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
889 |
* __before__ calling il_operand->accept(*this) !! |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
890 |
* |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
891 |
* NOTE 2: We do not need to call prev_il_instruction->accept(*this), as the object to which prev_il_instruction |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
892 |
* is pointing to will be later narrowed by the call from the for() loop of the instruction_list_c |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
893 |
* (or simple_instr_list_c), which iterates backwards. |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
894 |
*/ |
099aa5d655de
Finish support for semantic verification of IL paranthesised expressions.
Mario de Sousa <msousa@fe.up.pt>
parents:
453
diff
changeset
|
895 |
/* set the desired datatype of the previous il instruction */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
896 |
set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
897 |
|
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
898 |
/* set the datatype for the operand */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
899 |
il_operand->datatype = symbol->datatype; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
900 |
il_operand->accept(*this); |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
901 |
return NULL; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
902 |
} |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
903 |
|
478
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
904 |
|
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
905 |
|
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
906 |
|
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
907 |
void *narrow_candidate_datatypes_c::visit(LD_operator_c *symbol) { |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
908 |
if (NULL == symbol->datatype) |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
909 |
/* next IL instructions were unable to determine the datatype this instruction should produce */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
910 |
return NULL; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
911 |
/* set the datatype for the operand */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
912 |
il_operand->datatype = symbol->datatype; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
913 |
il_operand->accept(*this); |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
914 |
return NULL; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
915 |
} |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
916 |
|
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
917 |
|
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
918 |
void *narrow_candidate_datatypes_c::visit(LDN_operator_c *symbol) { |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
919 |
if (NULL == symbol->datatype) |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
920 |
/* next IL instructions were unable to determine the datatype this instruction should produce */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
921 |
return NULL; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
922 |
/* set the datatype for the operand */ |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
923 |
il_operand->datatype = symbol->datatype; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
924 |
il_operand->accept(*this); |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
925 |
return NULL; |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
926 |
} |
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
927 |
|
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
928 |
void *narrow_candidate_datatypes_c::visit(ST_operator_c *symbol) { |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
929 |
if (symbol->candidate_datatypes.size() != 1) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
930 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
931 |
symbol->datatype = symbol->candidate_datatypes[0]; |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
932 |
/* set the datatype for the operand */ |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
933 |
il_operand->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
934 |
il_operand->accept(*this); |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
935 |
/* set the desired datatype of the previous il instruction */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
936 |
set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
937 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
938 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
939 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
940 |
void *narrow_candidate_datatypes_c::visit(STN_operator_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
941 |
if (symbol->candidate_datatypes.size() != 1) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
942 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
943 |
symbol->datatype = symbol->candidate_datatypes[0]; |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
944 |
/* set the datatype for the operand */ |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
945 |
il_operand->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
946 |
il_operand->accept(*this); |
443
ff4d26b7e51d
Narrow IL code backwords, so as to correctly handle invocations to overloaded functions from IL code.
Mario de Sousa <msousa@fe.up.pt>
parents:
441
diff
changeset
|
947 |
/* set the desired datatype of the previous il instruction */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
948 |
set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
949 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
950 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
951 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
952 |
void *narrow_candidate_datatypes_c::visit(NOT_operator_c *symbol) { |
470
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
953 |
/* NOTE: the standard allows syntax in which the NOT operator is followed by an optional <il_operand> |
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
954 |
* NOT [<il_operand>] |
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
955 |
* However, it does not define the semantic of the NOT operation when the <il_operand> is specified. |
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
956 |
* We therefore consider it an error if an il_operand is specified! |
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
957 |
*/ |
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
958 |
/* We do not change the data type, we simply invert the bits in bit types! */ |
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
959 |
/* So, we set the desired datatype of the previous il instruction */ |
d2cd05c5e01a
Semantic verification of NOT operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
467
diff
changeset
|
960 |
set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
961 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
962 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
963 |
|
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
964 |
void *narrow_candidate_datatypes_c::visit(S_operator_c *symbol) { |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
965 |
/* TODO: what if this is a FB call? */ |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
966 |
return handle_il_instruction(symbol); |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
967 |
} |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
968 |
void *narrow_candidate_datatypes_c::visit(R_operator_c *symbol) { |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
969 |
/* TODO: what if this is a FB call? */ |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
970 |
return handle_il_instruction(symbol); |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
971 |
} |
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
972 |
|
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
973 |
|
456 | 974 |
void *narrow_candidate_datatypes_c::visit( S1_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "S1", symbol->called_fb_declaration);} |
975 |
void *narrow_candidate_datatypes_c::visit( R1_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "R1", symbol->called_fb_declaration);} |
|
976 |
void *narrow_candidate_datatypes_c::visit( CLK_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "CLK", symbol->called_fb_declaration);} |
|
977 |
void *narrow_candidate_datatypes_c::visit( CU_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "CU", symbol->called_fb_declaration);} |
|
978 |
void *narrow_candidate_datatypes_c::visit( CD_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "CD", symbol->called_fb_declaration);} |
|
979 |
void *narrow_candidate_datatypes_c::visit( PV_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "PV", symbol->called_fb_declaration);} |
|
980 |
void *narrow_candidate_datatypes_c::visit( IN_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "IN", symbol->called_fb_declaration);} |
|
981 |
void *narrow_candidate_datatypes_c::visit( PT_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "PT", symbol->called_fb_declaration);} |
|
982 |
||
481
16f943328696
Add 'widen' tables for AND, OR and XOR operations.
Mario de Sousa <msousa@fe.up.pt>
parents:
480
diff
changeset
|
983 |
void *narrow_candidate_datatypes_c::visit( AND_operator_c *symbol) {return narrow_binary_operator(widen_AND_table, symbol);} |
16f943328696
Add 'widen' tables for AND, OR and XOR operations.
Mario de Sousa <msousa@fe.up.pt>
parents:
480
diff
changeset
|
984 |
void *narrow_candidate_datatypes_c::visit( OR_operator_c *symbol) {return narrow_binary_operator( widen_OR_table, symbol);} |
16f943328696
Add 'widen' tables for AND, OR and XOR operations.
Mario de Sousa <msousa@fe.up.pt>
parents:
480
diff
changeset
|
985 |
void *narrow_candidate_datatypes_c::visit( XOR_operator_c *symbol) {return narrow_binary_operator(widen_XOR_table, symbol);} |
483
7f839fb100c1
Cleaning up XORN, ANDN, and ORN operator code.
Mario de Sousa <msousa@fe.up.pt>
parents:
481
diff
changeset
|
986 |
void *narrow_candidate_datatypes_c::visit(ANDN_operator_c *symbol) {return narrow_binary_operator(widen_AND_table, symbol);} |
7f839fb100c1
Cleaning up XORN, ANDN, and ORN operator code.
Mario de Sousa <msousa@fe.up.pt>
parents:
481
diff
changeset
|
987 |
void *narrow_candidate_datatypes_c::visit( ORN_operator_c *symbol) {return narrow_binary_operator( widen_OR_table, symbol);} |
7f839fb100c1
Cleaning up XORN, ANDN, and ORN operator code.
Mario de Sousa <msousa@fe.up.pt>
parents:
481
diff
changeset
|
988 |
void *narrow_candidate_datatypes_c::visit(XORN_operator_c *symbol) {return narrow_binary_operator(widen_XOR_table, symbol);} |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
989 |
void *narrow_candidate_datatypes_c::visit( ADD_operator_c *symbol) {return narrow_binary_operator(widen_ADD_table, symbol, &(symbol->deprecated_operation));} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
990 |
void *narrow_candidate_datatypes_c::visit( SUB_operator_c *symbol) {return narrow_binary_operator(widen_SUB_table, symbol, &(symbol->deprecated_operation));} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
991 |
void *narrow_candidate_datatypes_c::visit( MUL_operator_c *symbol) {return narrow_binary_operator(widen_MUL_table, symbol, &(symbol->deprecated_operation));} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
992 |
void *narrow_candidate_datatypes_c::visit( DIV_operator_c *symbol) {return narrow_binary_operator(widen_DIV_table, symbol, &(symbol->deprecated_operation));} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
993 |
void *narrow_candidate_datatypes_c::visit( MOD_operator_c *symbol) {return narrow_binary_operator(widen_MOD_table, symbol);} |
484
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
994 |
void *narrow_candidate_datatypes_c::visit( GT_operator_c *symbol) {return narrow_binary_operator(widen_CMP_table, symbol);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
995 |
void *narrow_candidate_datatypes_c::visit( GE_operator_c *symbol) {return narrow_binary_operator(widen_CMP_table, symbol);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
996 |
void *narrow_candidate_datatypes_c::visit( EQ_operator_c *symbol) {return narrow_binary_operator(widen_CMP_table, symbol);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
997 |
void *narrow_candidate_datatypes_c::visit( LT_operator_c *symbol) {return narrow_binary_operator(widen_CMP_table, symbol);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
998 |
void *narrow_candidate_datatypes_c::visit( LE_operator_c *symbol) {return narrow_binary_operator(widen_CMP_table, symbol);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
999 |
void *narrow_candidate_datatypes_c::visit( NE_operator_c *symbol) {return narrow_binary_operator(widen_CMP_table, symbol);} |
448
1bd18fc06911
Add support for semantic verification for implict FB calls in IL (e.g. PV ton_var)
Mario de Sousa <msousa@fe.up.pt>
parents:
445
diff
changeset
|
1000 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1001 |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1002 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1003 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1004 |
void *narrow_candidate_datatypes_c::narrow_conditional_flow_control_IL_instruction(symbol_c *symbol) { |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1005 |
/* if the next IL instructions needs us to provide a datatype other than a bool, |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1006 |
* then we have an internal compiler error - most likely in fill_candidate_datatypes_c |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1007 |
*/ |
472
d26759a2274a
Clean up code, and add support for 'safe' version of literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
470
diff
changeset
|
1008 |
if ((NULL != symbol->datatype) && (!is_ANY_BOOL_compatible(symbol->datatype))) ERROR; |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1009 |
if (symbol->candidate_datatypes.size() > 1) ERROR; |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1010 |
|
456 | 1011 |
/* NOTE: If there is no IL instruction following this CALC, CALCN, JMPC, JMPC, ..., instruction, |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1012 |
* we must still provide a bool_type_name_c datatype (if possible, i.e. if it exists in the candidate datatype list). |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1013 |
* If it is not possible, we set it to NULL |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1014 |
*/ |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1015 |
if (symbol->candidate_datatypes.size() == 0) symbol->datatype = NULL; |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1016 |
else symbol->datatype = symbol->candidate_datatypes[0]; /* i.e. a bool_type_name_c! */ |
472
d26759a2274a
Clean up code, and add support for 'safe' version of literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
470
diff
changeset
|
1017 |
if ((NULL != symbol->datatype) && (!is_ANY_BOOL_compatible(symbol->datatype))) ERROR; |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1018 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1019 |
/* set the required datatype of the previous IL instruction, i.e. a bool_type_name_c! */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
1020 |
set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1021 |
return NULL; |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1022 |
} |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1023 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1024 |
|
487 | 1025 |
// SYM_REF0(CAL_operator_c) |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1026 |
// SYM_REF0(CALC_operator_c) |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1027 |
// SYM_REF0(CALCN_operator_c) |
456 | 1028 |
/* called from visit(il_fb_call_c *) {symbol->il_call_operator->accpet(*this)} */ |
487 | 1029 |
/* NOTE: The CAL, JMP and RET instructions simply set the desired datatype of the previous il instruction since they do not change the value in the current/default IL variable */ |
1030 |
/* called from il_fb_call_c (symbol->il_call_operator->accpet(*this) ) */ |
|
1031 |
void *narrow_candidate_datatypes_c::visit( CAL_operator_c *symbol) {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); return NULL;} |
|
1032 |
void *narrow_candidate_datatypes_c::visit( RET_operator_c *symbol) {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); return NULL;} |
|
1033 |
void *narrow_candidate_datatypes_c::visit( JMP_operator_c *symbol) {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); return NULL;} |
|
456 | 1034 |
void *narrow_candidate_datatypes_c::visit( CALC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);} |
1035 |
void *narrow_candidate_datatypes_c::visit(CALCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);} |
|
1036 |
void *narrow_candidate_datatypes_c::visit( RETC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);} |
|
1037 |
void *narrow_candidate_datatypes_c::visit(RETCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);} |
|
1038 |
void *narrow_candidate_datatypes_c::visit( JMPC_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);} |
|
1039 |
void *narrow_candidate_datatypes_c::visit(JMPCN_operator_c *symbol) {return narrow_conditional_flow_control_IL_instruction(symbol);} |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1040 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1041 |
/* Symbol class handled together with function call checks */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1042 |
// void *visit(il_assign_operator_c *symbol, variable_name); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1043 |
/* Symbol class handled together with function call checks */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1044 |
// void *visit(il_assign_operator_c *symbol, option, variable_name); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1045 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1046 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1047 |
/***************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1048 |
/* B.3 - Language ST (Structured Text) */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1049 |
/***************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1050 |
/***********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1051 |
/* B 3.1 - Expressions */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1052 |
/***********************/ |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1053 |
void *narrow_candidate_datatypes_c::narrow_binary_expression(const struct widen_entry widen_table[], symbol_c *symbol, symbol_c *l_expr, symbol_c *r_expr, bool *deprecated_operation) { |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1054 |
symbol_c *l_type, *r_type; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1055 |
int count = 0; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1056 |
|
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1057 |
if (NULL != deprecated_operation) |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1058 |
*deprecated_operation = false; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1059 |
|
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1060 |
for(unsigned int i = 0; i < l_expr->candidate_datatypes.size(); i++) { |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1061 |
for(unsigned int j = 0; j < r_expr->candidate_datatypes.size(); j++) { |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1062 |
/* test widening compatibility */ |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1063 |
l_type = l_expr->candidate_datatypes[i]; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1064 |
r_type = r_expr->candidate_datatypes[j]; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1065 |
if (is_widening_compatible(widen_table, l_type, r_type, symbol->datatype, deprecated_operation)) { |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1066 |
l_expr->datatype = l_type; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1067 |
r_expr->datatype = r_type; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1068 |
count ++; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1069 |
} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1070 |
} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1071 |
} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1072 |
// if (count > 1) ERROR; /* Since we also support SAFE data types, this assertion is not necessarily always tru! */ |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1073 |
if (is_type_valid(symbol->datatype) && (count <= 0)) ERROR; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1074 |
|
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1075 |
l_expr->accept(*this); |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1076 |
r_expr->accept(*this); |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1077 |
return NULL; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1078 |
} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1079 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1080 |
|
481
16f943328696
Add 'widen' tables for AND, OR and XOR operations.
Mario de Sousa <msousa@fe.up.pt>
parents:
480
diff
changeset
|
1081 |
|
484
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1082 |
void *narrow_candidate_datatypes_c::visit( or_expression_c *symbol) {return narrow_binary_expression( widen_OR_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1083 |
void *narrow_candidate_datatypes_c::visit( xor_expression_c *symbol) {return narrow_binary_expression(widen_XOR_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1084 |
void *narrow_candidate_datatypes_c::visit( and_expression_c *symbol) {return narrow_binary_expression(widen_AND_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1085 |
|
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1086 |
void *narrow_candidate_datatypes_c::visit( equ_expression_c *symbol) {return narrow_binary_expression(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1087 |
void *narrow_candidate_datatypes_c::visit(notequ_expression_c *symbol) {return narrow_binary_expression(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1088 |
void *narrow_candidate_datatypes_c::visit( lt_expression_c *symbol) {return narrow_binary_expression(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1089 |
void *narrow_candidate_datatypes_c::visit( gt_expression_c *symbol) {return narrow_binary_expression(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1090 |
void *narrow_candidate_datatypes_c::visit( le_expression_c *symbol) {return narrow_binary_expression(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1091 |
void *narrow_candidate_datatypes_c::visit( ge_expression_c *symbol) {return narrow_binary_expression(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1092 |
|
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1093 |
void *narrow_candidate_datatypes_c::visit( add_expression_c *symbol) {return narrow_binary_expression(widen_ADD_table, symbol, symbol->l_exp, symbol->r_exp, &symbol->deprecated_operation);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1094 |
void *narrow_candidate_datatypes_c::visit( sub_expression_c *symbol) {return narrow_binary_expression(widen_SUB_table, symbol, symbol->l_exp, symbol->r_exp, &symbol->deprecated_operation);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1095 |
void *narrow_candidate_datatypes_c::visit( mul_expression_c *symbol) {return narrow_binary_expression(widen_MUL_table, symbol, symbol->l_exp, symbol->r_exp, &symbol->deprecated_operation);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1096 |
void *narrow_candidate_datatypes_c::visit( div_expression_c *symbol) {return narrow_binary_expression(widen_DIV_table, symbol, symbol->l_exp, symbol->r_exp, &symbol->deprecated_operation);} |
f78750994a82
Clean code for comparison operations & operators.
Mario de Sousa <msousa@fe.up.pt>
parents:
483
diff
changeset
|
1097 |
void *narrow_candidate_datatypes_c::visit( mod_expression_c *symbol) {return narrow_binary_expression(widen_MOD_table, symbol, symbol->l_exp, symbol->r_exp);} |
490 | 1098 |
void *narrow_candidate_datatypes_c::visit( power_expression_c *symbol) {return narrow_binary_expression(widen_EXPT_table,symbol, symbol->l_exp, symbol->r_exp);} |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1099 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1100 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1101 |
void *narrow_candidate_datatypes_c::visit(neg_expression_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1102 |
symbol->exp->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1103 |
symbol->exp->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1104 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1105 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1106 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1107 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1108 |
void *narrow_candidate_datatypes_c::visit(not_expression_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1109 |
symbol->exp->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1110 |
symbol->exp->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1111 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1112 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1113 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1114 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1115 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1116 |
/* NOTE: The parameter 'called_function_declaration', 'extensible_param_count' and 'candidate_functions' are used to pass data between the stage 3 and stage 4. */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1117 |
/* formal_param_list -> may be NULL ! */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1118 |
/* nonformal_param_list -> may be NULL ! */ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1119 |
// SYM_REF3(function_invocation_c, function_name, formal_param_list, nonformal_param_list, symbol_c *called_function_declaration; int extensible_param_count; std::vector <symbol_c *> candidate_functions;) |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1120 |
void *narrow_candidate_datatypes_c::visit(function_invocation_c *symbol) { |
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1121 |
generic_function_call_t fcall_param = { |
441
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
1122 |
/* fcall_param.function_name = */ symbol->function_name, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
1123 |
/* fcall_param.nonformal_operand_list = */ symbol->nonformal_param_list, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
1124 |
/* fcall_param.formal_operand_list = */ symbol->formal_param_list, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
1125 |
/* enum {POU_FB, POU_function} POU_type = */ generic_function_call_t::POU_function, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
1126 |
/* fcall_param.candidate_functions = */ symbol->candidate_functions, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
1127 |
/* fcall_param.called_function_declaration = */ symbol->called_function_declaration, |
e8de43eefcc5
Add printing of semantic errors when calling FB from IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
439
diff
changeset
|
1128 |
/* fcall_param.extensible_param_count = */ symbol->extensible_param_count |
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1129 |
}; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1130 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1131 |
narrow_function_invocation(symbol, fcall_param); |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1132 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1133 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1134 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1135 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1136 |
/* B 3.2 Statements */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1137 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1138 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1139 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1140 |
/*********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1141 |
/* B 3.2.1 Assignment Statements */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1142 |
/*********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1143 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1144 |
void *narrow_candidate_datatypes_c::visit(assignment_statement_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1145 |
if (symbol->candidate_datatypes.size() != 1) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1146 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1147 |
symbol->datatype = symbol->candidate_datatypes[0]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1148 |
symbol->l_exp->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1149 |
symbol->l_exp->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1150 |
symbol->r_exp->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1151 |
symbol->r_exp->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1152 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1153 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1154 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1155 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1156 |
/*****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1157 |
/* B 3.2.2 Subprogram Control Statements */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1158 |
/*****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1159 |
|
423
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1160 |
void *narrow_candidate_datatypes_c::visit(fb_invocation_c *symbol) { |
424
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1161 |
/* Note: We do not use the symbol->called_fb_declaration value (set in fill_candidate_datatypes_c) |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1162 |
* because we try to identify any other datatype errors in the expressions used in the |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1163 |
* parameters to the FB call (e.g. fb_var(var1 * 56 + func(var * 43)) ) |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1164 |
* even it the call to the FB is invalid. |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1165 |
* This makes sense because it may be errors in those expressions which are |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1166 |
* making this an invalid call, so it makes sense to point them out to the user! |
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1167 |
*/ |
423
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1168 |
symbol_c *fb_decl = search_varfb_instance_type->get_basetype_decl(symbol->fb_name); |
424
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1169 |
|
43d73e28eca8
Continue checking data type compatibility inside expressions used to pass paramters to invalid function/FB calls
Mario de Sousa <msousa@fe.up.pt>
parents:
423
diff
changeset
|
1170 |
/* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */ |
423
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1171 |
if (NULL == fb_decl) ERROR; |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1172 |
if (NULL != symbol->nonformal_param_list) narrow_nonformal_call(symbol, fb_decl); |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1173 |
if (NULL != symbol-> formal_param_list) narrow_formal_call(symbol, fb_decl); |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1174 |
|
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1175 |
return NULL; |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1176 |
} |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1177 |
|
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1178 |
|
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1179 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1180 |
/* B 3.2.3 Selection Statements */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1181 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1182 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1183 |
void *narrow_candidate_datatypes_c::visit(if_statement_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1184 |
for(unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
472
d26759a2274a
Clean up code, and add support for 'safe' version of literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
470
diff
changeset
|
1185 |
if (is_ANY_BOOL_compatible(symbol->expression->candidate_datatypes[i])) |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1186 |
symbol->expression->datatype = symbol->expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1187 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1188 |
symbol->expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1189 |
if (NULL != symbol->statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1190 |
symbol->statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1191 |
if (NULL != symbol->elseif_statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1192 |
symbol->elseif_statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1193 |
if (NULL != symbol->else_statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1194 |
symbol->else_statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1195 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1196 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1197 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1198 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1199 |
void *narrow_candidate_datatypes_c::visit(elseif_statement_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1200 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
472
d26759a2274a
Clean up code, and add support for 'safe' version of literals.
Mario de Sousa <msousa@fe.up.pt>
parents:
470
diff
changeset
|
1201 |
if (is_ANY_BOOL_compatible(symbol->expression->candidate_datatypes[i])) |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1202 |
symbol->expression->datatype = symbol->expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1203 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1204 |
symbol->expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1205 |
if (NULL != symbol->statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1206 |
symbol->statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1207 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1208 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1209 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1210 |
/* CASE expression OF case_element_list ELSE statement_list END_CASE */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1211 |
// SYM_REF3(case_statement_c, expression, case_element_list, statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1212 |
void *narrow_candidate_datatypes_c::visit(case_statement_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1213 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1214 |
if ((is_ANY_INT_type(symbol->expression->candidate_datatypes[i])) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1215 |
|| (search_base_type.type_is_enumerated(symbol->expression->candidate_datatypes[i]))) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1216 |
symbol->expression->datatype = symbol->expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1217 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1218 |
symbol->expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1219 |
if (NULL != symbol->statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1220 |
symbol->statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1221 |
if (NULL != symbol->case_element_list) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1222 |
symbol->case_element_list->datatype = symbol->expression->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1223 |
symbol->case_element_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1224 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1225 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1226 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1227 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1228 |
/* helper symbol for case_statement */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1229 |
// SYM_LIST(case_element_list_c) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1230 |
void *narrow_candidate_datatypes_c::visit(case_element_list_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1231 |
for (int i = 0; i < symbol->n; i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1232 |
symbol->elements[i]->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1233 |
symbol->elements[i]->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1234 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1235 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1236 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1237 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1238 |
/* case_list ':' statement_list */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1239 |
// SYM_REF2(case_element_c, case_list, statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1240 |
void *narrow_candidate_datatypes_c::visit(case_element_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1241 |
symbol->case_list->datatype = symbol->datatype; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1242 |
symbol->case_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1243 |
symbol->statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1244 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1245 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1246 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1247 |
// SYM_LIST(case_list_c) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1248 |
void *narrow_candidate_datatypes_c::visit(case_list_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1249 |
for (int i = 0; i < symbol->n; i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1250 |
for (unsigned int k = 0; k < symbol->elements[i]->candidate_datatypes.size(); k++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1251 |
if (is_type_equal(symbol->datatype, symbol->elements[i]->candidate_datatypes[k])) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1252 |
symbol->elements[i]->datatype = symbol->elements[i]->candidate_datatypes[k]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1253 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1254 |
/* NOTE: this may be an integer, a subrange_c, or a enumerated value! */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1255 |
symbol->elements[i]->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1256 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1257 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1258 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1259 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1260 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1261 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1262 |
/* B 3.2.4 Iteration Statements */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1263 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1264 |
void *narrow_candidate_datatypes_c::visit(for_statement_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1265 |
/* Control variable */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1266 |
for(unsigned int i = 0; i < symbol->control_variable->candidate_datatypes.size(); i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1267 |
if (is_ANY_INT_type(symbol->control_variable->candidate_datatypes[i])) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1268 |
symbol->control_variable->datatype = symbol->control_variable->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1269 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1270 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1271 |
symbol->control_variable->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1272 |
/* BEG expression */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1273 |
for(unsigned int i = 0; i < symbol->beg_expression->candidate_datatypes.size(); i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1274 |
if (is_type_equal(symbol->control_variable->datatype,symbol->beg_expression->candidate_datatypes[i]) && |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1275 |
is_ANY_INT_type(symbol->beg_expression->candidate_datatypes[i])) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1276 |
symbol->beg_expression->datatype = symbol->beg_expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1277 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1278 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1279 |
symbol->beg_expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1280 |
/* END expression */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1281 |
for(unsigned int i = 0; i < symbol->end_expression->candidate_datatypes.size(); i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1282 |
if (is_type_equal(symbol->control_variable->datatype,symbol->end_expression->candidate_datatypes[i]) && |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1283 |
is_ANY_INT_type(symbol->end_expression->candidate_datatypes[i])) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1284 |
symbol->end_expression->datatype = symbol->end_expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1285 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1286 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1287 |
symbol->end_expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1288 |
/* BY expression */ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1289 |
if (NULL != symbol->by_expression) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1290 |
for(unsigned int i = 0; i < symbol->by_expression->candidate_datatypes.size(); i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1291 |
if (is_type_equal(symbol->control_variable->datatype,symbol->by_expression->candidate_datatypes[i]) && |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1292 |
is_ANY_INT_type(symbol->by_expression->candidate_datatypes[i])) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1293 |
symbol->by_expression->datatype = symbol->by_expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1294 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1295 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1296 |
symbol->by_expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1297 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1298 |
if (NULL != symbol->statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1299 |
symbol->statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1300 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1301 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1302 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1303 |
void *narrow_candidate_datatypes_c::visit(while_statement_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1304 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1305 |
if(is_BOOL_type(symbol->expression->candidate_datatypes[i])) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1306 |
symbol->expression->datatype = symbol->expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1307 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1308 |
symbol->expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1309 |
if (NULL != symbol->statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1310 |
symbol->statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1311 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1312 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1313 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1314 |
void *narrow_candidate_datatypes_c::visit(repeat_statement_c *symbol) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1315 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1316 |
if(is_BOOL_type(symbol->expression->candidate_datatypes[i])) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1317 |
symbol->expression->datatype = symbol->expression->candidate_datatypes[i]; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1318 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1319 |
symbol->expression->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1320 |
if (NULL != symbol->statement_list) |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1321 |
symbol->statement_list->accept(*this); |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1322 |
return NULL; |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1323 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1324 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1325 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1326 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1327 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1328 |