1 /*

     2  *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3  *

     4  *  Copyright (C) 2009-2011  Mario de Sousa (msousa@fe.up.pt)

     5  *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6  *

     7  *  This program is free software: you can redistribute it and/or modify

     8  *  it under the terms of the GNU General Public License as published by

     9  *  the Free Software Foundation, either version 3 of the License, or

    10  *  (at your option) any later version.

    11  *

    12  *  This program is distributed in the hope that it will be useful,

    13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15  *  GNU General Public License for more details.

    16  *

    17  *  You should have received a copy of the GNU General Public License

    18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19  *

    20  *

    21  * This code is made available on the understanding that it will not be

    22  * used in safety-critical situations without a full and competent review.

    23  */

    24 

    25 /*

    26  * An IEC 61131-3 compiler.

    27  *

    28  * Based on the

    29  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    30  *

    31  */

    32 

    33 

    34 /* Verify whether the semantic rules of data type compatibility are being followed.

    35  *

    36  * For example:

    37  */

    38 

    39 #include "visit_expression_type.hh"

    40 #include <typeinfo>

    41 #include <list>

    42 #include <string>

    43 #include <string.h>

    44 #include <strings.h>

    45 

    46 

    47 #define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order)   ? (symbol1) : (symbol2))

    48 #define  LAST_(symbol1, symbol2) (((symbol1)->last_order  > (symbol2)->last_order)    ? (symbol1) : (symbol2))

    49 

    50 #define STAGE3_ERROR(symbol1, symbol2, ...) {                                          \

    51     fprintf(stderr, "%s:%d-%d..%d-%d: error : ",                                       \

    52            FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column, \

    53                                                 LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column); \

    54     fprintf(stderr, __VA_ARGS__);                                                      \

    55     fprintf(stderr, "\n");                                                             \

    56     il_error = true;                                                                   \

    57     error_found = true;                                                                \

    58   }

    59 

    60 

    61 /* set to 1 to see debug info during execution */

    62 static int debug = 0;

    63 

    64 

    65 void *visit_expression_type_c::visit(program_declaration_c *symbol) {

    66   search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    67   symbol->var_declarations->accept(*this);

    68   if (debug) printf("checking semantics in body of program %s\n", ((token_c *)(symbol->program_type_name))->value);

    69   il_parenthesis_level = 0;

    70   il_error = false;

    71   il_default_variable_type = NULL;

    72   symbol->function_block_body->accept(*this);

    73   il_default_variable_type = NULL;

    74   delete search_varfb_instance_type;

    75   search_varfb_instance_type = NULL;

    76   return NULL;

    77 }

    78 

    79 void *visit_expression_type_c::visit(function_declaration_c *symbol) {

    80   search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    81   symbol->var_declarations_list->accept(*this);

    82   if (debug) printf("checking semantics in body of function %s\n", ((token_c *)(symbol->derived_function_name))->value);

    83   il_parenthesis_level = 0;

    84   il_error = false;

    85   il_default_variable_type = NULL;

    86   symbol->function_body->accept(*this);

    87   il_default_variable_type = NULL;

    88   delete search_varfb_instance_type;

    89   search_varfb_instance_type = NULL;

    90   return NULL;

    91 }

    92 

    93 void *visit_expression_type_c::visit(function_block_declaration_c *symbol) {

    94   search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    95   symbol->var_declarations->accept(*this);

    96   if (debug) printf("checking semantics in body of FB %s\n", ((token_c *)(symbol->fblock_name))->value);

    97   il_parenthesis_level = 0;

    98   il_error = false;

    99   il_default_variable_type = NULL;

   100   symbol->fblock_body->accept(*this);

   101   il_default_variable_type = NULL;

   102   delete search_varfb_instance_type;

   103   search_varfb_instance_type = NULL;

   104   return NULL;

   105 }

   106 

   107 

   108 

   109 

   110 

   111 

   112 

   113 

   114 

   115 visit_expression_type_c::visit_expression_type_c(symbol_c *ignore) {

   116   error_found = false;

   117 }

   118 

   119 visit_expression_type_c::~visit_expression_type_c(void) {

   120 }

   121 

   122 bool visit_expression_type_c::get_error_found(void) {

   123   return error_found;

   124 }

   125 

   126 

   127 

   128 /* NOTE on data type handling and literals...

   129  * ==========================================

   130  *

   131  * Literals that are explicitly type cast 

   132  *   e.g.:   BYTE#42

   133  *           INT#65

   134  *           TIME#45h23m

   135  *               etc...

   136  *  are NOT considered literals in the following code.

   137  *  Since they are type cast, and their data type is fixed and well known,

   138  *  they are treated as a variable of that data type (except when determining lvalues)

   139  *  In other words, when calling search_constant_type_c on these constants, it returns

   140  *  a xxxxx_type_name_c, and not one of the xxxx_literal_c ! 

   141  *

   142  *  When the following code handles a literal, it is really a literal of unknown data type.

   143  *    e.g.   42, may be considered an int, a byte, a word, etc... 

   144  *

   145  * NOTE: type_symbol == NULL is valid!

   146  *       This will occur, for example, when and undefined/undeclared symbolic_variable is used in the program.

   147  *       This will not be of any type, so we always return false.

   148  */

   149 

   150 /* A helper function... */

   151 bool visit_expression_type_c::is_ANY_ELEMENTARY_type(symbol_c *type_symbol) {

   152   if (type_symbol == NULL) {return false;}

   153   return is_ANY_MAGNITUDE_type(type_symbol)

   154       || is_ANY_BIT_type      (type_symbol)

   155       || is_ANY_STRING_type   (type_symbol)

   156       || is_ANY_DATE_type     (type_symbol);

   157 }

   158 

   159 /* A helper function... */

   160 bool visit_expression_type_c::is_ANY_SAFEELEMENTARY_type(symbol_c *type_symbol) {

   161   if (type_symbol == NULL) {return false;}

   162   return is_ANY_SAFEMAGNITUDE_type(type_symbol)

   163       || is_ANY_SAFEBIT_type      (type_symbol)

   164       || is_ANY_SAFESTRING_type   (type_symbol)

   165       || is_ANY_SAFEDATE_type     (type_symbol);

   166 }

   167 

   168 /* A helper function... */

   169 bool visit_expression_type_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   170   if (type_symbol == NULL) {return false;}

   171   /* NOTE: doing 

   172    *          return is_ANY_SAFEELEMENTARY_type() || is_ANY_ELEMENTARY_type()

   173    *       is incorrect, as the literals would never be considered compatible...

   174    */

   175   return is_ANY_MAGNITUDE_compatible(type_symbol)

   176       || is_ANY_BIT_compatible      (type_symbol)

   177       || is_ANY_STRING_compatible   (type_symbol)

   178       || is_ANY_DATE_compatible     (type_symbol);

   179 }

   180 

   181 

   182 /* A helper function... */

   183 bool visit_expression_type_c::is_ANY_MAGNITUDE_type(symbol_c *type_symbol) {

   184   if (type_symbol == NULL) {return false;}

   185   if (typeid(*type_symbol) == typeid(time_type_name_c)) {return true;}

   186   return is_ANY_NUM_type(type_symbol);

   187 }

   188 

   189 /* A helper function... */

   190 bool visit_expression_type_c::is_ANY_SAFEMAGNITUDE_type(symbol_c *type_symbol) {

   191   if (type_symbol == NULL) {return false;}

   192   if (typeid(*type_symbol) == typeid(safetime_type_name_c)) {return true;}

   193   return is_ANY_SAFENUM_type(type_symbol);

   194 }

   195 

   196 /* A helper function... */

   197 bool visit_expression_type_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   198   if (type_symbol == NULL) {return false;}

   199   if (is_ANY_MAGNITUDE_type    (type_symbol))              {return true;}

   200   if (is_ANY_SAFEMAGNITUDE_type(type_symbol))              {return true;}

   201 

   202   return is_ANY_NUM_compatible(type_symbol);

   203 }

   204 

   205 /* A helper function... */

   206 bool visit_expression_type_c::is_ANY_NUM_type(symbol_c *type_symbol) {

   207   if (type_symbol == NULL) {return false;}

   208   if (is_ANY_REAL_type(type_symbol))                       {return true;}

   209   if (is_ANY_INT_type(type_symbol))                        {return true;}

   210   return false;

   211 }

   212 

   213 /* A helper function... */

   214 bool visit_expression_type_c::is_ANY_SAFENUM_type(symbol_c *type_symbol) {

   215   if (type_symbol == NULL) {return false;}

   216   return is_ANY_SAFEREAL_type(type_symbol) 

   217       || is_ANY_SAFEINT_type (type_symbol);

   218 }

   219 

   220 /* A helper function... */

   221 bool visit_expression_type_c::is_ANY_NUM_compatible(symbol_c *type_symbol) {

   222   if (type_symbol == NULL) {return false;}

   223   if (is_ANY_REAL_compatible(type_symbol))                       {return true;}

   224   if (is_ANY_INT_compatible(type_symbol))                        {return true;}

   225   return false;  

   226 }

   227 

   228 /* A helper function... */

   229 bool visit_expression_type_c::is_ANY_DATE_type(symbol_c *type_symbol) {

   230   if (type_symbol == NULL) {return false;}

   231   if (typeid(*type_symbol) == typeid(date_type_name_c)) {return true;}

   232   if (typeid(*type_symbol) == typeid(tod_type_name_c))  {return true;}

   233   if (typeid(*type_symbol) == typeid(dt_type_name_c))   {return true;}

   234   return false;

   235 }

   236 

   237 /* A helper function... */

   238 bool visit_expression_type_c::is_ANY_SAFEDATE_type(symbol_c *type_symbol) {

   239   if (type_symbol == NULL) {return false;}

   240   if (typeid(*type_symbol) == typeid(safedate_type_name_c)) {return true;}

   241   if (typeid(*type_symbol) == typeid(safetod_type_name_c))  {return true;}

   242   if (typeid(*type_symbol) == typeid(safedt_type_name_c))   {return true;}

   243   return false;

   244 }

   245 

   246 /* A helper function... */

   247 bool visit_expression_type_c::is_ANY_DATE_compatible(symbol_c *type_symbol) {

   248   if (type_symbol == NULL) {return false;}

   249   if (is_ANY_DATE_type    (type_symbol))              {return true;}

   250   if (is_ANY_SAFEDATE_type(type_symbol))              {return true;}

   251   return false;

   252 }

   253 

   254 /* A helper function... */

   255 bool visit_expression_type_c::is_ANY_STRING_type(symbol_c *type_symbol) {

   256   if (type_symbol == NULL) {return false;}

   257   if (typeid(*type_symbol) == typeid(string_type_name_c)) {return true;}

   258   if (typeid(*type_symbol) == typeid(wstring_type_name_c)) {return true;}

   259 // TODO literal_string ???

   260   return false;

   261 }

   262 

   263 /* A helper function... */

   264 bool visit_expression_type_c::is_ANY_SAFESTRING_type(symbol_c *type_symbol) {

   265   if (type_symbol == NULL) {return false;}

   266   if (typeid(*type_symbol) == typeid(safestring_type_name_c)) {return true;}

   267   if (typeid(*type_symbol) == typeid(safewstring_type_name_c)) {return true;}

   268   return false;

   269 }

   270 

   271 /* A helper function... */

   272 bool visit_expression_type_c::is_ANY_STRING_compatible(symbol_c *type_symbol) {

   273   if (type_symbol == NULL) {return false;}

   274   if (is_ANY_STRING_type    (type_symbol))              {return true;}

   275   if (is_ANY_SAFESTRING_type(type_symbol))              {return true;}

   276   return false;

   277 }

   278 

   279 /* A helper function... */

   280 bool visit_expression_type_c::is_ANY_INT_type(symbol_c *type_symbol) {

   281   if (type_symbol == NULL) {return false;}

   282   if (typeid(*type_symbol) == typeid(sint_type_name_c))  {return true;}

   283   if (typeid(*type_symbol) == typeid(int_type_name_c))   {return true;}

   284   if (typeid(*type_symbol) == typeid(dint_type_name_c))  {return true;}

   285   if (typeid(*type_symbol) == typeid(lint_type_name_c))  {return true;}

   286   if (typeid(*type_symbol) == typeid(usint_type_name_c)) {return true;}

   287   if (typeid(*type_symbol) == typeid(uint_type_name_c))  {return true;}

   288   if (typeid(*type_symbol) == typeid(udint_type_name_c)) {return true;}

   289   if (typeid(*type_symbol) == typeid(ulint_type_name_c)) {return true;}

   290   return false;

   291 }

   292 

   293 /* A helper function... */

   294 bool visit_expression_type_c::is_ANY_SAFEINT_type(symbol_c *type_symbol) {

   295   if (type_symbol == NULL) {return false;}

   296   if (typeid(*type_symbol) == typeid(safesint_type_name_c))  {return true;}

   297   if (typeid(*type_symbol) == typeid(safeint_type_name_c))   {return true;}

   298   if (typeid(*type_symbol) == typeid(safedint_type_name_c))  {return true;}

   299   if (typeid(*type_symbol) == typeid(safelint_type_name_c))  {return true;}

   300   if (typeid(*type_symbol) == typeid(safeusint_type_name_c)) {return true;}

   301   if (typeid(*type_symbol) == typeid(safeuint_type_name_c))  {return true;}

   302   if (typeid(*type_symbol) == typeid(safeudint_type_name_c)) {return true;}

   303   if (typeid(*type_symbol) == typeid(safeulint_type_name_c)) {return true;}

   304   return false;

   305 }

   306 

   307 /* A helper function... */

   308 bool visit_expression_type_c::is_ANY_INT_compatible(symbol_c *type_symbol) {

   309   if (type_symbol == NULL) {return false;}

   310   if (is_ANY_INT_type    (type_symbol))              {return true;}

   311   if (is_ANY_SAFEINT_type(type_symbol))              {return true;}

   312   if (is_literal_integer_type(type_symbol))          {return true;}

   313   return false;

   314 }

   315 

   316 /* A helper function... */

   317 bool visit_expression_type_c::is_ANY_REAL_type(symbol_c *type_symbol) {

   318   if (type_symbol == NULL) {return false;}

   319   if (typeid(*type_symbol) == typeid(real_type_name_c))  {return true;}

   320   if (typeid(*type_symbol) == typeid(lreal_type_name_c)) {return true;}

   321   return false;

   322 }

   323 

   324 /* A helper function... */

   325 bool visit_expression_type_c::is_ANY_SAFEREAL_type(symbol_c *type_symbol) {

   326   if (type_symbol == NULL) {return false;}

   327   if (typeid(*type_symbol) == typeid(safereal_type_name_c))  {return true;}

   328   if (typeid(*type_symbol) == typeid(safelreal_type_name_c)) {return true;}

   329   return false;

   330 }

   331 

   332 /* A helper function... */

   333 bool visit_expression_type_c::is_ANY_REAL_compatible(symbol_c *type_symbol) {

   334   if (type_symbol == NULL) {return false;}

   335   if (is_ANY_REAL_type    (type_symbol))              {return true;}

   336   if (is_ANY_SAFEREAL_type(type_symbol))              {return true;}

   337   if (is_literal_real_type(type_symbol))              {return true;}

   338   return false;

   339 }

   340 

   341 /* A helper function... */

   342 bool visit_expression_type_c::is_ANY_BIT_type(symbol_c *type_symbol) {

   343   if (type_symbol == NULL) {return false;}

   344   if (typeid(*type_symbol) == typeid(bool_type_name_c))     {return true;}

   345   if (typeid(*type_symbol) == typeid(byte_type_name_c))     {return true;}

   346   if (typeid(*type_symbol) == typeid(word_type_name_c))     {return true;}

   347   if (typeid(*type_symbol) == typeid(dword_type_name_c))    {return true;}

   348   if (typeid(*type_symbol) == typeid(lword_type_name_c))    {return true;}

   349   return false;

   350 }

   351 

   352 /* A helper function... */

   353 bool visit_expression_type_c::is_ANY_SAFEBIT_type(symbol_c *type_symbol) {

   354   if (type_symbol == NULL) {return false;}

   355   if (typeid(*type_symbol) == typeid(safebool_type_name_c))     {return true;}

   356   if (typeid(*type_symbol) == typeid(safebyte_type_name_c))     {return true;}

   357   if (typeid(*type_symbol) == typeid(safeword_type_name_c))     {return true;}

   358   if (typeid(*type_symbol) == typeid(safedword_type_name_c))    {return true;}

   359   if (typeid(*type_symbol) == typeid(safelword_type_name_c))    {return true;}

   360   return false;

   361 }

   362 

   363 /* A helper function... */

   364 bool visit_expression_type_c::is_ANY_BIT_compatible(symbol_c *type_symbol) {

   365   if (type_symbol == NULL) {return false;}

   366   if (is_ANY_BIT_type    (type_symbol))              {return true;}

   367   if (is_ANY_SAFEBIT_type(type_symbol))              {return true;}

   368   if (is_nonneg_literal_integer_type(type_symbol))   {return true;}

   369   if (is_literal_bool_type(type_symbol))             {return true;}

   370   return false;

   371 }

   372 

   373 /* A helper function... */

   374 bool visit_expression_type_c::is_BOOL_type(symbol_c *type_symbol) {

   375   if (type_symbol == NULL) {return false;}

   376   if (typeid(*type_symbol) == typeid(bool_type_name_c))      {return true;}

   377   return false;

   378 }

   379 

   380 /* A helper function... */

   381 bool visit_expression_type_c::is_SAFEBOOL_type(symbol_c *type_symbol){

   382   if (type_symbol == NULL) {return false;}

   383   if (typeid(*type_symbol) == typeid(safebool_type_name_c))  {return true;}

   384   return false;  

   385 }

   386 

   387 /* A helper function... */

   388 bool visit_expression_type_c::is_ANY_BOOL_compatible(symbol_c *type_symbol) {

   389   if (type_symbol == NULL) {return false;}

   390   if (is_BOOL_type    (type_symbol))              {return true;}

   391   if (is_SAFEBOOL_type(type_symbol))              {return true;}

   392   if (is_literal_bool_type(type_symbol))              {return true;}

   393   return false;

   394 }

   395 

   396 

   397 #define is_type(type_name_symbol, type_name_class)  ((type_name_symbol == NULL) ? false : (typeid(*type_name_symbol) == typeid(type_name_class)))

   398 

   399 

   400 #define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)

   401 

   402 

   403 /* A helper function... */

   404 bool visit_expression_type_c::is_literal_integer_type(symbol_c *type_symbol) {

   405   if (type_symbol == NULL) {return false;}

   406   if (typeid(*type_symbol) == typeid(neg_integer_c))        {return true;}

   407   return is_nonneg_literal_integer_type(type_symbol);

   408 }

   409 

   410 

   411 /* A helper function... */

   412 bool visit_expression_type_c::is_nonneg_literal_integer_type(symbol_c *type_symbol) {

   413   if (type_symbol == NULL) {return false;}

   414   if (typeid(*type_symbol) == typeid(integer_c))        {return true;}

   415   if (typeid(*type_symbol) == typeid(binary_integer_c)) {return true;}

   416   if (typeid(*type_symbol) == typeid(octal_integer_c))  {return true;}

   417   if (typeid(*type_symbol) == typeid(hex_integer_c))    {return true;}

   418   return false;

   419 }

   420 

   421 

   422 /* A helper function... */

   423 bool visit_expression_type_c::is_literal_real_type(symbol_c *type_symbol) {

   424   if (type_symbol == NULL) {return false;}

   425   if (typeid(*type_symbol) == typeid(real_c))     {return true;}

   426   if (typeid(*type_symbol) == typeid(neg_real_c)) {return true;}

   427   return false;

   428 }

   429 

   430 

   431 /* A helper function... */

   432 bool visit_expression_type_c::is_literal_bool_type(symbol_c *type_symbol) {

   433   bool_type_name_c bool_t;

   434 

   435   if (type_symbol == NULL) {return false;}

   436   if (typeid(*type_symbol) == typeid(boolean_true_c))    {return true;}

   437   if (typeid(*type_symbol) == typeid(boolean_false_c))   {return true;}

   438   if (is_nonneg_literal_integer_type(type_symbol))

   439     if (sizeoftype(&bool_t) >= sizeoftype(type_symbol))  {return true;}

   440   return false;

   441 }

   442 

   443 bool visit_expression_type_c::is_ANY_ELEMENTARY_OR_ENUMERATED_compatible(symbol_c *type_symbol) {

   444   if (type_symbol == NULL) {return false;}

   445   if (search_base_type.type_is_enumerated(type_symbol)) {return true;}

   446   return is_ANY_ELEMENTARY_compatible(type_symbol);

   447 }

   448 

   449 

   450 /* Determine the common data type between two data types.

   451  * If no common data type found, return NULL.

   452  *

   453  * If data types are identical, return the first (actually any would do...).

   454  * If any of the data types is a literal, we confirm that 

   455  *   the literal uses less bits than the fixed size data type.

   456  *   e.g. BYTE and 1024 returns NULL

   457  *        BYTE and 255  returns BYTE

   458  *

   459  * If two literals, then return the literal that requires more bits...

   460  */

   461 

   462 symbol_c *visit_expression_type_c::common_type__(symbol_c *first_type, symbol_c *second_type) {

   463   if (first_type == NULL && second_type == NULL) {return NULL;}

   464   if (first_type == NULL)  {return second_type;}

   465   if (second_type == NULL) {return first_type;}

   466 

   467   if (is_literal_integer_type(first_type) && is_literal_integer_type(second_type))

   468     {return ((sizeoftype(first_type) > sizeoftype(second_type))? first_type:second_type);}

   469 

   470   if (is_literal_real_type(first_type) && is_literal_real_type(second_type))

   471     {return ((sizeoftype(first_type) > sizeoftype(second_type))? first_type:second_type);}

   472 

   473   if (is_literal_bool_type(first_type) && is_literal_bool_type(second_type))

   474     {return first_type;}

   475 

   476   /* The following check can only be made after the is_literal_XXXX checks */

   477   /* When two literals of the same type, with identical typeid's are checked,

   478    * we must return the one that occupies more bits... This is done above.

   479    */

   480   if (typeid(*first_type) == typeid(*second_type)) {return first_type;}

   481 

   482   /* NOTE Although a BOOL is also an ANY_BIT, we must check it explicitly since some

   483    *       literal bool values are not literal integers...

   484    */ 

   485   if (is_BOOL_type(first_type)        && is_literal_bool_type(second_type))    {return first_type;}

   486   if (is_BOOL_type(second_type)       && is_literal_bool_type(first_type))     {return second_type;}

   487 

   488   if (is_SAFEBOOL_type(first_type)    && is_literal_bool_type(second_type))    {return first_type;}

   489   if (is_SAFEBOOL_type(second_type)   && is_literal_bool_type(first_type))     {return second_type;}

   490 

   491   if (is_SAFEBOOL_type(first_type)    && is_BOOL_type(second_type))            {return second_type;}

   492   if (is_SAFEBOOL_type(second_type)   && is_BOOL_type(first_type))             {return first_type;}

   493 

   494   if (is_ANY_BIT_type(first_type)     && is_nonneg_literal_integer_type(second_type))

   495     {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   496   if (is_ANY_BIT_type(second_type)    && is_nonneg_literal_integer_type(first_type))

   497     {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   498 

   499   if (is_ANY_SAFEBIT_type(first_type)     && is_nonneg_literal_integer_type(second_type))

   500     {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   501   if (is_ANY_SAFEBIT_type(second_type)    && is_nonneg_literal_integer_type(first_type))

   502     {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   503 

   504   if  (is_ANY_SAFEBIT_type(first_type)    && is_ANY_BIT_type(second_type))

   505     {return ((sizeoftype(first_type) == sizeoftype(second_type))? second_type:NULL);}

   506   if  (is_ANY_SAFEBIT_type(second_type)   && is_ANY_BIT_type(first_type))

   507     {return ((sizeoftype(first_type) == sizeoftype(second_type))? first_type :NULL);}

   508 

   509   if (is_ANY_INT_type(first_type)     && is_literal_integer_type(second_type))

   510     {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   511   if (is_ANY_INT_type(second_type)    && is_literal_integer_type(first_type))

   512     {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   513 

   514   if (is_ANY_SAFEINT_type(first_type)     && is_literal_integer_type(second_type))

   515     {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   516   if (is_ANY_SAFEINT_type(second_type)    && is_literal_integer_type(first_type))

   517     {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   518 

   519   if  (is_ANY_SAFEINT_type(first_type)    && is_ANY_INT_type(second_type))

   520     {return ((sizeoftype(first_type) == sizeoftype(second_type))? second_type:NULL);}

   521   if  (is_ANY_SAFEINT_type(second_type)   && is_ANY_INT_type(first_type))

   522     {return ((sizeoftype(first_type) == sizeoftype(second_type))? first_type :NULL);}

   523 

   524   if (is_ANY_REAL_type(first_type)    && is_literal_real_type(second_type))

   525     {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   526   if (is_ANY_REAL_type(second_type)   && is_literal_real_type(first_type))

   527     {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   528 

   529   if (is_ANY_SAFEREAL_type(first_type)    && is_literal_real_type(second_type))

   530     {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   531   if (is_ANY_SAFEREAL_type(second_type)   && is_literal_real_type(first_type))

   532     {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   533 

   534   if  (is_ANY_SAFEREAL_type(first_type)    && is_ANY_REAL_type(second_type))

   535     {return ((sizeoftype(first_type) == sizeoftype(second_type))? second_type:NULL);}

   536   if  (is_ANY_SAFEREAL_type(second_type)   && is_ANY_REAL_type(first_type))

   537     {return ((sizeoftype(first_type) == sizeoftype(second_type))? first_type :NULL);}

   538 

   539   /* the Time and Date types... */

   540   if (is_type(first_type,  safetime_type_name_c) && is_type(second_type, time_type_name_c))  {return second_type;}

   541   if (is_type(second_type, safetime_type_name_c) && is_type( first_type, time_type_name_c))  {return  first_type;}

   542 

   543   if (is_type(first_type,  safedate_type_name_c) && is_type(second_type, date_type_name_c))  {return second_type;}

   544   if (is_type(second_type, safedate_type_name_c) && is_type( first_type, date_type_name_c))  {return  first_type;}

   545 

   546   if (is_type(first_type,  safedt_type_name_c)   && is_type(second_type, dt_type_name_c))    {return second_type;}

   547   if (is_type(second_type, safedt_type_name_c)   && is_type( first_type, dt_type_name_c))    {return  first_type;}

   548 

   549   if (is_type(first_type,  safetod_type_name_c)  && is_type(second_type, tod_type_name_c))   {return second_type;}

   550   if (is_type(second_type, safetod_type_name_c)  && is_type( first_type, tod_type_name_c))   {return  first_type;}

   551 

   552   /* no common type */

   553   return NULL;

   554 }

   555 

   556 /* Determine the common data type between two data types.

   557  * Unlike the common_type__() function, we stop the compiler with an ERROR

   558  *  if no common data type is found.

   559  */

   560 symbol_c *visit_expression_type_c::common_type(symbol_c *first_type, symbol_c *second_type) {

   561 /*  

   562   symbol_c *res = common_type__(first_type, second_type);

   563   if (NULL == res) ERROR;

   564   return res;

   565 */

   566   return common_type__(first_type, second_type);

   567 }

   568 

   569 

   570 /* Return TRUE if the second (value) data type may be assigned to a variable of the first (variable) data type

   571  * such as: 

   572  *     var_type     value_type

   573  *    BOOL           BYTE#7     -> returns false

   574  *    INT            INT#7      -> returns true

   575  *    INT            7          -> returns true

   576  *    REAL           7.89       -> returns true

   577  *    REAL           7          -> returns true

   578  *    INT            7.89       -> returns false

   579  *    SAFEBOOL       BOOL#1     -> returns false   !!!

   580  *   etc...

   581  *

   582  * NOTE: It is assumed that the var_type is the data type of an lvalue

   583  */

   584 bool visit_expression_type_c::is_valid_assignment(symbol_c *var_type, symbol_c *value_type) {

   585   if (var_type == NULL)   {/* STAGE3_ERROR(value_type, value_type, "Var_type   == NULL"); */ return false;}

   586   if (value_type == NULL) {/* STAGE3_ERROR(var_type,   var_type,   "Value_type == NULL"); */ return false;}

   587 

   588   symbol_c *common_type = common_type__(var_type, value_type);

   589   if (NULL == common_type)

   590     return false;

   591   return (typeid(*var_type) == typeid(*common_type));

   592 }

   593 

   594 

   595 /* Return TRUE if there is a common data type, otherwise return FALSE

   596  * i.e., return TRUE if both data types may be used simultaneously in an expression

   597  * such as:

   598  *    BOOL#0     AND BYTE#7  -> returns false

   599  *    0          AND BYTE#7  -> returns true

   600  *    INT#10     AND INT#7   -> returns true

   601  *    INT#10     AND 7       -> returns true

   602  *    REAL#34.3  AND 7.89    -> returns true

   603  *    REAL#34.3  AND 7       -> returns true

   604  *    INT#10     AND 7.89    -> returns false

   605  *    SAFEBOOL#0 AND BOOL#1  -> returns true   !!!

   606  *   etc...

   607  */

   608 bool visit_expression_type_c::is_compatible_type(symbol_c *first_type, symbol_c *second_type) {

   609   if (first_type == NULL || second_type == NULL) {return false;}

   610   return (NULL != common_type__(first_type, second_type));

   611 }

   612 

   613 

   614 

   615 

   616 /* A helper function... */

   617 /*

   618 symbol_c *visit_expression_type_c::compute_boolean_expression(symbol_c *left_type, symbol_c *right_type,

   619                                                               is_data_type_t is_data_type) {

   620 */

   621 symbol_c *visit_expression_type_c::compute_expression(symbol_c *left_type,      symbol_c *right_type,     is_data_type_t is_data_type,

   622 						      symbol_c *left_expr, symbol_c *right_expr) {

   623   bool error = false;

   624 

   625   if (!(this->*is_data_type)(left_type)) {

   626     if (debug) printf("visit_expression_type_c::compute_expression(): invalid left_type\n");

   627     if (left_expr != NULL)

   628       STAGE3_ERROR(left_expr, left_expr, "Invalid data type of operand, or of data resulting from previous IL instructions.");

   629     error = true;

   630   }

   631   if (!(this->*is_data_type)(right_type)) {

   632     if (debug) printf("visit_expression_type_c::compute_expression(): invalid right_type\n");

   633     if (right_expr != NULL)

   634       STAGE3_ERROR(right_expr, right_expr, "Invalid data type of operand.");

   635     error = true;

   636   }

   637   if (!is_compatible_type(left_type, right_type)) {

   638     if (debug) printf("visit_expression_type_c::compute_expression(): left_type & right_type are incompatible\n");

   639     if ((left_expr != NULL) && (right_expr != NULL))

   640       STAGE3_ERROR(left_expr, right_expr, "Type mismatch between operands.");

   641     error = true;

   642   }

   643 

   644   if (error)

   645     return NULL;

   646   else

   647     return common_type(left_type, right_type);

   648 }

   649 

   650 

   651 

   652 

   653 /* A helper function... */

   654 /* check the semantics of a FB or Function non-formal call */

   655 /* e.g. foo(1, 2, 3, 4);  */

   656 /* If error_count pointer is != NULL, we do not really print out the errors,

   657  * but rather only count how many errors were found.

   658  * This is used to support overloaded functions, where we have to check each possible

   659  * function, one at a time, untill we find a function call without any errors.

   660  */

   661 void visit_expression_type_c::check_nonformal_call(symbol_c *f_call, symbol_c *f_decl, bool use_il_defvar, int *error_count) {

   662   symbol_c *call_param_value, *call_param_type, *param_type;

   663   identifier_c *param_name;

   664   function_param_iterator_c       fp_iterator(f_decl);

   665   function_call_param_iterator_c fcp_iterator(f_call);

   666   int extensible_parameter_highest_index = -1;

   667   

   668   /* reset error counter */

   669   if (error_count != NULL) *error_count = 0;

   670   /* if use_il_defvar, then the first parameter for the call comes from the il_default_variable */

   671   if (use_il_defvar) {

   672     /* The first parameter of the function corresponds to the il_default_variable_type of the function call */

   673     do {

   674       param_name = fp_iterator.next();

   675       if(param_name == NULL) break;

   676       /*  The EN and ENO parameters are default parameters.

   677        *  In the non-formal invocation of a function there can be no assignment of

   678        * values to these parameters. Therefore, we ignore the parameters declared

   679        * in the function.

   680        */

   681     } while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));

   682     /* If the function does not have any parameters (param_name == NULL)

   683      * then we cannot compare its type with the il_default_variable_type.

   684      *

   685      * However, I (Mario) think this is invalid syntax, as it seems to me all functions must

   686      * have at least one parameter.

   687      * However, we will make this semantic verification consider it possible, as later

   688      * versions of the standard may change that syntax.

   689      * So, instead of generating a syntax error message, we simply check whether the call

   690      * is passing any more parameters besides the default variable (the il default variable may be ignored

   691      * in this case, and not consider it as being a parameter being passed to the function).

   692      * If it does, then we have found a semantic error, otherwise the function call is 

   693      * correct, and we simply return.

   694      */

   695     if(param_name == NULL) {

   696       if (fcp_iterator.next_nf() != NULL)

   697         STAGE3_ERROR(f_call, f_call, "Too many parameters in function/FB call.");

   698       return;

   699     } else { 

   700       /* param_name != NULL */

   701       param_type = fp_iterator.param_type();

   702       if(!is_valid_assignment(param_type, il_default_variable_type)) {

   703         if (error_count != NULL) (*error_count)++;

   704         else STAGE3_ERROR(f_call, f_call, "In function/FB call, first parameter has invalid data type.");

   705       }

   706     }

   707     

   708     /* the fisrt parameter (il_def_variable) is correct */

   709     if (extensible_parameter_highest_index < fp_iterator.extensible_param_index()) {

   710       extensible_parameter_highest_index = fp_iterator.extensible_param_index();

   711     }

   712   } // if (use_il_defvar)

   713   

   714   

   715 

   716   /* Iterating through the non-formal parameters of the function call */

   717   while((call_param_value = fcp_iterator.next_nf()) != NULL) {

   718     /* Obtaining the type of the value being passed in the function call */

   719     call_param_type = base_type((symbol_c*)call_param_value->accept(*this));

   720     if (call_param_type == NULL) {

   721       if (error_count != NULL) (*error_count)++;

   722       /* the following error will usually occur when ST code uses an identifier, that could refer to an enumerated constant,

   723        * but was not actually used as a constant in any definitions of an enumerated data type

   724        */

   725       else STAGE3_ERROR(call_param_value, call_param_value, "Could not determine data type of value being passed in function/FB call.");

   726       continue;

   727     }  

   728     

   729     /* Iterate to the next parameter of the function being called.

   730      * Get the name of that parameter, and ignore if EN or ENO.

   731      */

   732     do {

   733       param_name = fp_iterator.next();

   734       /* If there is no other parameter declared, then we are passing too many parameters... */

   735       if(param_name == NULL) {

   736         if (error_count != NULL) (*error_count)++;

   737         /* Note: We don't want to print out the follwoing error message multiple times, so we return instead of continuing with 'break' */

   738         else STAGE3_ERROR(f_call, f_call, "Too many parameters in function/FB call."); return;

   739       }

   740     } while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));

   741 

   742     /* Get the parameter type */

   743     param_type = base_type(fp_iterator.param_type());

   744     /* If the declared parameter and the parameter from the function call do not have the same type */

   745     if(!is_valid_assignment(param_type, call_param_type)) {

   746       if (error_count != NULL) (*error_count)++;

   747       else STAGE3_ERROR(call_param_value, call_param_value, "Type mismatch in function/FB call parameter.");

   748     }

   749 

   750     if (extensible_parameter_highest_index < fp_iterator.extensible_param_index()) {

   751       extensible_parameter_highest_index = fp_iterator.extensible_param_index();

   752     }

   753   }

   754   

   755   /* The function call may not have any errors! */

   756   /* In the case of a call to an extensible function, we store the highest index 

   757    * of the extensible parameters this particular call uses, in the symbol_c object

   758    * of the function call itself!

   759    * In calls to non-extensible functions, this value will be set to -1.

   760    * This information is later used in stage4 to correctly generate the

   761    * output code.

   762    */

   763   int extensible_param_count = -1;

   764   if (extensible_parameter_highest_index >=0) /* if call to extensible function */

   765     extensible_param_count = 1 + extensible_parameter_highest_index - fp_iterator.first_extensible_param_index();

   766   il_function_call_c     *il_function_call = dynamic_cast<il_function_call_c *>(f_call);

   767   function_invocation_c  *function_invocation  = dynamic_cast<function_invocation_c  *>(f_call);

   768   if      (il_function_call     != NULL) il_function_call   ->extensible_param_count = extensible_param_count;

   769   else if (function_invocation  != NULL) function_invocation->extensible_param_count = extensible_param_count;

   770   //   else ERROR;  /* this function is also called by Function Blocks, so this is not an error! */

   771 }

   772 

   773 

   774 /* check semantics of FB call in the IL language using input operators */

   775 /* e.g. CU, CLK, IN, PT, SR, ...                                       */

   776 void visit_expression_type_c::check_il_fbcall(symbol_c *il_operator, const char *il_operator_str) {

   777   symbol_c *call_param_type = il_default_variable_type;

   778   symbol_c *fb_decl = il_operand_type;

   779     /* The following should never occur. The function block must be defined, 

   780      * and the FB type being called MUST be in the symtable... 

   781      * This was all already checked at stage 2!

   782      */

   783   if (NULL == fb_decl) ERROR;

   784   if (call_param_type == NULL) ERROR;

   785 

   786   /* We also create an identifier_c object, so we can later use it to find the equivalent FB parameter */

   787   /* Note however that this symbol does not have the correct location (file name and line numbers) 

   788    * so any error messages must use the il_operator symbol to generate the error location

   789    */

   790   identifier_c call_param_name(il_operator_str);

   791 

   792   /* Obtaining the type of the value being passed in the function call */

   793   call_param_type = base_type(call_param_type);

   794   if (call_param_type == NULL) STAGE3_ERROR(il_operator, il_operator, "Could not determine data type of value being passed in FB call.");

   795 

   796   /* Find the corresponding parameter of the function being called */

   797   function_param_iterator_c fp_iterator(fb_decl);

   798   if(fp_iterator.search(&call_param_name) == NULL) {

   799     STAGE3_ERROR(il_operand, il_operand, "Called FB does not have an input parameter named %s.", il_operator_str);

   800   } else {

   801     /* Get the parameter type */

   802     symbol_c *param_type = base_type(fp_iterator.param_type());

   803     /* If the declared parameter and the parameter from the function call have the same type */

   804     if(!is_valid_assignment(param_type, call_param_type)) STAGE3_ERROR(il_operator, il_operator, "Type mismatch in FB call parameter.");

   805   }

   806 }

   807 

   808 

   809 /* A helper function... */

   810 /* check the semantics of a FB or Function formal call */

   811 /* e.g. foo(IN1 := 1, OUT1 =>x, EN := true);  */

   812 /* If error_count pointer is != NULL, we do not really print out the errors,

   813  * but rather only count how many errors were found.

   814  * This is used to support overloaded functions, where we have to check each possible

   815  * function, one at a time, untill we find a function call without any errors.

   816  */

   817 void visit_expression_type_c::check_formal_call(symbol_c *f_call, symbol_c *f_decl, int *error_count) {

   818   symbol_c *call_param_value, *call_param_type, *call_param_name, *param_type;

   819   symbol_c *verify_duplicate_param;

   820   identifier_c *param_name;

   821   function_param_iterator_c       fp_iterator(f_decl);

   822   function_call_param_iterator_c fcp_iterator(f_call);

   823   int extensible_parameter_highest_index = -1;

   824   identifier_c *extensible_parameter_name;

   825 

   826   /* reset error counter */

   827   if (error_count != NULL) *error_count = 0;

   828 

   829   /* Iterating through the formal parameters of the function call */

   830   while((call_param_name = fcp_iterator.next_f()) != NULL) {

   831         

   832     /* Obtaining the value being passed in the function call */

   833     call_param_value = fcp_iterator.get_current_value();

   834     /* the following should never occur. If it does, then we have a bug in our code... */

   835     if (NULL == call_param_value) ERROR;

   836 

   837     /* Checking if there are duplicated parameter values */

   838     verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   839     if(verify_duplicate_param != call_param_value){

   840       if (error_count != NULL) (*error_count)++;

   841       else STAGE3_ERROR(call_param_name, verify_duplicate_param, "Duplicated parameter values.");

   842     }   

   843 

   844     /* Obtaining the type of the value being passed in the function call */

   845     call_param_type = (symbol_c*)call_param_value->accept(*this);

   846     if (call_param_type == NULL) {

   847       if (error_count != NULL) (*error_count)++;

   848       else STAGE3_ERROR(call_param_name, call_param_value, "Could not determine data type of value being passed in function/FB call.");

   849       /* The data value being passed is possibly any enumerated type value.

   850        * We do not yet handle semantic verification of enumerated types.

   851        */

   852       ERROR;

   853     }

   854     call_param_type = base_type(call_param_type);

   855     if (call_param_type == NULL) STAGE3_ERROR(call_param_name, call_param_value, "Could not determine data type of value being passed in function/FB call.");

   856 

   857     /* Find the corresponding parameter of the function being called */

   858     param_name = fp_iterator.search(call_param_name);

   859     if(param_name == NULL) {

   860       if (error_count != NULL) (*error_count)++;

   861       else STAGE3_ERROR(call_param_name, call_param_name, "Invalid parameter in function/FB call.");

   862     } else {

   863       /* Get the parameter type */

   864       param_type = base_type(fp_iterator.param_type());

   865       /* If the declared parameter and the parameter from the function call have the same type */

   866       if(!is_valid_assignment(param_type, call_param_type)) {

   867         if (error_count != NULL) (*error_count)++;

   868         else STAGE3_ERROR(call_param_name, call_param_value, "Type mismatch function/FB call parameter.");

   869       }

   870       if (extensible_parameter_highest_index < fp_iterator.extensible_param_index()) {

   871         extensible_parameter_highest_index = fp_iterator.extensible_param_index();

   872         extensible_parameter_name = param_name;

   873       }

   874     }

   875   }

   876   

   877   /* In the case of a call to an extensible function, we store the highest index 

   878    * of the extensible parameters this particular call uses, in the symbol_c object

   879    * of the function call itself!

   880    * In calls to non-extensible functions, this value will be set to -1.

   881    * This information is later used in stage4 to correctly generate the

   882    * output code.

   883    */

   884   int extensible_param_count = -1;

   885   if (extensible_parameter_highest_index >=0) /* if call to extensible function */

   886     extensible_param_count = 1 + extensible_parameter_highest_index - fp_iterator.first_extensible_param_index();

   887   il_formal_funct_call_c *il_formal_funct_call = dynamic_cast<il_formal_funct_call_c *>(f_call);

   888   function_invocation_c  *function_invocation  = dynamic_cast<function_invocation_c  *>(f_call);

   889   if      (il_formal_funct_call != NULL) il_formal_funct_call->extensible_param_count = extensible_param_count;

   890   else if (function_invocation  != NULL) function_invocation->extensible_param_count  = extensible_param_count;

   891 //   else ERROR;  /* this function is also called by Function Blocks, so this is not an error! */

   892 

   893   /* We have iterated through all the formal parameters of the function call,

   894    * and everything seems fine. 

   895    * If the function being called in an extensible function, we now check

   896    * whether the extensible paramters in the formal invocation do not skip

   897    * any indexes...

   898    *

   899    * f(in1:=0, in2:=0, in4:=0) --> ERROR!!

   900    */

   901   if (extensible_parameter_highest_index >=0) { /* if call to extensible function */

   902     for (int i=fp_iterator.first_extensible_param_index(); i < extensible_parameter_highest_index; i++) {

   903       char tmp[256];

   904       if (snprintf(tmp, 256, "%s%d", extensible_parameter_name->value, i) >= 256) ERROR;

   905       if (fcp_iterator.search_f(tmp) == NULL) {

   906         /* error in invocation of extensible function */

   907         if (error_count != NULL) (*error_count)++;

   908         else STAGE3_ERROR(f_call, f_call, "Missing extensible parameters in call to extensible function.");

   909       }  

   910     }    

   911   }  

   912 }

   913 

   914 

   915 

   916 

   917 /* a helper function... */

   918 symbol_c *visit_expression_type_c::base_type(symbol_c *symbol) {

   919   /* NOTE: symbol == NULL is valid. It will occur when, for e.g., an undefined/undeclared symbolic_variable is used

   920    *       in the code.

   921    */

   922   if (symbol == NULL) return NULL;

   923   return (symbol_c *)symbol->accept(search_base_type);

   924 }

   925 

   926 

   927 /* a helper function... */

   928 void *visit_expression_type_c::verify_null(symbol_c *symbol){

   929   if(il_default_variable_type == NULL){

   930     STAGE3_ERROR(symbol, symbol, "Missing LD instruction (or equivalent) before this instruction.");

   931   }

   932   if(il_operand_type == NULL){

   933     STAGE3_ERROR(symbol, symbol, "This instruction requires an operand.");

   934   }

   935   return NULL;

   936 }

   937 

   938 

   939 /********************************/

   940 /* B 1.3.3 - Derived data types */

   941 /********************************/

   942 void *visit_expression_type_c::visit(data_type_declaration_c *symbol) {

   943   // TODO !!!

   944   /* for the moment we must return NULL so semantic analysis of remaining code is not interrupted! */

   945   return NULL;

   946 }

   947 

   948 

   949 /*********************/

   950 /* B 1.4 - Variables */

   951 /*********************/

   952 

   953 void *visit_expression_type_c::visit(symbolic_variable_c *symbol) {

   954   return search_varfb_instance_type->get_basetype_decl(symbol);

   955 }

   956 

   957 /********************************************/

   958 /* B 1.4.1 - Directly Represented Variables */

   959 /********************************************/

   960 void *visit_expression_type_c::visit(direct_variable_c *symbol) {

   961   switch (symbol->value[2]) {

   962     case 'X': // bit - 1 bit

   963       return (void *)&bool_type_name;

   964     case 'B': // byte - 8 bits

   965       return (void *)&byte_type_name;

   966     case 'W': // word - 16 bits

   967       return (void *)&word_type_name;

   968     case 'D': // double word - 32 bits

   969       return (void *)&dword_type_name;

   970     case 'L': // long word - 64 bits

   971       return (void *)&lword_type_name;

   972     default:  // if none of the above, then the empty string was used <=> boolean 

   973       return (void *)&bool_type_name;

   974    }

   975 }

   976 

   977 /*************************************/

   978 /* B 1.4.2 - Multi-element variables */

   979 /*************************************/

   980 void *visit_expression_type_c::visit(array_variable_c *symbol) {

   981   return search_varfb_instance_type->get_basetype_decl(symbol);

   982 }

   983 

   984 void *visit_expression_type_c::visit(structured_variable_c *symbol) {

   985   return search_varfb_instance_type->get_basetype_decl(symbol);

   986 }

   987 

   988 

   989 

   990 /********************************/

   991 /* B 1.7 Configuration elements */

   992 /********************************/

   993 void *visit_expression_type_c::visit(configuration_declaration_c *symbol) {

   994   // TODO !!!

   995   /* for the moment we must return NULL so semantic analysis of remaining code is not interrupted! */

   996   return NULL;

   997 }

   998 

   999 

  1000 /****************************************/

  1001 /* B.2 - Language IL (Instruction List) */

  1002 /****************************************/

  1003 /***********************************/

  1004 /* B 2.1 Instructions and Operands */

  1005 /***********************************/

  1006 /*| instruction_list il_instruction */

  1007 /* The visitor of the base class search_visitor_c will handle calling each instruction in the list.

  1008  * We do not need to do anything here...

  1009  */

  1010 // void *visit_expression_type_c::visit(instruction_list_c *symbol)

  1011 

  1012 /* | label ':' [il_incomplete_instruction] eol_list */

  1013 //SYM_REF2(il_instruction_c, label, il_instruction)

  1014 // void *visit_expression_type_c::visit(il_instruction_c *symbol);

  1015 

  1016 

  1017 /* | il_simple_operator [il_operand] */

  1018 // SYM_REF2(il_simple_operation_c, il_simple_operator, il_operand)

  1019 void *visit_expression_type_c::visit(il_simple_operation_c *symbol) {

  1020   if (il_error)

  1021     return NULL;

  1022 

  1023   /* determine the data type of the operand */

  1024   il_operand = symbol->il_operand;

  1025   if (symbol->il_operand != NULL){

  1026     il_operand_type = base_type((symbol_c *)symbol->il_operand->accept(*this));

  1027   } else {

  1028     il_operand_type = NULL;

  1029   }

  1030   /* recursive call to see whether data types are compatible */

  1031   symbol->il_simple_operator->accept(*this);

  1032 

  1033   il_operand_type = NULL;

  1034   il_operand = NULL;

  1035   return NULL;

  1036 }

  1037 

  1038 // | function_name [il_operand_list] */

  1039 //SYM_REF2(il_function_call_c, function_name, il_operand_list)

  1040 void *visit_expression_type_c::visit(il_function_call_c *symbol) {

  1041   if (il_error)

  1042     return NULL;

  1043 

  1044   symbol_c *return_data_type = NULL;

  1045 

  1046   /* First find the declaration of the function being called! */

  1047   function_symtable_t::iterator lower = function_symtable.lower_bound(symbol->function_name);

  1048   function_symtable_t::iterator upper = function_symtable.upper_bound(symbol->function_name);

  1049   if (lower == function_symtable.end()) ERROR;

  1050 

  1051   int error_count = 0; 

  1052   int *error_count_ptr = NULL;

  1053 

  1054   function_symtable_t::iterator second = lower;

  1055   second++;

  1056   if (second != upper) 

  1057     /* This is a call to an overloaded function... */  

  1058     error_count_ptr = &error_count;

  1059 

  1060   for(; lower != upper; lower++) {

  1061     function_declaration_c *f_decl = function_symtable.get_value(lower);

  1062     

  1063     check_nonformal_call(symbol, f_decl, true, error_count_ptr);

  1064     

  1065     if (0 == error_count) {

  1066       /* Either: 

  1067        * (i) we have a call to a non-overloaded function (error_cnt_ptr is NULL!, so error_count won't change!)  

  1068        * (ii) we have a call to an overloaded function, with no errors!

  1069        */

  1070       

  1071       /* Store the pointer to the declaration of the function being called.

  1072        * This data will be used by stage 4 to call the correct function.

  1073        * Mostly needed to disambiguate overloaded functions...

  1074        * See comments in absyntax.def for more details

  1075        */

  1076       symbol->called_function_declaration = f_decl;

  1077       /* determine the base data type returned by the function being called... */

  1078       return_data_type = base_type(f_decl->type_name);

  1079       /* If the following occurs, then we must have some big bug in the syntax parser (stage 2)... */

  1080       if (NULL == return_data_type) ERROR;

  1081       /* set the new data type of the default variable for the following verifications... */

  1082       il_default_variable_type = return_data_type;

  1083       return NULL;

  1084     }

  1085   }

  1086 

  1087   /* No compatible function was found for this function call */

  1088   STAGE3_ERROR(symbol, symbol, "Call to an overloaded function with invalid parameter type.");

  1089   return NULL;

  1090 }

  1091 

  1092 

  1093 /* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */

  1094 // SYM_REF3(il_expression_c, il_expr_operator, il_operand, simple_instr_list);

  1095 void *visit_expression_type_c::visit(il_expression_c *symbol) {

  1096   if (il_error)

  1097     return NULL;

  1098 

  1099   symbol_c *il_default_variable_type_back = il_default_variable_type;

  1100 

  1101   il_parenthesis_level++;

  1102 

  1103   if(symbol->il_operand != NULL) {

  1104      il_default_variable_type = base_type((symbol_c *)symbol->il_operand->accept(*this));

  1105   } else {

  1106      il_default_variable_type = NULL;

  1107   }

  1108 

  1109   if(symbol->simple_instr_list != NULL) {

  1110     symbol->simple_instr_list->accept(*this);

  1111   }

  1112 

  1113   il_parenthesis_level--;

  1114   if (il_parenthesis_level < 0) ERROR;

  1115 

  1116   il_operand = symbol->simple_instr_list;

  1117   il_operand_type = il_default_variable_type;

  1118   il_default_variable_type = il_default_variable_type_back;

  1119 

  1120   /* Now check the if the data type semantics of operation are correct,

  1121    * but only if no previous error has been found...

  1122    */

  1123   if (!il_error)

  1124     symbol->il_expr_operator->accept(*this);

  1125 

  1126   il_operand_type = NULL;

  1127   il_operand = NULL;

  1128   return NULL;

  1129 }

  1130 

  1131 

  1132 #if 0

  1133 /*  il_jump_operator label */

  1134 SYM_REF2(il_jump_operation_c, il_jump_operator, label)

  1135 void *visit_expression_type_c::visit(il_jump_operation_c *symbol);

  1136 #endif