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 symbol_c *visit_expression_type_c::common_literal(symbol_c *first_type, symbol_c *second_type) {

   570   printf("common_literal: %d == %d, %d == %d, %d == %d\n",

   571 		 (int)is_ANY_INT_compatible(first_type),

   572 		 (int)is_ANY_INT_compatible(second_type),

   573 		 (int)is_ANY_REAL_compatible(first_type),

   574 		 (int)is_ANY_REAL_compatible(second_type),

   575 		 (int)is_ANY_BIT_compatible(first_type),

   576 		 (int)is_ANY_BIT_compatible(second_type));

   577   if ((is_ANY_INT_compatible(first_type) && is_ANY_INT_compatible(second_type)) ||

   578 	  (is_ANY_BIT_compatible(first_type) && is_ANY_BIT_compatible(second_type)))

   579 	 return &search_constant_type_c::integer;

   580   else if (is_ANY_REAL_compatible(first_type) && is_ANY_REAL_compatible(second_type))

   581 	 return &search_constant_type_c::real;

   582   return NULL;

   583 }

   584 

   585 symbol_c *visit_expression_type_c::overloaded_return_type(symbol_c *type) {

   586   if (is_ANY_INT_compatible(type))

   587     return &search_constant_type_c::ulint_type_name;

   588   else if (is_ANY_REAL_compatible(type))

   589     return &search_constant_type_c::lreal_type_name;

   590   else if (is_ANY_BIT_compatible(type))

   591       return &search_constant_type_c::lword_type_name;

   592   return NULL;

   593 }

   594 

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

   596  * such as: 

   597  *     var_type     value_type

   598  *    BOOL           BYTE#7     -> returns false

   599  *    INT            INT#7      -> returns true

   600  *    INT            7          -> returns true

   601  *    REAL           7.89       -> returns true

   602  *    REAL           7          -> returns true

   603  *    INT            7.89       -> returns false

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

   605  *   etc...

   606  *

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

   608  */

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

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

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

   612 

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

   614   if (NULL == common_type)

   615     return false;

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

   617 }

   618 

   619 

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

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

   622  * such as:

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

   624  *    0          AND BYTE#7  -> returns true

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

   626  *    INT#10     AND 7       -> returns true

   627  *    REAL#34.3  AND 7.89    -> returns true

   628  *    REAL#34.3  AND 7       -> returns true

   629  *    INT#10     AND 7.89    -> returns false

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

   631  *   etc...

   632  */

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

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

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

   636 }

   637 

   638 

   639 

   640 

   641 /* A helper function... */

   642 /*

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

   644                                                               is_data_type_t is_data_type) {

   645 */

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

   647 						      symbol_c *left_expr, symbol_c *right_expr) {

   648   bool error = false;

   649 

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

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

   652     if (left_expr != NULL)

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

   654     error = true;

   655   }

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

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

   658     if (right_expr != NULL)

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

   660     error = true;

   661   }

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

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

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

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

   666     error = true;

   667   }

   668 

   669   if (error)

   670     return NULL;

   671   else

   672     return common_type(left_type, right_type);

   673 }

   674 

   675 

   676 

   677 

   678 /* A helper function... */

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

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

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

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

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

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

   685  */

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

   687   symbol_c *call_param_value, *call_param_type, *param_type;

   688   identifier_c *param_name;

   689   function_param_iterator_c       fp_iterator(f_decl);

   690   function_call_param_iterator_c fcp_iterator(f_call);

   691   int extensible_parameter_highest_index = -1;

   692   

   693   /* reset error counter */

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

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

   696   if (use_il_defvar) {

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

   698     do {

   699       param_name = fp_iterator.next();

   700       if(param_name == NULL) break;

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

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

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

   704        * in the function.

   705        */

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

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

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

   709      *

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

   711      * have at least one parameter.

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

   713      * versions of the standard may change that syntax.

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

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

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

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

   718      * correct, and we simply return.

   719      */

   720     if(param_name == NULL) {

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

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

   723       return;

   724     } else { 

   725       /* param_name != NULL */

   726       param_type = fp_iterator.param_type();

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

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

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

   730       }

   731     }

   732     

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

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

   735       extensible_parameter_highest_index = fp_iterator.extensible_param_index();

   736     }

   737   } // if (use_il_defvar)

   738   

   739   

   740 

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

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

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

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

   745     if (call_param_type == NULL) {

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

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

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

   749        */

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

   751       continue;

   752     }  

   753     

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

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

   756      */

   757     do {

   758       param_name = fp_iterator.next();

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

   760       if(param_name == NULL) {

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

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

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

   764       }

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

   766 

   767     /* Get the parameter type */

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

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

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

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

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

   773     }

   774 

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

   776       extensible_parameter_highest_index = fp_iterator.extensible_param_index();

   777     }

   778   }

   779   

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

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

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

   783    * of the function call itself!

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

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

   786    * output code.

   787    */

   788   int extensible_param_count = -1;

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

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

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

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

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

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

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

   796 }

   797 

   798 

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

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

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

   802   symbol_c *call_param_type = il_default_variable_type;

   803   symbol_c *fb_decl = il_operand_type;

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

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

   806      * This was all already checked at stage 2!

   807      */

   808   if (NULL == fb_decl) ERROR;

   809   if (call_param_type == NULL) ERROR;

   810 

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

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

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

   814    */

   815   identifier_c call_param_name(il_operator_str);

   816 

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

   818   call_param_type = base_type(call_param_type);

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

   820 

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

   822   function_param_iterator_c fp_iterator(fb_decl);

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

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

   825   } else {

   826     /* Get the parameter type */

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

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

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

   830   }

   831 }

   832 

   833 

   834 /* A helper function... */

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

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

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

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

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

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

   841  */

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

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

   844   symbol_c *verify_duplicate_param;

   845   identifier_c *param_name;

   846   function_param_iterator_c       fp_iterator(f_decl);

   847   function_call_param_iterator_c fcp_iterator(f_call);

   848   int extensible_parameter_highest_index = -1;

   849   identifier_c *extensible_parameter_name;

   850 

   851   /* reset error counter */

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

   853 

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

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

   856         

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

   858     call_param_value = fcp_iterator.get_current_value();

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

   860     if (NULL == call_param_value) ERROR;

   861 

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

   863     verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   864     if(verify_duplicate_param != call_param_value){

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

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

   867     }   

   868 

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

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

   871     if (call_param_type == NULL) {

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

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

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

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

   876        */

   877       ERROR;

   878     }

   879     call_param_type = base_type(call_param_type);

   880     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.");

   881 

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

   883     param_name = fp_iterator.search(call_param_name);

   884     if(param_name == NULL) {

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

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

   887     } else {

   888       /* Get the parameter type */

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

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

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

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

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

   894       }

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

   896         extensible_parameter_highest_index = fp_iterator.extensible_param_index();

   897         extensible_parameter_name = param_name;

   898       }

   899     }

   900   }

   901   

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

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

   904    * of the function call itself!

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

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

   907    * output code.

   908    */

   909   int extensible_param_count = -1;

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

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

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

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

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

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

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

   917 

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

   919    * and everything seems fine. 

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

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

   922    * any indexes...

   923    *

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

   925    */

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

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

   928       char tmp[256];

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

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

   931         /* error in invocation of extensible function */

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

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

   934       }  

   935     }    

   936   }  

   937 }

   938 

   939 

   940 

   941 

   942 /* a helper function... */

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

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

   945    *       in the code.

   946    */

   947   if (symbol == NULL) return NULL;

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

   949 }

   950 

   951 

   952 /* a helper function... */

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

   954   if(il_default_variable_type == NULL){

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

   956   }

   957   if(il_operand_type == NULL){

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

   959   }

   960   return NULL;

   961 }

   962 

   963 

   964 /********************************/

   965 /* B 1.3.3 - Derived data types */

   966 /********************************/

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

   968   // TODO !!!

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

   970   return NULL;

   971 }

   972 

   973 

   974 /*********************/

   975 /* B 1.4 - Variables */

   976 /*********************/

   977 

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

   979   return search_varfb_instance_type->get_basetype_decl(symbol);

   980 }

   981 

   982 /********************************************/

   983 /* B 1.4.1 - Directly Represented Variables */

   984 /********************************************/

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

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

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

   988       return (void *)&bool_type_name;

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

   990       return (void *)&byte_type_name;

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

   992       return (void *)&word_type_name;

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

   994       return (void *)&dword_type_name;

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

   996       return (void *)&lword_type_name;

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

   998       return (void *)&bool_type_name;

   999    }

  1000 }

  1001 

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

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

  1004 /*************************************/

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

  1006   return search_varfb_instance_type->get_basetype_decl(symbol);

  1007 }

  1008 

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

  1010   return search_varfb_instance_type->get_basetype_decl(symbol);

  1011 }

  1012 

  1013 

  1014 

  1015 /********************************/

  1016 /* B 1.7 Configuration elements */

  1017 /********************************/

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

  1019   // TODO !!!

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

  1021   return NULL;

  1022 }

  1023 

  1024 

  1025 /****************************************/

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

  1027 /****************************************/

  1028 /***********************************/

  1029 /* B 2.1 Instructions and Operands */

  1030 /***********************************/

  1031 /*| instruction_list il_instruction */

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

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

  1034  */

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

  1036 

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

  1038 //SYM_REF2(il_instruction_c, label, il_instruction)

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

  1040 

  1041 

  1042 /* | il_simple_operator [il_operand] */

  1043 // SYM_REF2(il_simple_operation_c, il_simple_operator, il_operand)

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

  1045   if (il_error)

  1046     return NULL;

  1047 

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

  1049   il_operand = symbol->il_operand;

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

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

  1052   } else {

  1053     il_operand_type = NULL;

  1054   }

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

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

  1057 

  1058   il_operand_type = NULL;

  1059   il_operand = NULL;

  1060   return NULL;

  1061 }

  1062 

  1063 // | function_name [il_operand_list] */

  1064 //SYM_REF2(il_function_call_c, function_name, il_operand_list)

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

  1066   if (il_error)

  1067     return NULL;

  1068 

  1069   symbol_c *return_data_type = NULL;

  1070   symbol_c* fdecl_return_type;

  1071   symbol_c* overloaded_data_type = NULL;

  1072   int extensible_param_count = -1;

  1073   symbol->called_function_declaration = NULL;

  1074 

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

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

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

  1078   function_symtable_t::iterator current;

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

  1080 

  1081   int error_count = 0; 

  1082   int *error_count_ptr = NULL;

  1083 

  1084   function_symtable_t::iterator second = lower;

  1085   second++;

  1086   if (second != upper) 

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

  1088     error_count_ptr = &error_count;

  1089 

  1090   for(current = lower; current != upper; current++) {

  1091     function_declaration_c *f_decl = function_symtable.get_value(current);

  1092     

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

  1094     

  1095     if (0 == error_count) {

  1096       /* Either: 

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

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

  1099        */

  1100 

  1101       fdecl_return_type = base_type(f_decl->type_name);

  1102 

  1103       if (symbol->called_function_declaration == NULL) {

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

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

  1106          * Mostly needed to disambiguate overloaded functions...

  1107          * See comments in absyntax.def for more details

  1108          */

  1109         symbol->called_function_declaration = f_decl;

  1110         extensible_param_count = symbol->extensible_param_count;

  1111 

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

  1113         return_data_type = fdecl_return_type;

  1114       }

  1115       else if (typeid(*return_data_type) != typeid(*fdecl_return_type)){

  1116         return_data_type = common_literal(return_data_type, fdecl_return_type);

  1117         overloaded_data_type = overloaded_return_type(return_data_type);

  1118       }

  1119       

  1120       if (NULL == return_data_type) ERROR;

  1121     }

  1122   }

  1123 

  1124   if (overloaded_data_type != NULL) {

  1125     for(current = lower; current != upper; current++) {

  1126       function_declaration_c *f_decl = function_symtable.get_value(current);

  1127 

  1128       /* check semantics of data passed in the function call... */

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

  1130 

  1131       if (0 == error_count) {

  1132 

  1133         fdecl_return_type = base_type(f_decl->type_name);

  1134 

  1135         if (typeid(*overloaded_data_type) == typeid(*fdecl_return_type)){