author | mjsousa |
Fri, 26 Dec 2014 09:57:02 +0000 | |
changeset 971 | 8aee27d46208 |
parent 945 | 477393b00f95 |
child 994 | 66dc2ef40e70 |
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) { |
661
f537c3315f83
Minor changes needed to build with pedantic flag.
Manuele Conti <conti.ma@alice.it>
parents:
652
diff
changeset
|
69 |
search_varfb_instance_type = NULL; |
f537c3315f83
Minor changes needed to build with pedantic flag.
Manuele Conti <conti.ma@alice.it>
parents:
652
diff
changeset
|
70 |
fake_prev_il_instruction = NULL; |
674
b221168a36f1
Set datatype of il_intruction_c objects containing an ST operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
673
diff
changeset
|
71 |
current_il_instruction = NULL; |
661
f537c3315f83
Minor changes needed to build with pedantic flag.
Manuele Conti <conti.ma@alice.it>
parents:
652
diff
changeset
|
72 |
il_operand = 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
|
73 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
74 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
75 |
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
|
76 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
77 |
|
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
|
78 |
|
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
79 |
/* 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
|
80 |
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
|
81 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
82 |
/* 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
|
83 |
* 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
|
84 |
* 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
|
85 |
* 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
|
86 |
*/ |
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
|
87 |
// 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
|
88 |
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
|
89 |
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
|
90 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
91 |
if (search_in_candidate_datatype_list(datatype, symbol->candidate_datatypes) < 0) |
693
51a2fa6441b9
Prepare to delete search_constant_type_c -> Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
690
diff
changeset
|
92 |
symbol->datatype = &(get_datatype_info_c::invalid_type_name); |
459
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 |
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
|
95 |
/* 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
|
96 |
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
|
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 |
/* had already been set previously to some data type. Let's check if they are the same! */ |
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
99 |
if (!get_datatype_info_c::is_type_equal(symbol->datatype, datatype)) |
693
51a2fa6441b9
Prepare to delete search_constant_type_c -> Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
690
diff
changeset
|
100 |
symbol->datatype = &(get_datatype_info_c::invalid_type_name); |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
101 |
// else |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
102 |
/* 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
|
103 |
} |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
104 |
} |
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
|
105 |
} |
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
106 |
|
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
107 |
|
c8e6cf57324a
Print error messages when datatype erros found in ST function/FB calls.
Mario de Sousa <msousa@fe.up.pt>
parents:
424
diff
changeset
|
108 |
|
457
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
109 |
/* 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
|
110 |
// 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
|
111 |
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
|
112 |
if (NULL == symbol) ERROR; |
457
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
113 |
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
|
114 |
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
|
115 |
} |
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
116 |
|
67d8b07bac22
Change prev_il_instruction to a vector<>
Mario de Sousa <msousa@fe.up.pt>
parents:
456
diff
changeset
|
117 |
|
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
|
118 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
119 |
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
|
120 |
/* 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
|
121 |
* 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
|
122 |
*/ |
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
123 |
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
|
124 |
return false; |
fdef852a6565
Fix bug when handling code with data type errors.
Mario de Sousa <msousa@fe.up.pt>
parents:
502
diff
changeset
|
125 |
|
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
|
126 |
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
|
127 |
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
|
128 |
&& (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
|
129 |
&& (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
|
130 |
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
|
131 |
*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
|
132 |
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
|
133 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
134 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
135 |
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
|
136 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
137 |
|
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
|
138 |
/* |
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
|
139 |
* 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
|
140 |
* 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
|
141 |
* 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
|
142 |
*/ |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
143 |
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
|
144 |
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
|
145 |
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
|
146 |
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
|
147 |
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
|
148 |
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
|
149 |
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
|
150 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
151 |
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
|
152 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/* 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
|
154 |
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
|
155 |
/* 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
|
156 |
/* 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
|
157 |
* 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
|
158 |
*/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
159 |
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
|
160 |
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
|
161 |
/* 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
|
162 |
/* 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
|
163 |
* 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
|
164 |
* 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
|
165 |
*/ |
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 |
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
|
167 |
} 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
|
168 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
169 |
/* 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
|
170 |
/* 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
|
171 |
* 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
|
172 |
*/ |
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
|
173 |
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
|
174 |
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
|
175 |
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
|
176 |
|
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
|
177 |
/* NOTE: When we are handling a nonformal function call made from IL, the first parameter is the 'default' or 'current' |
451 | 178 |
* 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
|
179 |
* 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
|
180 |
* call_param_value->accept(*this); |
451 | 181 |
* 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
|
182 |
*/ |
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
|
183 |
set_datatype(desired_datatype, call_param_value); |
451 | 184 |
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
|
185 |
|
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
|
186 |
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
|
187 |
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
|
188 |
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
|
189 |
} |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
190 |
/* 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
|
191 |
* 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
|
192 |
* 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
|
193 |
* 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
|
194 |
* 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
|
195 |
* 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
|
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 |
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
|
198 |
*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
|
199 |
} |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
200 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
201 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
202 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
203 |
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
|
204 |
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
|
205 |
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
|
206 |
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
|
207 |
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
|
208 |
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
|
209 |
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
|
210 |
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
|
211 |
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
|
212 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
213 |
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
|
214 |
/* 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
|
215 |
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
|
216 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/* 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
|
218 |
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
|
219 |
/* 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
|
220 |
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
|
221 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
222 |
/* 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
|
223 |
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
|
224 |
|
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
225 |
/* 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
|
226 |
/* 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
|
227 |
* 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
|
228 |
* 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
|
229 |
*/ |
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
|
230 |
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
|
231 |
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
|
232 |
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
|
233 |
|
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
|
234 |
/* 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
|
235 |
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
|
236 |
/* And recursively call that parameter/expression, so it can propagate that info */ |
451 | 237 |
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
|
238 |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
239 |
/* 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
|
240 |
/* 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
|
241 |
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
|
242 |
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
|
243 |
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
|
244 |
} |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
245 |
/* 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
|
246 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
247 |
/* 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
|
248 |
* 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
|
249 |
* 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
|
250 |
* 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
|
251 |
* 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
|
252 |
* 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
|
253 |
*/ |
421
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
254 |
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
|
255 |
*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
|
256 |
} |
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
257 |
|
840cb1e1e177
Add support in stage 3 for checking function invocations in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
417
diff
changeset
|
258 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
259 |
/* |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
260 |
typedef struct { |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
261 |
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
|
262 |
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
|
263 |
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
|
264 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
265 |
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
|
266 |
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
|
267 |
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
|
268 |
} 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
|
269 |
*/ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
270 |
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
|
271 |
/* 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
|
272 |
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
|
273 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
274 |
/* 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
|
275 |
for(unsigned int i = 0; i < fcall->candidate_datatypes.size(); i++) { |
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
276 |
if (get_datatype_info_c::is_type_equal(fcall->candidate_datatypes[i], fcall->datatype)) { |
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
277 |
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
|
278 |
break; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
279 |
} |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
280 |
} |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
281 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
282 |
/* 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
|
283 |
* 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
|
284 |
* (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
|
285 |
* 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
|
286 |
* 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
|
287 |
* invocation. |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
288 |
*/ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
289 |
/* 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
|
290 |
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
|
291 |
/* 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
|
292 |
* 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
|
293 |
* function invocation. |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
294 |
*/ |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
295 |
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
|
296 |
} |
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 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
|
299 |
* 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
|
300 |
* 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
|
301 |
*/ |
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.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
|
303 |
return; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
304 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
305 |
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
|
306 |
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
|
307 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
308 |
return; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
309 |
} |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
310 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
311 |
|
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
|
312 |
|
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
|
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 |
/* 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
|
315 |
* 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
|
316 |
* 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
|
317 |
* |
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
|
318 |
* 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
|
319 |
* 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
|
320 |
*/ |
456 | 321 |
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
|
322 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
323 |
/* 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
|
324 |
if (NULL != il_operand) { |
834
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
325 |
set_datatype(called_fb_declaration, il_operand); /* only set it if it is in the candidate datatypes list! */ |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
326 |
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
|
327 |
} |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
328 |
|
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
329 |
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
|
330 |
/* 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
|
331 |
* (or list of instructions) that will set the IL current/default value. |
451 | 332 |
* 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
|
333 |
*/ |
456 | 334 |
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
|
335 |
} |
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
|
336 |
|
834
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
337 |
symbol_c *fb_decl = (NULL == il_operand)? NULL : il_operand->datatype; |
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
338 |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
339 |
if (NULL == fb_decl) { |
834
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
340 |
/* the il_operand is a not FB instance, or it simply does not even exist, */ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
341 |
/* 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
|
342 |
/* 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
|
343 |
set_datatype_in_prev_il_instructions(il_instruction->datatype, fake_prev_il_instruction); |
456 | 344 |
return NULL; |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
345 |
} |
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
346 |
|
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
347 |
|
451 | 348 |
/* The value being passed to the 'param_name' parameter is actually the prev_il_instruction. |
349 |
* However, we do not place that object directly in the fake il_param_list_c that we will be |
|
350 |
* creating, since the visit(il_fb_call_c *) method will recursively call every object in that list. |
|
351 |
* The il_prev_intruction object will be visited once we have handled this implici IL FB call |
|
352 |
* (called from the instruction_list_c for() loop that works backwards). We DO NOT want to visit it twice. |
|
353 |
* (Anyway, if we let the visit(il_fb_call_c *) recursively visit the current prev_il_instruction, this pointer |
|
354 |
* would be changed to the IL instruction coming before the current prev_il_instruction! => things would get all messed up!) |
|
355 |
* The easiest way to work around this is to simply use a new object, and copy the relevant details to that object! |
|
356 |
*/ |
|
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
357 |
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
|
358 |
|
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
|
359 |
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
|
360 |
// 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
|
361 |
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
|
362 |
// SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list) |
451 | 363 |
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
|
364 |
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
|
365 |
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
|
366 |
// 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
|
367 |
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
|
368 |
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
|
369 |
|
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
|
370 |
/* 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
|
371 |
* 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
|
372 |
* 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
|
373 |
* 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
|
374 |
* |
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 |
* 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
|
376 |
* 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
|
377 |
*/ |
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
378 |
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
|
379 |
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
|
380 |
|
451 | 381 |
/* set the required datatype of the previous IL instruction! */ |
382 |
/* NOTE: |
|
383 |
* When handling these implicit IL calls, the parameter_value being passed to the FB parameter |
|
384 |
* is actually the prev_il_instruction. |
|
385 |
* |
|
386 |
* However, since the FB call does not change the value in the current/default IL variable, this value |
|
387 |
* must also be used ny the IL instruction coming after this FB call. |
|
388 |
* |
|
389 |
* This means that we have two consumers/users for the same value. |
|
390 |
* We must therefore check whether the datatype required by the IL instructions following this FB call |
|
391 |
* 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
|
392 |
* and we set it to invalid_type_name. |
451 | 393 |
* |
394 |
* However, we only do that if: |
|
395 |
* - The IL instruction that comes after this IL FB call actually asked this FB call for a specific |
|
396 |
* datatype in the current/default vairable, once this IL FB call returns. |
|
397 |
* However, sometimes, (for e.g., this FB call is the last in the IL list) the subsequent FB to not aks this |
|
398 |
* FB call for any datatype. In that case, then the datatype required to pass to the first parameter of the |
|
399 |
* FB call must be left unchanged! |
|
400 |
*/ |
|
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
401 |
if ((NULL == il_instruction->datatype) || (get_datatype_info_c::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
|
402 |
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
|
403 |
} else { |
693
51a2fa6441b9
Prepare to delete search_constant_type_c -> Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
690
diff
changeset
|
404 |
set_datatype_in_prev_il_instructions(&get_datatype_info_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
|
405 |
} |
456 | 406 |
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
|
407 |
} |
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
|
408 |
|
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
|
409 |
|
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
|
410 |
/* 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
|
411 |
symbol_c *narrow_candidate_datatypes_c::base_type(symbol_c *symbol) { |
718
a9f8cc778444
Make search_base_type_c a singleton!
Mario de Sousa <msousa@fe.up.pt>
parents:
693
diff
changeset
|
412 |
/* NOTE: symbol == NULL is valid. It will occur when, for e.g., an undefined/undeclared symbolic_variable is used in the code. */ |
423
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
413 |
if (symbol == NULL) return NULL; |
718
a9f8cc778444
Make search_base_type_c a singleton!
Mario de Sousa <msousa@fe.up.pt>
parents:
693
diff
changeset
|
414 |
return search_base_type_c::get_basetype_decl(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
|
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 |
|
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
417 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
418 |
|
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
|
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 |
/**********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/* 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
|
422 |
/**********************/ |
797
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
423 |
/***********************************/ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
424 |
/* B 1.3.1 - Elementary Data Types */ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
425 |
/***********************************/ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
426 |
/* NOTE: elementary datatypes are their own basetype ! */ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
427 |
void *narrow_candidate_datatypes_c::visit( time_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
428 |
void *narrow_candidate_datatypes_c::visit( bool_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
429 |
void *narrow_candidate_datatypes_c::visit( sint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
430 |
void *narrow_candidate_datatypes_c::visit( int_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
431 |
void *narrow_candidate_datatypes_c::visit( dint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
432 |
void *narrow_candidate_datatypes_c::visit( lint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
433 |
void *narrow_candidate_datatypes_c::visit( usint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
434 |
void *narrow_candidate_datatypes_c::visit( uint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
435 |
void *narrow_candidate_datatypes_c::visit( udint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
436 |
void *narrow_candidate_datatypes_c::visit( ulint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
437 |
void *narrow_candidate_datatypes_c::visit( real_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
438 |
void *narrow_candidate_datatypes_c::visit( lreal_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
439 |
void *narrow_candidate_datatypes_c::visit( date_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
440 |
void *narrow_candidate_datatypes_c::visit( tod_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
441 |
void *narrow_candidate_datatypes_c::visit( dt_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
442 |
void *narrow_candidate_datatypes_c::visit( byte_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
443 |
void *narrow_candidate_datatypes_c::visit( word_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
444 |
void *narrow_candidate_datatypes_c::visit( dword_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
445 |
void *narrow_candidate_datatypes_c::visit( lword_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
446 |
void *narrow_candidate_datatypes_c::visit( string_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
447 |
void *narrow_candidate_datatypes_c::visit( wstring_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
448 |
|
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
449 |
void *narrow_candidate_datatypes_c::visit(safetime_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
450 |
void *narrow_candidate_datatypes_c::visit(safebool_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
451 |
void *narrow_candidate_datatypes_c::visit(safesint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
452 |
void *narrow_candidate_datatypes_c::visit(safeint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
453 |
void *narrow_candidate_datatypes_c::visit(safedint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
454 |
void *narrow_candidate_datatypes_c::visit(safelint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
455 |
void *narrow_candidate_datatypes_c::visit(safeusint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
456 |
void *narrow_candidate_datatypes_c::visit(safeuint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
457 |
void *narrow_candidate_datatypes_c::visit(safeudint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
458 |
void *narrow_candidate_datatypes_c::visit(safeulint_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
459 |
void *narrow_candidate_datatypes_c::visit(safereal_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
460 |
void *narrow_candidate_datatypes_c::visit(safelreal_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
461 |
void *narrow_candidate_datatypes_c::visit(safedate_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
462 |
void *narrow_candidate_datatypes_c::visit(safetod_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
463 |
void *narrow_candidate_datatypes_c::visit(safedt_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
464 |
void *narrow_candidate_datatypes_c::visit(safebyte_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
465 |
void *narrow_candidate_datatypes_c::visit(safeword_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
466 |
void *narrow_candidate_datatypes_c::visit(safedword_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
467 |
void *narrow_candidate_datatypes_c::visit(safelword_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
468 |
void *narrow_candidate_datatypes_c::visit(safestring_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
469 |
void *narrow_candidate_datatypes_c::visit(safewstring_type_name_c *symbol) {symbol->datatype = search_base_type_c::get_basetype_decl(symbol); return NULL;} |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
470 |
|
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
471 |
|
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
472 |
/********************************/ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
473 |
/* B.1.3.2 - Generic data types */ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
474 |
/********************************/ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
475 |
/* empty!! */ |
3444c331efc9
Fill in the symbol->datatype of elementary datatypes.
Mario de Sousa <msousa@fe.up.pt>
parents:
728
diff
changeset
|
476 |
|
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
|
477 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/* 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
|
479 |
/********************************/ |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
480 |
void *narrow_candidate_datatypes_c::narrow_spec_init(symbol_c *symbol, symbol_c *type_decl, symbol_c *init_value) { |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
481 |
// If we are handling an anonymous datatype (i.e. a datatype implicitly declared inside a VAR ... END_VAR declaration) |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
482 |
// then the symbol->datatype has not yet been set by the previous visit(type_decl) method, because it does not exist! |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
483 |
// So we set the datatype ourselves! |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
484 |
if ((NULL == symbol->datatype) && (symbol->candidate_datatypes.size() == 1)) |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
485 |
symbol->datatype = symbol->candidate_datatypes[0]; |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
486 |
|
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
487 |
set_datatype(symbol->datatype, type_decl); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
488 |
type_decl->accept(*this); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
489 |
|
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
490 |
if (NULL != init_value) { |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
491 |
set_datatype(symbol->datatype, init_value); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
492 |
init_value->accept(*this); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
493 |
} |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
494 |
return NULL; |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
495 |
} |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
496 |
|
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
497 |
|
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
498 |
void *narrow_candidate_datatypes_c::narrow_type_decl(symbol_c *symbol, symbol_c *type_name, symbol_c *spec_init) { |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
499 |
if (symbol->candidate_datatypes.size() == 1) { |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
500 |
symbol->datatype = symbol->candidate_datatypes[0]; |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
501 |
|
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
502 |
set_datatype(symbol->datatype, type_name); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
503 |
set_datatype(symbol->datatype, spec_init); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
504 |
spec_init->accept(*this); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
505 |
} |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
506 |
return NULL; |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
507 |
} |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
508 |
|
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
509 |
|
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
510 |
/* TYPE type_declaration_list END_TYPE */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
511 |
// SYM_REF1(data_type_declaration_c, type_declaration_list) |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
512 |
/* NOTE: Not required. already handled by iterator_visitor_c base class */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
513 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
514 |
/* helper symbol for data_type_declaration */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
515 |
// SYM_LIST(type_declaration_list_c) |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
516 |
/* NOTE: Not required. already handled by iterator_visitor_c base class */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
517 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
518 |
/* simple_type_name ':' simple_spec_init */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
519 |
// SYM_REF2(simple_type_declaration_c, simple_type_name, simple_spec_init) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
520 |
void *narrow_candidate_datatypes_c::visit(simple_type_declaration_c *symbol) {return narrow_type_decl(symbol, symbol->simple_type_name, symbol->simple_spec_init);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
521 |
|
502
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
522 |
/* 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
|
523 |
// SYM_REF2(simple_spec_init_c, simple_specification, constant) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
524 |
void *narrow_candidate_datatypes_c::visit(simple_spec_init_c *symbol) {return narrow_spec_init(symbol, symbol->simple_specification, symbol->constant);} |
502
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
525 |
|
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
526 |
/* subrange_type_name ':' subrange_spec_init */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
527 |
// SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
528 |
void *narrow_candidate_datatypes_c::visit(subrange_type_declaration_c *symbol) {return narrow_type_decl(symbol, symbol->subrange_type_name, symbol->subrange_spec_init);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
529 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
530 |
/* subrange_specification ASSIGN signed_integer */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
531 |
// SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
532 |
void *narrow_candidate_datatypes_c::visit(subrange_spec_init_c *symbol) {return narrow_spec_init(symbol, symbol->subrange_specification, symbol->signed_integer);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
533 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
534 |
/* integer_type_name '(' subrange')' */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
535 |
// SYM_REF2(subrange_specification_c, integer_type_name, subrange) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
536 |
void *narrow_candidate_datatypes_c::visit(subrange_specification_c *symbol) { |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
537 |
set_datatype(symbol->datatype, symbol->integer_type_name); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
538 |
symbol->integer_type_name->accept(*this); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
539 |
set_datatype(symbol->datatype, symbol->integer_type_name); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
540 |
symbol->integer_type_name->accept(*this); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
541 |
return NULL; |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
542 |
} |
502
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
543 |
|
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
|
544 |
/* signed_integer DOTDOT signed_integer */ |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
545 |
/* dimension will be filled in during stage 3 (array_range_check_c) with the number of elements in this subrange */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
546 |
// SYM_REF2(subrange_c, lower_limit, upper_limit, unsigned long long int dimension;) |
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
|
547 |
void *narrow_candidate_datatypes_c::visit(subrange_c *symbol) { |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
548 |
set_datatype(symbol->datatype, symbol->lower_limit); |
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
|
549 |
symbol->lower_limit->accept(*this); |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
550 |
set_datatype(symbol->datatype, symbol->upper_limit); |
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
|
551 |
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
|
552 |
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
|
553 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
|
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
556 |
/* enumerated_type_name ':' enumerated_spec_init */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
557 |
// SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
558 |
void *narrow_candidate_datatypes_c::visit(enumerated_type_declaration_c *symbol) {return narrow_type_decl(symbol, symbol->enumerated_type_name, symbol->enumerated_spec_init);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
559 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
560 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
561 |
/* enumerated_specification ASSIGN enumerated_value */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
562 |
// SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
563 |
void *narrow_candidate_datatypes_c::visit(enumerated_spec_init_c *symbol) {return narrow_spec_init(symbol, symbol->enumerated_specification, symbol->enumerated_value);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
564 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
565 |
/* helper symbol for enumerated_specification->enumerated_spec_init */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
566 |
/* enumerated_value_list ',' enumerated_value */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
567 |
// SYM_LIST(enumerated_value_list_c) |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
568 |
void *narrow_candidate_datatypes_c::visit(enumerated_value_list_c *symbol) { |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
569 |
//if (NULL == symbol->datatype) ERROR; // Comented out-> Reserve this check for the print_datatypes_error_c ??? |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
570 |
for(int i = 0; i < symbol->n; i++) set_datatype(symbol->datatype, symbol->elements[i]); |
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
571 |
//for(int i = 0; i < symbol->n; i++) if (NULL == symbol->elements[i]->datatype) ERROR; // Comented out-> Reserve this check for the print_datatypes_error_c ??? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
572 |
return NULL; |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
573 |
} |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
574 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
575 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
576 |
/* enumerated_type_name '#' identifier */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
577 |
// SYM_REF2(enumerated_value_c, type, value) |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
578 |
// void *narrow_candidate_datatypes_c::visit(enumerated_value_c *symbol) {/* do nothing! */ return NULL;} |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
579 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
580 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
581 |
/* identifier ':' array_spec_init */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
582 |
// SYM_REF2(array_type_declaration_c, identifier, array_spec_init) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
583 |
void *narrow_candidate_datatypes_c::visit(array_type_declaration_c *symbol) {return narrow_type_decl(symbol, symbol->identifier, symbol->array_spec_init);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
584 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
585 |
/* array_specification [ASSIGN array_initialization} */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
586 |
/* array_initialization may be NULL ! */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
587 |
// SYM_REF2(array_spec_init_c, array_specification, array_initialization) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
588 |
void *narrow_candidate_datatypes_c::visit(array_spec_init_c *symbol) {return narrow_spec_init(symbol, symbol->array_specification, symbol->array_initialization);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
589 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
590 |
/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
591 |
// SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
592 |
// Not needed!! |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
593 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
594 |
/* helper symbol for array_specification */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
595 |
/* array_subrange_list ',' subrange */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
596 |
// SYM_LIST(array_subrange_list_c) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
597 |
// Not needed ?? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
598 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
599 |
/* array_initialization: '[' array_initial_elements_list ']' */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
600 |
/* helper symbol for array_initialization */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
601 |
/* array_initial_elements_list ',' array_initial_elements */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
602 |
// SYM_LIST(array_initial_elements_list_c) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
603 |
// Not needed ??? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
604 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
605 |
/* integer '(' [array_initial_element] ')' */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
606 |
/* array_initial_element may be NULL ! */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
607 |
// SYM_REF2(array_initial_elements_c, integer, array_initial_element) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
608 |
// Not needed ??? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
609 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
610 |
/* structure_type_name ':' structure_specification */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
611 |
// SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
612 |
void *narrow_candidate_datatypes_c::visit(structure_type_declaration_c *symbol) {return narrow_type_decl(symbol, symbol->structure_type_name, symbol->structure_specification);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
613 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
614 |
/* structure_type_name ASSIGN structure_initialization */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
615 |
/* structure_initialization may be NULL ! */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
616 |
// SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
617 |
void *narrow_candidate_datatypes_c::visit(initialized_structure_c *symbol) {return narrow_spec_init(symbol, symbol->structure_type_name, symbol->structure_initialization);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
618 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
619 |
/* helper symbol for structure_declaration */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
620 |
/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
621 |
/* structure_element_declaration_list structure_element_declaration ';' */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
622 |
// SYM_LIST(structure_element_declaration_list_c) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
623 |
// Not needed ??? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
624 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
625 |
/* structure_element_name ':' *_spec_init */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
626 |
// SYM_REF2(structure_element_declaration_c, structure_element_name, spec_init) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
627 |
// Not needed ??? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
628 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
629 |
/* helper symbol for structure_initialization */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
630 |
/* structure_initialization: '(' structure_element_initialization_list ')' */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
631 |
/* structure_element_initialization_list ',' structure_element_initialization */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
632 |
// SYM_LIST(structure_element_initialization_list_c) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
633 |
// Not needed ??? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
634 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
635 |
/* structure_element_name ASSIGN value */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
636 |
// SYM_REF2(structure_element_initialization_c, structure_element_name, value) |
806
f218434eeaf8
Fill in the symbol.datatype annotation in symbol classes used in derived data type declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
798
diff
changeset
|
637 |
// Not needed ??? |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
638 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
639 |
/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
640 |
// SYM_REF4(string_type_declaration_c, string_type_name, elementary_string_type_name, string_type_declaration_size, string_type_declaration_init/* may be == NULL! */) |
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
641 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
642 |
|
810
d9c48ad646f1
Add a new node to the abstract symtax tree, which will let us do datatype checking of FB variable declarations using the standard algorithm, and no special cases.
Mario de Sousa <msousa@fe.up.pt>
parents:
808
diff
changeset
|
643 |
/* structure_type_name ASSIGN structure_initialization */ |
d9c48ad646f1
Add a new node to the abstract symtax tree, which will let us do datatype checking of FB variable declarations using the standard algorithm, and no special cases.
Mario de Sousa <msousa@fe.up.pt>
parents:
808
diff
changeset
|
644 |
/* structure_initialization may be NULL ! */ |
d9c48ad646f1
Add a new node to the abstract symtax tree, which will let us do datatype checking of FB variable declarations using the standard algorithm, and no special cases.
Mario de Sousa <msousa@fe.up.pt>
parents:
808
diff
changeset
|
645 |
// SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) |
d9c48ad646f1
Add a new node to the abstract symtax tree, which will let us do datatype checking of FB variable declarations using the standard algorithm, and no special cases.
Mario de Sousa <msousa@fe.up.pt>
parents:
808
diff
changeset
|
646 |
void *narrow_candidate_datatypes_c::visit(fb_spec_init_c *symbol) {return narrow_spec_init(symbol, symbol->function_block_type_name, symbol->structure_initialization);} |
726
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
647 |
|
9b61eb4f00dc
Change the base datatype of enumerations to an enumerated_type_declaration_c (for named types!)
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset
|
648 |
|
909
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
649 |
/* REF_TO (non_generic_type_name | function_block_type_name) */ |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
650 |
// SYM_REF1(ref_spec_c, type_name) |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
651 |
void *narrow_candidate_datatypes_c::visit(ref_spec_c *symbol) { |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
652 |
/* First handle the datatype being referenced (pointed to) */ |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
653 |
if (symbol->type_name->candidate_datatypes.size() == 1) { |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
654 |
symbol->type_name->datatype = symbol->type_name->candidate_datatypes[0]; |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
655 |
symbol->type_name->accept(*this); |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
656 |
} |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
657 |
|
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
658 |
/* Now handle the reference datatype itself (i.e. the pointer) */ |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
659 |
// If we are handling an anonymous datatype (i.e. a datatype implicitly declared inside a VAR ... END_VAR declaration) |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
660 |
// then the symbol->datatype has not yet been set by the previous visit(type_decl) method, because it does not exist! |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
661 |
// So we set the datatype ourselves! |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
662 |
if ((NULL == symbol->datatype) && (symbol->candidate_datatypes.size() == 1)) |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
663 |
symbol->datatype = symbol->candidate_datatypes[0]; |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
664 |
|
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
665 |
return NULL; |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
666 |
} |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
667 |
|
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
668 |
/* For the moment, we do not support initialising reference data types */ |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
669 |
/* ref_spec [ ASSIGN ref_initialization ] */ |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
670 |
/* NOTE: ref_initialization may be NULL!! */ |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
671 |
// SYM_REF2(ref_spec_init_c, ref_spec, ref_initialization) |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
672 |
void *narrow_candidate_datatypes_c::visit(ref_spec_init_c *symbol) {return narrow_spec_init(symbol, symbol->ref_spec, symbol->ref_initialization);} |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
673 |
|
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
674 |
/* identifier ':' ref_spec_init */ |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
675 |
// SYM_REF2(ref_type_decl_c, ref_type_name, ref_spec_init) |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
676 |
void *narrow_candidate_datatypes_c::visit(ref_type_decl_c *symbol) {return narrow_type_decl(symbol, symbol->ref_type_name, symbol->ref_spec_init);} |
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
677 |
|
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
678 |
|
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
895
diff
changeset
|
679 |
|
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
|
680 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
681 |
/* 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
|
682 |
/*********************/ |
843
f9a059c24aea
Fill in the 'datatype' anotation in the identifiers of symbolic variables.
mjsousa
parents:
839
diff
changeset
|
683 |
// SYM_REF1(symbolic_variable_c, var_name) |
f9a059c24aea
Fill in the 'datatype' anotation in the identifiers of symbolic variables.
mjsousa
parents:
839
diff
changeset
|
684 |
void *narrow_candidate_datatypes_c::visit(symbolic_variable_c *symbol) { |
f9a059c24aea
Fill in the 'datatype' anotation in the identifiers of symbolic variables.
mjsousa
parents:
839
diff
changeset
|
685 |
symbol->var_name->datatype = symbol->datatype; |
f9a059c24aea
Fill in the 'datatype' anotation in the identifiers of symbolic variables.
mjsousa
parents:
839
diff
changeset
|
686 |
return NULL; |
f9a059c24aea
Fill in the 'datatype' anotation in the identifiers of symbolic variables.
mjsousa
parents:
839
diff
changeset
|
687 |
} |
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
|
688 |
/********************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
689 |
/* 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
|
690 |
/********************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
691 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
692 |
/*************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
693 |
/* 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
|
694 |
/*************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
695 |
/* 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
|
696 |
// 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
|
697 |
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
|
698 |
/* 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
|
699 |
symbol->subscript_list->accept(*this); |
827
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
700 |
|
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
701 |
/* Set the datatype of the subscripted variable and visit it recursively. For the reason why we do this, */ |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
702 |
/* Please read the comments in the array_variable_c and structured_variable_c visitors in the fill_candidate_datatypes.cc file! */ |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
703 |
symbol->subscripted_variable->accept(*this); // visit recursively |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
704 |
|
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
705 |
if (symbol->subscripted_variable->candidate_datatypes.size() == 1) |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
706 |
symbol->subscripted_variable->datatype = symbol->subscripted_variable->candidate_datatypes[0]; // set the datatype |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
707 |
|
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
|
708 |
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
|
709 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
710 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
711 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
712 |
/* 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
|
713 |
// 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
|
714 |
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
|
715 |
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
|
716 |
for (unsigned int k = 0; k < symbol->elements[i]->candidate_datatypes.size(); k++) { |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
717 |
if (get_datatype_info_c::is_ANY_INT(symbol->elements[i]->candidate_datatypes[k])) |
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
|
718 |
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
|
719 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
720 |
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
|
721 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
722 |
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
|
723 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
724 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
725 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
726 |
|
827
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
727 |
/* record_variable '.' field_selector */ |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
728 |
/* WARNING: input and/or output variables of function blocks |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
729 |
* may be accessed as fields of a structured variable! |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
730 |
* Code handling a structured_variable_c must take |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
731 |
* this into account! |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
732 |
*/ |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
733 |
// SYM_REF2(structured_variable_c, record_variable, field_selector) |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
734 |
void *narrow_candidate_datatypes_c::visit(structured_variable_c *symbol) { |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
735 |
/* Set the datatype of the record_variable and visit it recursively. For the reason why we do this, */ |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
736 |
/* Please read the comments in the array_variable_c and structured_variable_c visitors in the fill_candidate_datatypes.cc file! */ |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
737 |
symbol->record_variable->accept(*this); // visit recursively |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
738 |
|
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
739 |
if (symbol->record_variable->candidate_datatypes.size() == 1) |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
740 |
symbol->record_variable->datatype = symbol->record_variable->candidate_datatypes[0]; // set the datatype |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
741 |
|
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
742 |
return NULL; |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
743 |
} |
e3800aff352c
Fix datatype analysis of structured variables that contain arrays in their fields (e.g. var.x1[var2 + 42].y1).
mjsousa
parents:
813
diff
changeset
|
744 |
|
502
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
745 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
746 |
/******************************************/ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
747 |
/* 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
|
748 |
/******************************************/ |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
749 |
|
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
750 |
/* When handling the declaration of variables the fill/narrow algorithm will simply visit the objects |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
751 |
* in the abstract syntax tree defining the desired datatype for the variables. Tis is to set the |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
752 |
* symbol->datatype to the basetype of that datatype. |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
753 |
* |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
754 |
* Note that we do not currently set the symbol->datatype annotation for the identifier_c objects naming the |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
755 |
* variables inside the variable declaration. However, this is liable to change in the future, so do not write |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
756 |
* any code that depends on this! |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
757 |
* |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
758 |
* example: |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
759 |
* VAR var1, var2, var3 : my_type; END_VAR |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
760 |
* (* ^^^^ ^^^^ ^^^^ -> will NOT have the symbol->datatype set (for now, may change in the future!) *) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
761 |
* (* ^^^^^^^ -> WILL have the symbol->datatype set *) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
762 |
* |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
763 |
* (remeber too that the identifier_c objects identifying variables inside ST/IL/SFC code *will* have their |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
764 |
* symbol->datatype annotation filled by the fill/narrow algorithm) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
765 |
*/ |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
766 |
void *narrow_candidate_datatypes_c::narrow_var_declaration(symbol_c *type) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
767 |
if (type->candidate_datatypes.size() == 1) |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
768 |
type->datatype = type->candidate_datatypes[0]; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
769 |
type->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
770 |
return NULL; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
771 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
772 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
773 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
774 |
void *narrow_candidate_datatypes_c::visit(var1_init_decl_c *symbol) {return narrow_var_declaration(symbol->spec_init);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
775 |
void *narrow_candidate_datatypes_c::visit(array_var_init_decl_c *symbol) {return narrow_var_declaration(symbol->array_spec_init);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
776 |
void *narrow_candidate_datatypes_c::visit(structured_var_init_decl_c *symbol) {return narrow_var_declaration(symbol->initialized_structure);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
777 |
void *narrow_candidate_datatypes_c::visit(fb_name_decl_c *symbol) {return narrow_var_declaration(symbol->fb_spec_init);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
778 |
void *narrow_candidate_datatypes_c::visit(array_var_declaration_c *symbol) {return narrow_var_declaration(symbol->array_specification);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
779 |
void *narrow_candidate_datatypes_c::visit(structured_var_declaration_c *symbol) {return narrow_var_declaration(symbol->structure_type_name);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
780 |
void *narrow_candidate_datatypes_c::visit(external_declaration_c *symbol) {return narrow_var_declaration(symbol->specification);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
781 |
void *narrow_candidate_datatypes_c::visit(global_var_decl_c *symbol) {return narrow_var_declaration(symbol->type_specification);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
782 |
void *narrow_candidate_datatypes_c::visit(incompl_located_var_decl_c *symbol) {return narrow_var_declaration(symbol->var_spec);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
783 |
//void *narrow_candidate_datatypes_c::visit(single_byte_string_var_declaration_c *symbol) {return handle_var_declaration(symbol->single_byte_string_spec);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
784 |
//void *narrow_candidate_datatypes_c::visit(double_byte_string_var_declaration_c *symbol) {return handle_var_declaration(symbol->double_byte_string_spec);} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
785 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
786 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
787 |
|
502
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
788 |
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
|
789 |
#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
|
790 |
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
|
791 |
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
|
792 |
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
|
793 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
794 |
#endif |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
795 |
return NULL; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
796 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
797 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
798 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
799 |
/* 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
|
800 |
// 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
|
801 |
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
|
802 |
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
|
803 |
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
|
804 |
return NULL; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
805 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
806 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
807 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
808 |
/* [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
|
809 |
/* 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
|
810 |
// 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
|
811 |
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
|
812 |
/* 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
|
813 |
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
|
814 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
815 |
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
|
816 |
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
|
817 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
818 |
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
|
819 |
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
|
820 |
return NULL; |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
821 |
} |
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
822 |
|
a6211f73690b
Start data type checking of var declarations (including direct variables!)
Mario de Sousa <msousa@fe.up.pt>
parents:
490
diff
changeset
|
823 |
|
808
7a6b53d61ea3
Consider fb_name_decl_c a non base data type class!
Mario de Sousa <msousa@fe.up.pt>
parents:
807
diff
changeset
|
824 |
|
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
|
825 |
/************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
826 |
/* 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
|
827 |
/************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
828 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
829 |
/* 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
|
830 |
/*********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
831 |
void *narrow_candidate_datatypes_c::visit(function_declaration_c *symbol) { |
798
d21e598b0b75
Set the symbol->datatpe of function_declaration_c
Mario de Sousa <msousa@fe.up.pt>
parents:
797
diff
changeset
|
832 |
/* set the function_declaration_c->datatype to the datatype returned by the function! */ |
d21e598b0b75
Set the symbol->datatpe of function_declaration_c
Mario de Sousa <msousa@fe.up.pt>
parents:
797
diff
changeset
|
833 |
symbol->type_name->datatype = search_base_type_c::get_basetype_decl(symbol->type_name); |
d21e598b0b75
Set the symbol->datatpe of function_declaration_c
Mario de Sousa <msousa@fe.up.pt>
parents:
797
diff
changeset
|
834 |
symbol->datatype = symbol->type_name->datatype; |
d21e598b0b75
Set the symbol->datatpe of function_declaration_c
Mario de Sousa <msousa@fe.up.pt>
parents:
797
diff
changeset
|
835 |
|
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
|
836 |
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
|
837 |
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
|
838 |
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
|
839 |
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
|
840 |
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
|
841 |
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
|
842 |
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
|
843 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
844 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
845 |
/***************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
846 |
/* 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
|
847 |
/***************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
848 |
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
|
849 |
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
|
850 |
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
|
851 |
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
|
852 |
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
|
853 |
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
|
854 |
search_varfb_instance_type = NULL; |
889
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
873
diff
changeset
|
855 |
|
807
4d71292f8732
Fill symbol->datatype anotation for FB declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
806
diff
changeset
|
856 |
// A FB declaration can also be used as a Datatype! We now do the narrow algorithm considering it as such! |
4d71292f8732
Fill symbol->datatype anotation for FB declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
806
diff
changeset
|
857 |
if (symbol->candidate_datatypes.size() == 1) |
4d71292f8732
Fill symbol->datatype anotation for FB declarations.
Mario de Sousa <msousa@fe.up.pt>
parents:
806
diff
changeset
|
858 |
symbol->datatype = symbol->candidate_datatypes[0]; |
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
|
859 |
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
|
860 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
861 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
862 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
863 |
/* 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
|
864 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
865 |
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
|
866 |
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
|
867 |
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
|
868 |
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
|
869 |
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
|
870 |
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
|
871 |
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
|
872 |
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
|
873 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
874 |
|
802
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
875 |
/********************************************/ |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
876 |
/* B 1.6 Sequential function chart elements */ |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
877 |
/********************************************/ |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
878 |
void *narrow_candidate_datatypes_c::visit(transition_condition_c *symbol) { |
895
f824bf8e1579
Add error message for invalid datatype of transition condition. Generalize datatype narrowing algorithm for transition conditions.
mjsousa
parents:
889
diff
changeset
|
879 |
// We can safely ask for a BOOL type, as even if the result is a SAFEBOOL, in that case it will aslo include BOOL as a possible datatype. |
f824bf8e1579
Add error message for invalid datatype of transition condition. Generalize datatype narrowing algorithm for transition conditions.
mjsousa
parents:
889
diff
changeset
|
880 |
set_datatype(&get_datatype_info_c::bool_type_name /* datatype*/, symbol /* symbol */); |
f824bf8e1579
Add error message for invalid datatype of transition condition. Generalize datatype narrowing algorithm for transition conditions.
mjsousa
parents:
889
diff
changeset
|
881 |
|
802
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
882 |
if (symbol->transition_condition_il != NULL) { |
895
f824bf8e1579
Add error message for invalid datatype of transition condition. Generalize datatype narrowing algorithm for transition conditions.
mjsousa
parents:
889
diff
changeset
|
883 |
set_datatype(symbol->datatype, symbol->transition_condition_il); |
802
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
884 |
symbol->transition_condition_il->accept(*this); |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
885 |
} |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
886 |
if (symbol->transition_condition_st != NULL) { |
895
f824bf8e1579
Add error message for invalid datatype of transition condition. Generalize datatype narrowing algorithm for transition conditions.
mjsousa
parents:
889
diff
changeset
|
887 |
set_datatype(symbol->datatype, symbol->transition_condition_st); |
802
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
888 |
symbol->transition_condition_st->accept(*this); |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
889 |
} |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
890 |
return NULL; |
cac262d1d6a5
Fixed bug with SFC transition datatype checking
Laurent Bessard
parents:
798
diff
changeset
|
891 |
} |
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
|
892 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
893 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
894 |
/* 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
|
895 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
896 |
void *narrow_candidate_datatypes_c::visit(configuration_declaration_c *symbol) { |
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
897 |
if (debug) printf("Narrowing candidate data types list in configuration %s\n", ((token_c *)(symbol->configuration_name))->value); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
898 |
search_varfb_instance_type = new search_varfb_instance_type_c(symbol); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
899 |
symbol->global_var_declarations->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
900 |
symbol->resource_declarations ->accept(*this); // points to a single_resource_declaration_c or a resource_declaration_list_c |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
901 |
// symbol->access_declarations ->accept(*this); // TODO |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
902 |
// symbol->instance_specific_initializations->accept(*this); // TODO |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
903 |
delete search_varfb_instance_type; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
904 |
search_varfb_instance_type = NULL; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
905 |
return NULL; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
906 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
907 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
908 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
909 |
void *narrow_candidate_datatypes_c::visit(resource_declaration_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
910 |
if (debug) printf("Narrowing candidate data types list in resource %s\n", ((token_c *)(symbol->resource_name))->value); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
911 |
search_varfb_instance_type_c *prev_search_varfb_instance_type = search_varfb_instance_type; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
912 |
search_varfb_instance_type = new search_varfb_instance_type_c(symbol); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
913 |
symbol->global_var_declarations->accept(*this); |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
914 |
symbol->resource_declaration ->accept(*this); // points to a single_resource_declaration_c! |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
915 |
delete search_varfb_instance_type; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
916 |
search_varfb_instance_type = prev_search_varfb_instance_type; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
917 |
return NULL; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
918 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
919 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
920 |
|
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
921 |
void *narrow_candidate_datatypes_c::visit(single_resource_declaration_c *symbol) { |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
922 |
// symbol->task_configuration_list ->accept(*this); // TODO |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
923 |
// symbol->program_configuration_list ->accept(*this); // TODO |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
924 |
return NULL; |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
925 |
} |
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
940
diff
changeset
|
926 |
|
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
|
927 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
928 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/* 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
|
931 |
/****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
932 |
/***********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/* 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
|
934 |
/***********************************/ |
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 |
|
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
|
936 |
/*| 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
|
937 |
// 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
|
938 |
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
|
939 |
/* 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
|
940 |
* 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
|
941 |
*/ |
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
|
942 |
/* 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
|
943 |
* 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
|
944 |
* 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
|
945 |
* 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
|
946 |
* 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
|
947 |
* 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
|
948 |
* 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
|
949 |
* 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
|
950 |
* |
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
|
951 |
* 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
|
952 |
* 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
|
953 |
* 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
|
954 |
*/ |
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
|
955 |
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
|
956 |
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
|
957 |
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
|
958 |
} |
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
|
959 |
} |
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
|
960 |
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
|
961 |
} |
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
|
962 |
|
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
|
963 |
/* | 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
|
964 |
// 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
|
965 |
// 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
|
966 |
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
|
967 |
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
|
968 |
/* 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
|
969 |
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
|
970 |
} else { |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
971 |
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
|
972 |
/* 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
|
973 |
* 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
|
974 |
* 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
|
975 |
* 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
|
976 |
*/ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
977 |
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
|
978 |
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
|
979 |
/* 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
|
980 |
fake_prev_il_instruction = &tmp_prev_il_instruction; |
674
b221168a36f1
Set datatype of il_intruction_c objects containing an ST operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
673
diff
changeset
|
981 |
current_il_instruction = symbol; |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
982 |
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
|
983 |
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
|
984 |
fake_prev_il_instruction = NULL; |
674
b221168a36f1
Set datatype of il_intruction_c objects containing an ST operator.
Mario de Sousa <msousa@fe.up.pt>
parents:
673
diff
changeset
|
985 |
current_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
|
986 |
} |
eb1b28acec2e
Fix a few more bugs related to FB/function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
448
diff
changeset
|
987 |
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
|
988 |
} |
444
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
989 |
|
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
990 |
|
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
991 |
|
92d40d2a7adc
Update comments on general architecture.
Mario de Sousa <msousa@fe.up.pt>
parents:
443
diff
changeset
|
992 |
|
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
|
993 |
// 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
|
994 |
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
|
995 |
/* 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
|
996 |
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
|
997 |
/* 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
|
998 |
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
|
999 |
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
|
1000 |
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
|
1001 |
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
|
1002 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1003 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1004 |
/* | 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
|
1005 |
/* 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
|
1006 |
// 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
|
1007 |
void *narrow_candidate_datatypes_c::visit(il_function_call_c *symbol) { |
451 | 1008 |
/* The first parameter of a non formal function call in IL will be the 'current value' (i.e. the prev_il_instruction) |
1009 |
* In order to be able to handle this without coding special cases, we will simply prepend that symbol |
|
1010 |
* to the il_operand_list, and remove it after calling handle_function_call(). |
|
1011 |
* However, since handle_function_call() will be recursively calling all parameter, and we don't want |
|
1012 |
* to do that for the prev_il_instruction (since it has already been visited by the fill_candidate_datatypes_c) |
|
1013 |
* we create a new ____ symbol_c ____ object, and copy the relevant info to/from that object before/after |
|
1014 |
* the call to handle_function_call(). |
|
1015 |
* |
|
1016 |
* However, if no further paramters are given, then il_operand_list will be NULL, and we will |
|
1017 |
* need to create a new object to hold the pointer to prev_il_instruction. |
|
534 | 1018 |
* This change will also be undone at the end of this method. |
451 | 1019 |
*/ |
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
1020 |
symbol_c param_value = *fake_prev_il_instruction; /* copy the candidate_datatypes list */ |
451 | 1021 |
if (NULL == symbol->il_operand_list) symbol->il_operand_list = new il_operand_list_c; |
1022 |
if (NULL == symbol->il_operand_list) ERROR; |
|
1023 |
||
1024 |
((list_c *)symbol->il_operand_list)->insert_element(¶m_value, 0); |
|
1025 |
||
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1026 |
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
|
1027 |
/* 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
|
1028 |
/* 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
|
1029 |
/* 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
|
1030 |
/* 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
|
1031 |
/* 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
|
1032 |
/* 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
|
1033 |
/* 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
|
1034 |
}; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1035 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1036 |
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
|
1037 |
set_datatype_in_prev_il_instructions(param_value.datatype, fake_prev_il_instruction); |
451 | 1038 |
|
1039 |
/* Undo the changes to the abstract syntax tree we made above... */ |
|
1040 |
((list_c *)symbol->il_operand_list)->remove_element(0); |
|
1041 |
if (((list_c *)symbol->il_operand_list)->n == 0) { |
|
1042 |
/* if the list becomes empty, then that means that it did not exist before we made these changes, so we delete it! */ |
|
1043 |
delete symbol->il_operand_list; |
|
1044 |
symbol->il_operand_list = NULL; |
|
1045 |
} |
|
1046 |
||
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
|
1047 |
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
|
1048 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
|
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1050 |
|
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
|
1051 |
/* | 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
|
1052 |
// 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
|
1053 |
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
|
1054 |
/* 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
|
1055 |
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
|
1056 |
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
|
1057 |
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
|
1058 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
1059 |
/* 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
|
1060 |
/* 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
|
1061 |
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
|
1062 |
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
|
1063 |
fake_prev_il_instruction = save_fake_prev_il_instruction; |
690
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1064 |
|
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1065 |
/* Since stage2 will insert an artificial (and equivalent) LD <il_operand> to the simple_instr_list when an 'il_operand' exists, we know |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1066 |
* that if (symbol->il_operand != NULL), then the first IL instruction in the simple_instr_list will be the equivalent and artificial |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1067 |
* 'LD <il_operand>' IL instruction. |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1068 |
* Just to be consistent, we will copy the datatype info back into the il_operand, even though this should not be necessary! |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1069 |
*/ |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1070 |
if ((NULL != symbol->il_operand) && ((NULL == symbol->simple_instr_list) || (0 == ((list_c *)symbol->simple_instr_list)->n))) ERROR; // stage2 is not behaving as we expect it to! |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1071 |
if (NULL != symbol->il_operand) |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1072 |
symbol->il_operand->datatype = ((list_c *)symbol->simple_instr_list)->elements[0]->datatype; |
6156ee2b4e32
Correctly generate C code for IL expressions, i.e. IL instructions inside parenthesis.
Mario de Sousa <msousa@fe.up.pt>
parents:
676
diff
changeset
|
1073 |
|
459
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
1074 |
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
|
1075 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1076 |
|
456 | 1077 |
|
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
|
1078 |
|
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
|
1079 |
|
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
|
1080 |
/* 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
|
1081 |
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
|
1082 |
/* 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
|
1083 |
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
|
1084 |
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
|
1085 |
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
|
1086 |
} |
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
|
1087 |
|
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
|
1088 |
|
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
|
1089 |
|
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
|
1090 |
|
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
|
1091 |
|
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
|
1092 |
|
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
|
1093 |
|
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
|
1094 |
/* 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
|
1095 |
* | 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
|
1096 |
* | 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
|
1097 |
* | 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
|
1098 |
* | 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
|
1099 |
*/ |
834
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
1100 |
/* NOTE: The parameter 'called_fb_declaration'is used to pass data between stage 3 and stage4 */ |
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
|
1101 |
// 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
|
1102 |
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
|
1103 |
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
|
1104 |
|
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
|
1105 |
/* 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
|
1106 |
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
|
1107 |
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
|
1108 |
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
|
1109 |
|
455
933c0dccc82f
Add support for semantic verification of CALC, CALCN, etc..
Mario de Sousa <msousa@fe.up.pt>
parents:
454
diff
changeset
|
1110 |
/* 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
|
1111 |
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
|
1112 |
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
|
1113 |
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
|
1114 |
} |
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
|
1115 |
|
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
|
1116 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1117 |
/* | 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
|
1118 |
/* 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
|
1119 |
// 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
|
1120 |
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
|
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 = */ NULL, |
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->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
|
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); |
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
|
1132 |
/* 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
|
1133 |
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
|
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 |
|
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1137 |
// 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
|
1138 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
1139 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
1140 |
/* | 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
|
1141 |
/* 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
|
1142 |
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
|
1143 |
if (symbol->n > 0) |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1144 |
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
|
1145 |
|
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1146 |
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
|
1147 |
symbol->elements[i]->accept(*this); |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1148 |
} |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1149 |
return NULL; |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1150 |
} |
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1151 |
|
453
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
1152 |
|
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
1153 |
// 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
|
1154 |
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
|
1155 |
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
|
1156 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
1157 |
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
|
1158 |
/* 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
|
1159 |
* 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
|
1160 |
* 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
|
1161 |
* 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
|
1162 |
*/ |
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
1163 |
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
|
1164 |
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
|
1165 |
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
|
1166 |
|
01f6664bf8c5
Continue adding support for semantic verification of JMP and RET.
Mario de Sousa <msousa@fe.up.pt>
parents:
457
diff
changeset
|
1167 |
/* 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
|
1168 |
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
|
1169 |
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
|
1170 |
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
|
1171 |
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
|
1172 |
return NULL; |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
1173 |
} |
4733f662362a
More changes for support of semantic verification of il_expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
452
diff
changeset
|
1174 |
|
452
79ac274d1cc4
Start of support for IL expressions (parenthesis).
Mario de Sousa <msousa@fe.up.pt>
parents:
451
diff
changeset
|
1175 |
// 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
|
1176 |
// 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
|
1177 |
// 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
|
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 |
/*******************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write 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 |
/* 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
|
1182 |
/*******************/ |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1183 |
/* Sets the datatype of the il_operand, and calls it recursively! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1184 |
* |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1185 |
* NOTE 1: the il_operand __may__ be pointing to a parenthesized list of IL instructions. |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1186 |
* e.g. LD 33 |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1187 |
* AND ( 45 |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1188 |
* OR 56 |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1189 |
* ) |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1190 |
* When we handle the first 'AND' IL_operator, the il_operand will point to an simple_instr_list_c. |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1191 |
* In this case, when we call il_operand->accept(*this);, the prev_il_instruction pointer will be overwritten! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1192 |
* |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1193 |
* So, if yoy wish to set the prev_il_instruction->datatype = symbol->datatype; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1194 |
* do it __before__ calling set_il_operand_datatype() (which in turn calls il_operand->accept(*this)) !! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1195 |
*/ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1196 |
void *narrow_candidate_datatypes_c::set_il_operand_datatype(symbol_c *il_operand, symbol_c *datatype) { |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1197 |
if (NULL == il_operand) return NULL; /* if no IL operand => error in the source code!! */ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1198 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1199 |
/* If il_operand already has a non-NULL datatype (remember, narrow algorithm runs twice over IL lists!), |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1200 |
* but narrow algorithm has not yet been able to determine what datatype it should take? This is strange, |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1201 |
* and most probably an error! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1202 |
*/ |
838
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1203 |
if ((NULL != il_operand->datatype) && (NULL == datatype)) ERROR; |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1204 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1205 |
/* If the il_operand's datatype has already been set previously, and |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1206 |
* the narrow algorithm has already determined the datatype the il_operand should take! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1207 |
* ...we just make sure that the new datatype is the same as the current il_operand's datatype |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1208 |
*/ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1209 |
if ((NULL != il_operand->datatype) && (NULL != datatype)) { |
838
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1210 |
/* Both datatypes are an invalid_type_name_c. This implies they are the same!! */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1211 |
if ((!get_datatype_info_c::is_type_valid(datatype)) && ((!get_datatype_info_c::is_type_valid(il_operand->datatype)))) |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1212 |
return NULL;; |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1213 |
/* OK, so both the datatypes are valid, but are they equal? */ |
838
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1214 |
if ( !get_datatype_info_c::is_type_equal(il_operand->datatype, datatype)) |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1215 |
ERROR; |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1216 |
/* The datatypes are the same. We have nothing to do, so we simply return! */ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1217 |
return NULL; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1218 |
} |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1219 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1220 |
/* Set the il_operand's datatype. Note that the new 'datatype' may even be NULL!!! */ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1221 |
il_operand->datatype = datatype; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1222 |
/* Even if we are not able to determine the il_operand's datatype ('datatype' is NULL), we still visit it recursively, |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1223 |
* to give a chance of any complex expressions embedded in the il_operand (e.g. expressions inside array subscripts!) |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1224 |
* to be narrowed too. |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1225 |
*/ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1226 |
il_operand->accept(*this); |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1227 |
return NULL; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1228 |
} |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1229 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1230 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1231 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1232 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1233 |
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
|
1234 |
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
|
1235 |
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
|
1236 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1237 |
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
|
1238 |
*deprecated_operation = false; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1239 |
|
834
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
1240 |
if (NULL == il_operand) return NULL; /* if no IL operand => error in the source code!! */ |
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
1241 |
|
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
1242 |
/* NOTE 1: the il_operand __may__ be pointing to a parenthesized list of IL instructions. |
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
|
1243 |
* 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
|
1244 |
* 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
|
1245 |
* 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
|
1246 |
* ) |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
1247 |
* 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
|
1248 |
* 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
|
1249 |
* |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
1250 |
* 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
|
1251 |
* __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
|
1252 |
* |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
1253 |
* 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
|
1254 |
* 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
|
1255 |
* (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
|
1256 |
*/ |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1257 |
if (NULL != symbol->datatype) { // next IL instructions were able to determine the datatype this instruction should produce |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1258 |
for(unsigned int i = 0; i < fake_prev_il_instruction->candidate_datatypes.size(); i++) { |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1259 |
for(unsigned int j = 0; j < il_operand->candidate_datatypes.size(); j++) { |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1260 |
prev_instruction_type = fake_prev_il_instruction->candidate_datatypes[i]; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1261 |
operand_type = il_operand->candidate_datatypes[j]; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1262 |
if (is_widening_compatible(widen_table, prev_instruction_type, operand_type, symbol->datatype, deprecated_operation)) { |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1263 |
/* set the desired datatype of the previous il instruction */ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1264 |
set_datatype_in_prev_il_instructions(prev_instruction_type, fake_prev_il_instruction); |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1265 |
/* set the datatype for the operand */ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1266 |
set_il_operand_datatype(il_operand, operand_type); |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1267 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1268 |
/* NOTE: DO NOT search any further! Return immediately! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1269 |
* Since we support SAFE*** datatypes, multiple entries in the widen_table may be compatible. |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1270 |
* If we try to set more than one distinct datatype on the same symbol, then the datatype will be set to |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1271 |
* an invalid_datatype, which is NOT what we want! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1272 |
*/ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1273 |
return NULL; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1274 |
} |
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
|
1275 |
} |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
1276 |
} |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
1277 |
} |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1278 |
/* We were not able to determine the required datatype, but we still give the il_operand a chance to be narrowed! */ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1279 |
set_il_operand_datatype(il_operand, NULL); |
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
|
1280 |
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
|
1281 |
} |
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
1282 |
|
b13feab3b918
Change setting of deprecated_operation from fill to narrow_candidate_datatypes_c.
Mario de Sousa <msousa@fe.up.pt>
parents:
472
diff
changeset
|
1283 |
|
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
|
1284 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1285 |
|
838
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1286 |
/* Narrow IL operators whose execution is conditional on the boolean value in the accumulator. |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1287 |
* Basically, narrow the JMPC, JMPCN, RETC, RETCN, CALC, and CALCN operators! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1288 |
* Also does part of the S and R operator narrowing!!! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1289 |
*/ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1290 |
void *narrow_candidate_datatypes_c::narrow_conditional_operator(symbol_c *symbol) { |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1291 |
/* if the next IL instructions needs us to provide a datatype other than a BOOL or a SAFEBOOL, |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1292 |
* then we have an internal compiler error - most likely in fill_candidate_datatypes_c |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1293 |
*/ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1294 |
// I (mario) am confident the fill/narrow algorithms are working correctly, so for now we can disable the assertions! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1295 |
//if ((NULL != symbol->datatype) && (!get_datatype_info_c::is_BOOL_compatible(symbol->datatype))) ERROR; |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1296 |
//if (symbol->candidate_datatypes.size() > 2) ERROR; /* may contain, at most, a BOOL and a SAFEBOOL */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1297 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1298 |
/* NOTE: If there is no IL instruction following this S, R, CALC, CALCN, JMPC, JMPCN, RETC, or RETCN instruction, |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1299 |
* we must still provide a bool_type_name_c datatype (if possible, i.e. if it exists in the candidate datatype list). |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1300 |
* If it is not possible, we set it to NULL |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1301 |
* |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1302 |
* NOTE: Note that this algorithm we are implementing is slightly wrong. |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1303 |
* (a) It ignores that a SAFEBOOL may be needed instead of a BOOL datatype. |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1304 |
* (b) It also ignores that this method gets to be called twice on the same |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1305 |
* object (the narrow algorithm runs through the IL list twice in order to |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1306 |
* handle forward JMPs), so the assumption that we must immediately set our |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1307 |
* own datatype if we get called with a NULL symbol->datatype is incorrect |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1308 |
* (it may be that the second time it is called it will be with the correct datatype!). |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1309 |
* |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1310 |
* These two issues (a) and (b) together means that we should only really be setting our own |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1311 |
* datatype if we are certain that the following IL instructions will never set it for us |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1312 |
* - basically if the following IL instruction is a LD, or a JMP to a LD, or a JMP to a JMP to a LD, |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1313 |
* etc..., or a conditional JMP whose both branches go to LD, etc...!!! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1314 |
* |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1315 |
* At the moment, it seems to me that we would need to write a visitor class to do this for us! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1316 |
* I currently have other things on my mind at the moment, so I will leave this for later... |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1317 |
* For the moment we just set it to BOOL, and ignore the support of SAFEBOOL! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1318 |
*/ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1319 |
if (NULL == symbol->datatype) set_datatype(&get_datatype_info_c::bool_type_name /* datatype*/, symbol /* symbol */); |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1320 |
if (NULL == symbol->datatype) ERROR; // the BOOL is not on the candidate_datatypes! Strange... Probably a bug in fill_candidate_datatype_c |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1321 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1322 |
/* set the required datatype of the previous IL instruction, i.e. a bool_type_name_c! */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1323 |
set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1324 |
return NULL; |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1325 |
} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1326 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1327 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1328 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1329 |
void *narrow_candidate_datatypes_c::narrow_S_and_R_operator(symbol_c *symbol, const char *param_name, symbol_c *called_fb_declaration) { |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1330 |
if (NULL != called_fb_declaration) |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1331 |
/* FB call semantics */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1332 |
return narrow_implicit_il_fb_call(symbol, param_name, called_fb_declaration); |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1333 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1334 |
/* Set/Reset semantics */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1335 |
narrow_conditional_operator(symbol); |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1336 |
/* set the datatype for the il_operand */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1337 |
if ((NULL != il_operand) && (il_operand->candidate_datatypes.size() > 0)) |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1338 |
set_il_operand_datatype(il_operand, il_operand->candidate_datatypes[0]); |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1339 |
return NULL; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1340 |
} |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1341 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1342 |
|
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1343 |
|
839
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1344 |
void *narrow_candidate_datatypes_c::narrow_store_operator(symbol_c *symbol) { |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1345 |
if (symbol->candidate_datatypes.size() == 1) { |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1346 |
symbol->datatype = symbol->candidate_datatypes[0]; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1347 |
/* set the desired datatype of the previous il instruction */ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1348 |
set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1349 |
/* In the case of the ST operator, we must set the datatype of the il_instruction_c object that points to this ST_operator_c ourselves, |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1350 |
* since the following il_instruction_c objects have not done it, as is normal/standard for other instructions! |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1351 |
*/ |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1352 |
current_il_instruction->datatype = symbol->datatype; |
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1353 |
} |
834
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
1354 |
|
783ef40344dd
Add support for FB call semantics of 'S' and 'R' IL operators!
mjsousa
parents:
827
diff
changeset
|
1355 |
/* set the datatype for the operand */ |
836
149398f525a7
make sure all IL operands are narrowed (datatype checking algorithm)
mjsousa
parents:
834
diff
changeset
|
1356 |
set_il_operand_datatype(il_operand, symbol->datatype); |
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
|
1357 |
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
|
1358 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1359 |
|
839
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1360 |
|
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1361 |
|
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1362 |
void *narrow_candidate_datatypes_c::visit( LD_operator_c *symbol) {return set_il_operand_datatype(il_operand, symbol->datatype);} |
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1363 |
void *narrow_candidate_datatypes_c::visit( LDN_operator_c *symbol) {return set_il_operand_datatype(il_operand, symbol->datatype);} |
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1364 |
|
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1365 |
void *narrow_candidate_datatypes_c::visit( ST_operator_c *symbol) {return narrow_store_operator(symbol);} |
99d9ef4d210b
Small code cleanup (move common code to a function)
mjsousa
parents:
838
diff
changeset
|
1366 |
void *narrow_candidate_datatypes_c::visit( STN_operator_c *symbol) {return narrow_store_operator(symbol);} |
838
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1367 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1368 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1369 |
/* NOTE: the standard allows syntax in which the NOT operator is followed by an optional <il_operand> |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1370 |
* NOT [<il_operand>] |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1371 |
* However, it does not define the semantic of the NOT operation when the <il_operand> is specified. |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1372 |
* We therefore consider it an error if an il_operand is specified! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1373 |
* This error will be detected in print_datatypes_error_c!! |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1374 |
*/ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1375 |
/* This operator does not change the data type, it simply inverts the bits in the ANT_BIT data types! */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1376 |
/* So, we merely set the desired datatype of the previous il instruction */ |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1377 |
void *narrow_candidate_datatypes_c::visit( NOT_operator_c *symbol) {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction);return NULL;} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1378 |
|
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1379 |
void *narrow_candidate_datatypes_c::visit( S_operator_c *symbol) {return narrow_S_and_R_operator (symbol, "S", symbol->called_fb_declaration);} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1380 |
void *narrow_candidate_datatypes_c::visit( R_operator_c *symbol) {return narrow_S_and_R_operator (symbol, "R", symbol->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
|
1381 |
|
456 | 1382 |
void *narrow_candidate_datatypes_c::visit( S1_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "S1", symbol->called_fb_declaration);} |
1383 |
void *narrow_candidate_datatypes_c::visit( R1_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "R1", symbol->called_fb_declaration);} |
|
1384 |
void *narrow_candidate_datatypes_c::visit( CLK_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "CLK", symbol->called_fb_declaration);} |
|
1385 |
void *narrow_candidate_datatypes_c::visit( CU_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "CU", symbol->called_fb_declaration);} |
|
1386 |
void *narrow_candidate_datatypes_c::visit( CD_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "CD", symbol->called_fb_declaration);} |
|
1387 |
void *narrow_candidate_datatypes_c::visit( PV_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "PV", symbol->called_fb_declaration);} |
|
1388 |
void *narrow_candidate_datatypes_c::visit( IN_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "IN", symbol->called_fb_declaration);} |
|
1389 |
void *narrow_candidate_datatypes_c::visit( PT_operator_c *symbol) {return narrow_implicit_il_fb_call(symbol, "PT", symbol->called_fb_declaration);} |
|
1390 |
||
481
16f943328696
Add 'widen' tables for AND, OR and XOR operations.
Mario de Sousa <msousa@fe.up.pt>
parents:
480
diff
changeset
|
1391 |
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
|
1392 |
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
|
1393 |
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
|
1394 |
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
|
1395 |
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
|
1396 |
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
|
1397 |
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
|
1398 |
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
|
1399 |
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
|
1400 |
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
|
1401 |
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
|
1402 |
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
|
1403 |
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
|
1404 |
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
|
1405 |
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
|
1406 |
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
|
1407 |
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
|
1408 |
|
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
|
1409 |
|
838
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1410 |
/* visitors to CAL_operator_c, CALC_operator_c and CALCN_operator_c are called from visit(il_fb_call_c *) {symbol->il_call_operator->accept(*this)} */ |
487 | 1411 |
/* 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 */ |
1412 |
void *narrow_candidate_datatypes_c::visit( CAL_operator_c *symbol) {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); return NULL;} |
|
1413 |
void *narrow_candidate_datatypes_c::visit( RET_operator_c *symbol) {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); return NULL;} |
|
1414 |
void *narrow_candidate_datatypes_c::visit( JMP_operator_c *symbol) {set_datatype_in_prev_il_instructions(symbol->datatype, fake_prev_il_instruction); return NULL;} |
|
838
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1415 |
void *narrow_candidate_datatypes_c::visit( CALC_operator_c *symbol) {return narrow_conditional_operator(symbol);} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1416 |
void *narrow_candidate_datatypes_c::visit(CALCN_operator_c *symbol) {return narrow_conditional_operator(symbol);} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1417 |
void *narrow_candidate_datatypes_c::visit( RETC_operator_c *symbol) {return narrow_conditional_operator(symbol);} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1418 |
void *narrow_candidate_datatypes_c::visit(RETCN_operator_c *symbol) {return narrow_conditional_operator(symbol);} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1419 |
void *narrow_candidate_datatypes_c::visit( JMPC_operator_c *symbol) {return narrow_conditional_operator(symbol);} |
13ea7c080018
Fix datatype analysis of conditional IL operators (CALC, CALCN, RETC, RETCN, JMPC, JMPCN, S and R)
mjsousa
parents:
836
diff
changeset
|
1420 |
void *narrow_candidate_datatypes_c::visit(JMPCN_operator_c *symbol) {return narrow_conditional_operator(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
|
1421 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1422 |
/* 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
|
1423 |
// 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
|
1424 |
/* 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
|
1425 |
// 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
|
1426 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1427 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1428 |
/***************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1429 |
/* 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
|
1430 |
/***************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1431 |
/***********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1432 |
/* 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
|
1433 |
/***********************/ |
933
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1434 |
/* SYM_REF1(deref_expression_c, exp) --> an extension to the IEC 61131-3 standard - based on the IEC 61131-3 v3 standard. Returns address of the varible! */ |
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1435 |
void *narrow_candidate_datatypes_c::visit(deref_expression_c *symbol) { |
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1436 |
for (unsigned int i = 0; i < symbol->exp->candidate_datatypes.size(); i++) { |
937
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1437 |
symbol_c *typ = symbol->exp->candidate_datatypes[i]; |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1438 |
symbol_c *ref = get_datatype_info_c::get_ref_to(typ); |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1439 |
if ( (get_datatype_info_c::is_ref_to(typ)) |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1440 |
&& (get_datatype_info_c::is_type_equal(search_base_type_c::get_basetype_decl(ref), symbol->datatype)) |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1441 |
) |
933
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1442 |
/* if it points to the required datatype for symbol, then that is the required datatype for symbol->exp */ |
937
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1443 |
symbol->exp->datatype = typ; |
933
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1444 |
} |
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1445 |
|
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1446 |
symbol->exp->accept(*this); |
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1447 |
return NULL; |
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1448 |
} |
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1449 |
|
76324f461aed
Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
919
diff
changeset
|
1450 |
|
936
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1451 |
/* SYM_REF1(deref_operator_c, exp) --> an extension to the IEC 61131-3 standard - based on the IEC 61131-3 v3 standard. Returns address of the varible! */ |
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1452 |
void *narrow_candidate_datatypes_c::visit(deref_operator_c *symbol) { |
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1453 |
for (unsigned int i = 0; i < symbol->exp->candidate_datatypes.size(); i++) { |
937
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1454 |
symbol_c *typ = symbol->exp->candidate_datatypes[i]; |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1455 |
symbol_c *ref = get_datatype_info_c::get_ref_to(typ); |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1456 |
if ( (get_datatype_info_c::is_ref_to(typ)) |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1457 |
&& (get_datatype_info_c::is_type_equal(search_base_type_c::get_basetype_decl(ref), symbol->datatype)) |
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1458 |
) |
936
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1459 |
/* if it points to the required datatype for symbol, then that is the required datatype for symbol->exp */ |
937
887e7d90445a
Fix bug with multple dereferencing (bool_var := bool_ptr_ptr^^;)
mjsousa
parents:
936
diff
changeset
|
1460 |
symbol->exp->datatype = typ; |
936
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1461 |
} |
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1462 |
|
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1463 |
symbol->exp->accept(*this); |
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1464 |
return NULL; |
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1465 |
} |
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1466 |
|
0f7bcc160568
Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset
|
1467 |
|
873
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1468 |
/* SYM_REF1(ref_expression_c, exp) --> an extension to the IEC 61131-3 standard - based on the IEC 61131-3 v3 standard. Returns address of the varible! */ |
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1469 |
void *narrow_candidate_datatypes_c::visit( ref_expression_c *symbol) { |
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1470 |
if (symbol->exp->candidate_datatypes.size() > 0) { |
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1471 |
symbol->exp->datatype = symbol->exp->candidate_datatypes[0]; /* just use the first possible datatype */ |
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1472 |
} |
910
a0518971127d
Narrow array subscripts correctly, even in the presence of other datatype errors (so we do not generate error messages for array subscripts that do not contain errors).
mjsousa
parents:
909
diff
changeset
|
1473 |
symbol->exp->accept(*this); |
873
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1474 |
return NULL; |
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1475 |
} |
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1476 |
|
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1477 |
|
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents:
854
diff
changeset
|
1478 |
|
652
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1479 |
/* allow_enums is FALSE by default!! |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1480 |
* deprecated_operation is NULL by default!! |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1481 |
* if (allow_enums) then consider that we are ectually processing an equ_expression or notequ_expression, where two enums of the same data type may also be legally compared |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1482 |
* e.g. symbol := l_expr == r_expr |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1483 |
* symbol := l_expr != r_expr |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1484 |
* In the above situation it is a legal operation when (l_expr.datatype == r_expr.datatype) && is_enumerated(r/l_expr.datatype) && is_bool(symbol.datatype) |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1485 |
*/ |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1486 |
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, bool allow_enums) { |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1487 |
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
|
1488 |
int count = 0; |
652
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1489 |
|
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1490 |
if (NULL != deprecated_operation) |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1491 |
*deprecated_operation = false; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1492 |
|
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1493 |
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
|
1494 |
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
|
1495 |
/* test widening compatibility */ |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1496 |
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
|
1497 |
r_type = r_expr->candidate_datatypes[j]; |
652
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1498 |
if (is_widening_compatible(widen_table, l_type, r_type, symbol->datatype, deprecated_operation)) { |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1499 |
l_expr->datatype = l_type; |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1500 |
r_expr->datatype = r_type; |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1501 |
count ++; |
919
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
910
diff
changeset
|
1502 |
} else if ( /* handle the special case of enumerations */ |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
910
diff
changeset
|
1503 |
(get_datatype_info_c::is_BOOL_compatible(symbol->datatype) && get_datatype_info_c::is_enumerated(l_type) && (l_type == r_type)) |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
910
diff
changeset
|
1504 |
/* handle the special case of comparison between REF_TO datatypes */ |
8da635655f37
Add support for the 'NULL' keyword, defined in version 3 of IEC 61131-3.
mjsousa
parents:
910
diff
changeset
|
1505 |
|| (get_datatype_info_c::is_BOOL_compatible(symbol->datatype) && get_datatype_info_c::is_ref_to (l_type) && get_datatype_info_c::is_type_equal(l_type, r_type))) { |
652
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1506 |
if (NULL != deprecated_operation) *deprecated_operation = false; |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1507 |
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
|
1508 |
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
|
1509 |
count ++; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1510 |
} |
652
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1511 |
|
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1512 |
} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1513 |
} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1514 |
// if (count > 1) ERROR; /* Since we also support SAFE data types, this assertion is not necessarily always tru! */ |
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
1515 |
if (get_datatype_info_c::is_type_valid(symbol->datatype) && (count <= 0)) ERROR; |
480
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1516 |
|
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1517 |
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
|
1518 |
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
|
1519 |
return NULL; |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1520 |
} |
8a58d7b8b26c
Add MOD widening table, and some code clean-ups.
Mario de Sousa <msousa@fe.up.pt>
parents:
478
diff
changeset
|
1521 |
|
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
|
1522 |
|
652
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1523 |
void *narrow_candidate_datatypes_c::narrow_equality_comparison(const struct widen_entry widen_table[], symbol_c *symbol, symbol_c *l_expr, symbol_c *r_expr, bool *deprecated_operation) { |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1524 |
return narrow_binary_expression(widen_table, symbol, l_expr, r_expr, deprecated_operation, true); |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1525 |
} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1526 |
|
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1527 |
|
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1528 |
void *narrow_candidate_datatypes_c::visit( or_expression_c *symbol) {return narrow_binary_expression ( widen_OR_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1529 |
void *narrow_candidate_datatypes_c::visit( xor_expression_c *symbol) {return narrow_binary_expression (widen_XOR_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1530 |
void *narrow_candidate_datatypes_c::visit( and_expression_c *symbol) {return narrow_binary_expression (widen_AND_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1531 |
|
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1532 |
void *narrow_candidate_datatypes_c::visit( equ_expression_c *symbol) {return narrow_equality_comparison(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1533 |
void *narrow_candidate_datatypes_c::visit(notequ_expression_c *symbol) {return narrow_equality_comparison(widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1534 |
void *narrow_candidate_datatypes_c::visit( lt_expression_c *symbol) {return narrow_binary_expression (widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1535 |
void *narrow_candidate_datatypes_c::visit( gt_expression_c *symbol) {return narrow_binary_expression (widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1536 |
void *narrow_candidate_datatypes_c::visit( le_expression_c *symbol) {return narrow_binary_expression (widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1537 |
void *narrow_candidate_datatypes_c::visit( ge_expression_c *symbol) {return narrow_binary_expression (widen_CMP_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1538 |
|
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1539 |
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);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1540 |
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);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1541 |
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);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1542 |
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);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1543 |
void *narrow_candidate_datatypes_c::visit( mod_expression_c *symbol) {return narrow_binary_expression (widen_MOD_table, symbol, symbol->l_exp, symbol->r_exp);} |
7fe1533d2260
Start adding support for data type checking of enums.
Mario de Sousa <msousa@fe.up.pt>
parents:
552
diff
changeset
|
1544 |
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
|
1545 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1546 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1547 |
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
|
1548 |
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
|
1549 |
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
|
1550 |
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
|
1551 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1552 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1553 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1554 |
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
|
1555 |
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
|
1556 |
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
|
1557 |
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
|
1558 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1559 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1560 |
|
438
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1561 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1562 |
/* 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
|
1563 |
/* 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
|
1564 |
/* 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
|
1565 |
// 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
|
1566 |
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
|
1567 |
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
|
1568 |
/* 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
|
1569 |
/* 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
|
1570 |
/* 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
|
1571 |
/* 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
|
1572 |
/* 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
|
1573 |
/* 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
|
1574 |
/* 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
|
1575 |
}; |
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1576 |
|
744b125d911e
Add support for semantic verification of function calls in IL.
Mario de Sousa <msousa@fe.up.pt>
parents:
428
diff
changeset
|
1577 |
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
|
1578 |
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
|
1579 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1580 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1581 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1582 |
/* 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
|
1583 |
/********************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1584 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1585 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1586 |
/*********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1587 |
/* 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
|
1588 |
/*********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1589 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1590 |
void *narrow_candidate_datatypes_c::visit(assignment_statement_c *symbol) { |
910
a0518971127d
Narrow array subscripts correctly, even in the presence of other datatype errors (so we do not generate error messages for array subscripts that do not contain errors).
mjsousa
parents:
909
diff
changeset
|
1591 |
if (symbol->candidate_datatypes.size() == 1) { |
a0518971127d
Narrow array subscripts correctly, even in the presence of other datatype errors (so we do not generate error messages for array subscripts that do not contain errors).
mjsousa
parents:
909
diff
changeset
|
1592 |
symbol->datatype = symbol->candidate_datatypes[0]; |
a0518971127d
Narrow array subscripts correctly, even in the presence of other datatype errors (so we do not generate error messages for array subscripts that do not contain errors).
mjsousa
parents:
909
diff
changeset
|
1593 |
symbol->l_exp->datatype = symbol->datatype; |
a0518971127d
Narrow array subscripts correctly, even in the presence of other datatype errors (so we do not generate error messages for array subscripts that do not contain errors).
mjsousa
parents:
909
diff
changeset
|
1594 |
symbol->r_exp->datatype = symbol->datatype; |
a0518971127d
Narrow array subscripts correctly, even in the presence of other datatype errors (so we do not generate error messages for array subscripts that do not contain errors).
mjsousa
parents:
909
diff
changeset
|
1595 |
} |
a0518971127d
Narrow array subscripts correctly, even in the presence of other datatype errors (so we do not generate error messages for array subscripts that do not contain errors).
mjsousa
parents:
909
diff
changeset
|
1596 |
/* give the chance of any expressions inside array subscripts to be narrowed correctly */ |
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
|
1597 |
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
|
1598 |
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
|
1599 |
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
|
1600 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1601 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1602 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1603 |
/*****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1604 |
/* 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
|
1605 |
/*****************************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1606 |
|
423
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1607 |
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
|
1608 |
/* 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
|
1609 |
* 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
|
1610 |
* 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
|
1611 |
* 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
|
1612 |
* 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
|
1613 |
* 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
|
1614 |
*/ |
423
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1615 |
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
|
1616 |
|
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
|
1617 |
/* 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
|
1618 |
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
|
1619 |
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
|
1620 |
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
|
1621 |
|
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1622 |
return NULL; |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1623 |
} |
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1624 |
|
f4a2d400ddbd
Adding support for semantic verification of FB calls in ST.
Mario de Sousa <msousa@fe.up.pt>
parents:
421
diff
changeset
|
1625 |
|
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
|
1626 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1627 |
/* 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
|
1628 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1629 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1630 |
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
|
1631 |
for(unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1632 |
if (get_datatype_info_c::is_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
|
1633 |
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
|
1634 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1635 |
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
|
1636 |
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
|
1637 |
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
|
1638 |
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
|
1639 |
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
|
1640 |
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
|
1641 |
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
|
1642 |
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
|
1643 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1644 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1645 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1646 |
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
|
1647 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1648 |
if (get_datatype_info_c::is_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
|
1649 |
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
|
1650 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1651 |
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
|
1652 |
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
|
1653 |
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
|
1654 |
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
|
1655 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1656 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1657 |
/* 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
|
1658 |
// 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
|
1659 |
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
|
1660 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1661 |
if ((get_datatype_info_c::is_ANY_INT(symbol->expression->candidate_datatypes[i])) |
854
13d0b67de111
Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
843
diff
changeset
|
1662 |
|| (get_datatype_info_c::is_enumerated(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
|
1663 |
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
|
1664 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1665 |
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
|
1666 |
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
|
1667 |
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
|
1668 |
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
|
1669 |
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
|
1670 |
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
|
1671 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1672 |
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
|
1673 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1674 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1675 |
/* 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
|
1676 |
// 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
|
1677 |
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
|
1678 |
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
|
1679 |
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
|
1680 |
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
|
1681 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1682 |
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
|
1683 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1684 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1685 |
/* 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
|
1686 |
// 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
|
1687 |
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
|
1688 |
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
|
1689 |
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
|
1690 |
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
|
1691 |
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
|
1692 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1693 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1694 |
// 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
|
1695 |
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
|
1696 |
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
|
1697 |
for (unsigned int k = 0; k < symbol->elements[i]->candidate_datatypes.size(); k++) { |
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
1698 |
if (get_datatype_info_c::is_type_equal(symbol->datatype, symbol->elements[i]->candidate_datatypes[k])) |
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
|
1699 |
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
|
1700 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1701 |
/* 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
|
1702 |
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
|
1703 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1704 |
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
|
1705 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1706 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1707 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1708 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1709 |
/* 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
|
1710 |
/********************************/ |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1711 |
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
|
1712 |
/* 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
|
1713 |
for(unsigned int i = 0; i < symbol->control_variable->candidate_datatypes.size(); i++) { |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1714 |
if (get_datatype_info_c::is_ANY_INT(symbol->control_variable->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
|
1715 |
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
|
1716 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1717 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1718 |
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
|
1719 |
/* 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
|
1720 |
for(unsigned int i = 0; i < symbol->beg_expression->candidate_datatypes.size(); i++) { |
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
1721 |
if (get_datatype_info_c::is_type_equal(symbol->control_variable->datatype,symbol->beg_expression->candidate_datatypes[i]) && |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1722 |
get_datatype_info_c::is_ANY_INT(symbol->beg_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
|
1723 |
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
|
1724 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1725 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1726 |
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
|
1727 |
/* 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
|
1728 |
for(unsigned int i = 0; i < symbol->end_expression->candidate_datatypes.size(); i++) { |
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
1729 |
if (get_datatype_info_c::is_type_equal(symbol->control_variable->datatype,symbol->end_expression->candidate_datatypes[i]) && |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1730 |
get_datatype_info_c::is_ANY_INT(symbol->end_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
|
1731 |
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
|
1732 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1733 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1734 |
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
|
1735 |
/* 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
|
1736 |
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
|
1737 |
for(unsigned int i = 0; i < symbol->by_expression->candidate_datatypes.size(); i++) { |
676
ca4f17211251
Move is_datatype_valid/equal() to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
675
diff
changeset
|
1738 |
if (get_datatype_info_c::is_type_equal(symbol->control_variable->datatype,symbol->by_expression->candidate_datatypes[i]) && |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1739 |
get_datatype_info_c::is_ANY_INT(symbol->by_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
|
1740 |
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
|
1741 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1742 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1743 |
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
|
1744 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1745 |
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
|
1746 |
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
|
1747 |
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
|
1748 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1749 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1750 |
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
|
1751 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1752 |
if(get_datatype_info_c::is_BOOL(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
|
1753 |
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
|
1754 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1755 |
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
|
1756 |
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
|
1757 |
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
|
1758 |
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
|
1759 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1760 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1761 |
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
|
1762 |
for (unsigned int i = 0; i < symbol->expression->candidate_datatypes.size(); i++) { |
666
8ba9ec4bae50
Add new get_datatype_info_c (preparing to remove search_expression_type_c)
Mario de Sousa <msousa@fe.up.pt>
parents:
661
diff
changeset
|
1763 |
if(get_datatype_info_c::is_BOOL(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
|
1764 |
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
|
1765 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1766 |
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
|
1767 |
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
|
1768 |
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
|
1769 |
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
|
1770 |
} |
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1771 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1772 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1773 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1774 |
|
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
diff
changeset
|
1775 |