Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage4/generate_c/st_code_gen.c
changeset 279 c0453b7f99df
parent 235 ed66dc50f31a
child 314 41d4ac0b4821
equal deleted inserted replaced
278:050d31dd7c74 279:c0453b7f99df 
     1 /*
 
     1 /*
 
     2  * (c) 2008 Edouard TISSERANT
 
     2  * Copyright (C) 2007-2011: Edouard TISSERANT and Laurent BESSARD
 
     3  *
 
     3  *
 
     4  * Offered to the public under the terms of the GNU General Public License
 
     4  * See COPYING and COPYING.LESSER files for copyright details.
 
     5  * as published by the Free Software Foundation; either version 2 of the
 
       
     6  * License, or (at your option) any later version.
 
       
     7  *
 
     5  *
 
     8  * This program is distributed in the hope that it will be useful, but
 
     6  * This program is free software: you can redistribute it and/or modify
 
     9  * WITHOUT ANY WARRANTY; without even the implied warranty of
 
     7  * it under the terms of the GNU General Public License as published by
 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 
     8  * the Free Software Foundation, either version 3 of the License, or
 
    11  * Public License for more details.
 
     9  * (at your option) any later version.
 
    12  *
 
    10  *
 
    13  * This code is made available on the understanding that it will not be
 
    11  * This program is distributed in the hope that it will be useful,
 
    14  * used in safety-critical situations without a full and competent review.
 
    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
    15  */
 
    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
    16 
    14  * GNU General Public License for more details.
 
    17 /*
 
       
    18  * An IEC 61131-3 IL and ST compiler.
 
       
    19  *
 
    15  *
 
    20  * Based on the
 
    16  * You should have received a copy of the GNU General Public License
 
    21  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)
 
    17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 
    22  *
 
    18  *
 
    23  */
 
    19  */
 
    24 
    20 
    25 /****
 
    21 /****
 
    26  * IEC 61131-3 standard function library
 
    22  * IEC 61131-3 standard function library
 
 16692         
 16688         
 16693     }/*function_add*/
 
 16689     }/*function_add*/
 
 16694     break;
 
 16690     break;
 
 16695 
 16691 
 16696 /****
 
 16692 /****
 
       
 16693  *ADD_TIME
 
       
 16694  */
 
       
 16695     case function_add_time :
 
       
 16696     {
 
       
 16697         symbol_c *last_type_symbol = NULL;
 
       
 16698 
       
 16699         {
 
       
 16700             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 16701             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 16702             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 16703             symbol_c *IN1_type_symbol = NULL;
 
       
 16704             
       
 16705             /* Get the value from a foo(<param_value>) style call */
 
       
 16706             if (IN1_param_value == NULL)
 
       
 16707               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 16708             if (IN1_param_value != NULL) {
 
       
 16709               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 16710               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 16711             }
 
       
 16712             
       
 16713             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 16714             {
 
       
 16715         
       
 16716                 {
 
       
 16717                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 16718                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 16719                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 16720                     symbol_c *IN2_type_symbol = NULL;
 
       
 16721                     
       
 16722                     /* Get the value from a foo(<param_value>) style call */
 
       
 16723                     if (IN2_param_value == NULL)
 
       
 16724                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 16725                     if (IN2_param_value != NULL) {
 
       
 16726                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 16727                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 16728                     }
 
       
 16729                     
       
 16730                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 16731                     {
 
       
 16732                 
       
 16733                         function_name = (symbol_c*)(new pragma_c("__time_add"));
 
       
 16734                         
       
 16735                         if (IN1_type_symbol == NULL)
 
       
 16736                           IN1_type_symbol = last_type_symbol;
 
       
 16737                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 16738                         
       
 16739                         if (IN2_type_symbol == NULL)
 
       
 16740                           IN2_type_symbol = last_type_symbol;
 
       
 16741                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 16742                         symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
 
       
 16743                         break;
 
       
 16744                         
       
 16745                     }
 
       
 16746                     
       
 16747                     
       
 16748                     ERROR;
 
       
 16749                 }
 
       
 16750                 
       
 16751             }
 
       
 16752             
       
 16753             
       
 16754             ERROR;
 
       
 16755         }
 
       
 16756         
       
 16757     }/*function_add_time*/
 
       
 16758     break;
 
       
 16759 
       
 16760 /****
 
       
 16761  *ADD_TOD_TIME
 
       
 16762  */
 
       
 16763     case function_add_tod_time :
 
       
 16764     {
 
       
 16765         symbol_c *last_type_symbol = NULL;
 
       
 16766 
       
 16767         {
 
       
 16768             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 16769             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 16770             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 16771             symbol_c *IN1_type_symbol = NULL;
 
       
 16772             
       
 16773             /* Get the value from a foo(<param_value>) style call */
 
       
 16774             if (IN1_param_value == NULL)
 
       
 16775               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 16776             if (IN1_param_value != NULL) {
 
       
 16777               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 16778               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 16779             }
 
       
 16780             
       
 16781             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
 
       
 16782             {
 
       
 16783         
       
 16784                 {
 
       
 16785                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 16786                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 16787                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 16788                     symbol_c *IN2_type_symbol = NULL;
 
       
 16789                     
       
 16790                     /* Get the value from a foo(<param_value>) style call */
 
       
 16791                     if (IN2_param_value == NULL)
 
       
 16792                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 16793                     if (IN2_param_value != NULL) {
 
       
 16794                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 16795                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 16796                     }
 
       
 16797                     
       
 16798                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 16799                     {
 
       
 16800                 
       
 16801                         function_name = (symbol_c*)(new pragma_c("__time_add"));
 
       
 16802                         
       
 16803                         if (IN1_type_symbol == NULL)
 
       
 16804                           IN1_type_symbol = last_type_symbol;
 
       
 16805                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 16806                         
       
 16807                         if (IN2_type_symbol == NULL)
 
       
 16808                           IN2_type_symbol = last_type_symbol;
 
       
 16809                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 16810                         symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
 
       
 16811                         break;
 
       
 16812                         
       
 16813                     }
 
       
 16814                     
       
 16815                     
       
 16816                     ERROR;
 
       
 16817                 }
 
       
 16818                 
       
 16819             }
 
       
 16820             
       
 16821             
       
 16822             ERROR;
 
       
 16823         }
 
       
 16824         
       
 16825     }/*function_add_tod_time*/
 
       
 16826     break;
 
       
 16827 
       
 16828 /****
 
       
 16829  *ADD_DT_TIME
 
       
 16830  */
 
       
 16831     case function_add_dt_time :
 
       
 16832     {
 
       
 16833         symbol_c *last_type_symbol = NULL;
 
       
 16834 
       
 16835         {
 
       
 16836             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 16837             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 16838             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 16839             symbol_c *IN1_type_symbol = NULL;
 
       
 16840             
       
 16841             /* Get the value from a foo(<param_value>) style call */
 
       
 16842             if (IN1_param_value == NULL)
 
       
 16843               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 16844             if (IN1_param_value != NULL) {
 
       
 16845               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 16846               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 16847             }
 
       
 16848             
       
 16849             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
 
       
 16850             {
 
       
 16851         
       
 16852                 {
 
       
 16853                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 16854                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 16855                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 16856                     symbol_c *IN2_type_symbol = NULL;
 
       
 16857                     
       
 16858                     /* Get the value from a foo(<param_value>) style call */
 
       
 16859                     if (IN2_param_value == NULL)
 
       
 16860                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 16861                     if (IN2_param_value != NULL) {
 
       
 16862                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 16863                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 16864                     }
 
       
 16865                     
       
 16866                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 16867                     {
 
       
 16868                 
       
 16869                         function_name = (symbol_c*)(new pragma_c("__time_add"));
 
       
 16870                         
       
 16871                         if (IN1_type_symbol == NULL)
 
       
 16872                           IN1_type_symbol = last_type_symbol;
 
       
 16873                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 16874                         
       
 16875                         if (IN2_type_symbol == NULL)
 
       
 16876                           IN2_type_symbol = last_type_symbol;
 
       
 16877                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 16878                         symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
 
       
 16879                         break;
 
       
 16880                         
       
 16881                     }
 
       
 16882                     
       
 16883                     
       
 16884                     ERROR;
 
       
 16885                 }
 
       
 16886                 
       
 16887             }
 
       
 16888             
       
 16889             
       
 16890             ERROR;
 
       
 16891         }
 
       
 16892         
       
 16893     }/*function_add_dt_time*/
 
       
 16894     break;
 
       
 16895 
       
 16896 /****
 
 16697  *MUL
 
 16897  *MUL
 
 16698  */
 
 16898  */
 
 16699     case function_mul :
 
 16899     case function_mul :
 
 16700     {
 
 16900     {
 
 16701         symbol_c *last_type_symbol = NULL;
 
 16901         symbol_c *last_type_symbol = NULL;
 
 16834         
 17034         
 16835     }/*function_mul*/
 
 17035     }/*function_mul*/
 
 16836     break;
 
 17036     break;
 
 16837 
 17037 
 16838 /****
 
 17038 /****
 
       
 17039  *MULTIME
 
       
 17040  */
 
       
 17041     case function_multime :
 
       
 17042     {
 
       
 17043         symbol_c *last_type_symbol = NULL;
 
       
 17044 
       
 17045         {
 
       
 17046             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 17047             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17048             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 17049             symbol_c *IN1_type_symbol = NULL;
 
       
 17050             
       
 17051             /* Get the value from a foo(<param_value>) style call */
 
       
 17052             if (IN1_param_value == NULL)
 
       
 17053               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 17054             if (IN1_param_value != NULL) {
 
       
 17055               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 17056               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 17057             }
 
       
 17058             
       
 17059             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 17060             {
 
       
 17061         
       
 17062                 {
 
       
 17063                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 17064                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17065                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 17066                     symbol_c *IN2_type_symbol = NULL;
 
       
 17067                     
       
 17068                     /* Get the value from a foo(<param_value>) style call */
 
       
 17069                     if (IN2_param_value == NULL)
 
       
 17070                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 17071                     if (IN2_param_value != NULL) {
 
       
 17072                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 17073                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 17074                     }
 
       
 17075                     
       
 17076                     if(IN2_type_symbol == NULL || search_expression_type->is_num_type(IN2_type_symbol))
 
       
 17077                     {
 
       
 17078                 
       
 17079                         function_name = (symbol_c*)(new pragma_c("__time_mul"));
 
       
 17080                         
       
 17081                         if (IN1_type_symbol == NULL)
 
       
 17082                           IN1_type_symbol = last_type_symbol;
 
       
 17083                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17084                         
       
 17085                         if (IN2_type_symbol == NULL)
 
       
 17086                           IN2_type_symbol = last_type_symbol;
 
       
 17087                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17088                         symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
 
       
 17089                         if (search_expression_type->is_literal_integer_type(function_type_suffix))
 
       
 17090                             function_type_suffix = &search_constant_type_c::lint_type_name;
 
       
 17091                         break;
 
       
 17092                         
       
 17093                     }
 
       
 17094                     
       
 17095                     
       
 17096                     ERROR;
 
       
 17097                 }
 
       
 17098                 
       
 17099             }
 
       
 17100             
       
 17101             
       
 17102             ERROR;
 
       
 17103         }
 
       
 17104         
       
 17105     }/*function_multime*/
 
       
 17106     break;
 
       
 17107 
       
 17108 /****
 
 16839  *SUB
 
 17109  *SUB
 
 16840  */
 
 17110  */
 
 16841     case function_sub :
 
 17111     case function_sub :
 
 16842     {
 
 17112     {
 
 16843         symbol_c *last_type_symbol = NULL;
 
 17113         symbol_c *last_type_symbol = NULL;
 
 17094             
 17364             
 17095             ERROR;
 
 17365             ERROR;
 
 17096         }
 
 17366         }
 
 17097         
 17367         
 17098     }/*function_sub*/
 
 17368     }/*function_sub*/
 
       
 17369     break;
 
       
 17370 
       
 17371 /****
 
       
 17372  *SUB_TIME
 
       
 17373  */
 
       
 17374     case function_sub_time :
 
       
 17375     {
 
       
 17376         symbol_c *last_type_symbol = NULL;
 
       
 17377 
       
 17378         {
 
       
 17379             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 17380             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17381             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 17382             symbol_c *IN1_type_symbol = NULL;
 
       
 17383             
       
 17384             /* Get the value from a foo(<param_value>) style call */
 
       
 17385             if (IN1_param_value == NULL)
 
       
 17386               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 17387             if (IN1_param_value != NULL) {
 
       
 17388               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 17389               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 17390             }
 
       
 17391             
       
 17392             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 17393             {
 
       
 17394         
       
 17395                 {
 
       
 17396                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 17397                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17398                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 17399                     symbol_c *IN2_type_symbol = NULL;
 
       
 17400                     
       
 17401                     /* Get the value from a foo(<param_value>) style call */
 
       
 17402                     if (IN2_param_value == NULL)
 
       
 17403                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 17404                     if (IN2_param_value != NULL) {
 
       
 17405                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 17406                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 17407                     }
 
       
 17408                     
       
 17409                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 17410                     {
 
       
 17411                 
       
 17412                         function_name = (symbol_c*)(new pragma_c("__time_sub"));
 
       
 17413                         
       
 17414                         if (IN1_type_symbol == NULL)
 
       
 17415                           IN1_type_symbol = last_type_symbol;
 
       
 17416                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17417                         
       
 17418                         if (IN2_type_symbol == NULL)
 
       
 17419                           IN2_type_symbol = last_type_symbol;
 
       
 17420                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17421                         symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
 
       
 17422                         break;
 
       
 17423                         
       
 17424                     }
 
       
 17425                     
       
 17426                     
       
 17427                     ERROR;
 
       
 17428                 }
 
       
 17429                 
       
 17430             }
 
       
 17431             
       
 17432             
       
 17433             ERROR;
 
       
 17434         }
 
       
 17435         
       
 17436     }/*function_sub_time*/
 
       
 17437     break;
 
       
 17438 
       
 17439 /****
 
       
 17440  *SUB_DATE_DATE
 
       
 17441  */
 
       
 17442     case function_sub_date_date :
 
       
 17443     {
 
       
 17444         symbol_c *last_type_symbol = NULL;
 
       
 17445 
       
 17446         {
 
       
 17447             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 17448             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17449             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 17450             symbol_c *IN1_type_symbol = NULL;
 
       
 17451             
       
 17452             /* Get the value from a foo(<param_value>) style call */
 
       
 17453             if (IN1_param_value == NULL)
 
       
 17454               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 17455             if (IN1_param_value != NULL) {
 
       
 17456               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 17457               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 17458             }
 
       
 17459             
       
 17460             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
 
       
 17461             {
 
       
 17462         
       
 17463                 {
 
       
 17464                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 17465                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17466                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 17467                     symbol_c *IN2_type_symbol = NULL;
 
       
 17468                     
       
 17469                     /* Get the value from a foo(<param_value>) style call */
 
       
 17470                     if (IN2_param_value == NULL)
 
       
 17471                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 17472                     if (IN2_param_value != NULL) {
 
       
 17473                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 17474                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 17475                     }
 
       
 17476                     
       
 17477                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
 
       
 17478                     {
 
       
 17479                 
       
 17480                         function_name = (symbol_c*)(new pragma_c("__time_sub"));
 
       
 17481                         
       
 17482                         if (IN1_type_symbol == NULL)
 
       
 17483                           IN1_type_symbol = last_type_symbol;
 
       
 17484                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17485                         
       
 17486                         if (IN2_type_symbol == NULL)
 
       
 17487                           IN2_type_symbol = last_type_symbol;
 
       
 17488                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17489                         symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
 
       
 17490                         break;
 
       
 17491                         
       
 17492                     }
 
       
 17493                     
       
 17494                     
       
 17495                     ERROR;
 
       
 17496                 }
 
       
 17497                 
       
 17498             }
 
       
 17499             
       
 17500             
       
 17501             ERROR;
 
       
 17502         }
 
       
 17503         
       
 17504     }/*function_sub_date_date*/
 
       
 17505     break;
 
       
 17506 
       
 17507 /****
 
       
 17508  *SUB_TOD_TIME
 
       
 17509  */
 
       
 17510     case function_sub_tod_time :
 
       
 17511     {
 
       
 17512         symbol_c *last_type_symbol = NULL;
 
       
 17513 
       
 17514         {
 
       
 17515             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 17516             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17517             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 17518             symbol_c *IN1_type_symbol = NULL;
 
       
 17519             
       
 17520             /* Get the value from a foo(<param_value>) style call */
 
       
 17521             if (IN1_param_value == NULL)
 
       
 17522               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 17523             if (IN1_param_value != NULL) {
 
       
 17524               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 17525               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 17526             }
 
       
 17527             
       
 17528             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
 
       
 17529             {
 
       
 17530         
       
 17531                 {
 
       
 17532                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 17533                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17534                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 17535                     symbol_c *IN2_type_symbol = NULL;
 
       
 17536                     
       
 17537                     /* Get the value from a foo(<param_value>) style call */
 
       
 17538                     if (IN2_param_value == NULL)
 
       
 17539                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 17540                     if (IN2_param_value != NULL) {
 
       
 17541                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 17542                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 17543                     }
 
       
 17544                     
       
 17545                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 17546                     {
 
       
 17547                 
       
 17548                         function_name = (symbol_c*)(new pragma_c("__time_sub"));
 
       
 17549                         
       
 17550                         if (IN1_type_symbol == NULL)
 
       
 17551                           IN1_type_symbol = last_type_symbol;
 
       
 17552                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17553                         
       
 17554                         if (IN2_type_symbol == NULL)
 
       
 17555                           IN2_type_symbol = last_type_symbol;
 
       
 17556                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17557                         symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
 
       
 17558                         break;
 
       
 17559                         
       
 17560                     }
 
       
 17561                     
       
 17562                     
       
 17563                     ERROR;
 
       
 17564                 }
 
       
 17565                 
       
 17566             }
 
       
 17567             
       
 17568             
       
 17569             ERROR;
 
       
 17570         }
 
       
 17571         
       
 17572     }/*function_sub_tod_time*/
 
       
 17573     break;
 
       
 17574 
       
 17575 /****
 
       
 17576  *SUB_TOD_TOD
 
       
 17577  */
 
       
 17578     case function_sub_tod_tod :
 
       
 17579     {
 
       
 17580         symbol_c *last_type_symbol = NULL;
 
       
 17581 
       
 17582         {
 
       
 17583             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 17584             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17585             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 17586             symbol_c *IN1_type_symbol = NULL;
 
       
 17587             
       
 17588             /* Get the value from a foo(<param_value>) style call */
 
       
 17589             if (IN1_param_value == NULL)
 
       
 17590               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 17591             if (IN1_param_value != NULL) {
 
       
 17592               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 17593               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 17594             }
 
       
 17595             
       
 17596             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
 
       
 17597             {
 
       
 17598         
       
 17599                 {
 
       
 17600                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 17601                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17602                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 17603                     symbol_c *IN2_type_symbol = NULL;
 
       
 17604                     
       
 17605                     /* Get the value from a foo(<param_value>) style call */
 
       
 17606                     if (IN2_param_value == NULL)
 
       
 17607                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 17608                     if (IN2_param_value != NULL) {
 
       
 17609                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 17610                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 17611                     }
 
       
 17612                     
       
 17613                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
 
       
 17614                     {
 
       
 17615                 
       
 17616                         function_name = (symbol_c*)(new pragma_c("__time_sub"));
 
       
 17617                         
       
 17618                         if (IN1_type_symbol == NULL)
 
       
 17619                           IN1_type_symbol = last_type_symbol;
 
       
 17620                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17621                         
       
 17622                         if (IN2_type_symbol == NULL)
 
       
 17623                           IN2_type_symbol = last_type_symbol;
 
       
 17624                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17625                         symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
 
       
 17626                         break;
 
       
 17627                         
       
 17628                     }
 
       
 17629                     
       
 17630                     
       
 17631                     ERROR;
 
       
 17632                 }
 
       
 17633                 
       
 17634             }
 
       
 17635             
       
 17636             
       
 17637             ERROR;
 
       
 17638         }
 
       
 17639         
       
 17640     }/*function_sub_tod_tod*/
 
       
 17641     break;
 
       
 17642 
       
 17643 /****
 
       
 17644  *SUB_DT_TIME
 
       
 17645  */
 
       
 17646     case function_sub_dt_time :
 
       
 17647     {
 
       
 17648         symbol_c *last_type_symbol = NULL;
 
       
 17649 
       
 17650         {
 
       
 17651             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 17652             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17653             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 17654             symbol_c *IN1_type_symbol = NULL;
 
       
 17655             
       
 17656             /* Get the value from a foo(<param_value>) style call */
 
       
 17657             if (IN1_param_value == NULL)
 
       
 17658               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 17659             if (IN1_param_value != NULL) {
 
       
 17660               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 17661               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 17662             }
 
       
 17663             
       
 17664             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
 
       
 17665             {
 
       
 17666         
       
 17667                 {
 
       
 17668                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 17669                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17670                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 17671                     symbol_c *IN2_type_symbol = NULL;
 
       
 17672                     
       
 17673                     /* Get the value from a foo(<param_value>) style call */
 
       
 17674                     if (IN2_param_value == NULL)
 
       
 17675                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 17676                     if (IN2_param_value != NULL) {
 
       
 17677                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 17678                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 17679                     }
 
       
 17680                     
       
 17681                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
 
       
 17682                     {
 
       
 17683                 
       
 17684                         function_name = (symbol_c*)(new pragma_c("__time_sub"));
 
       
 17685                         
       
 17686                         if (IN1_type_symbol == NULL)
 
       
 17687                           IN1_type_symbol = last_type_symbol;
 
       
 17688                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17689                         
       
 17690                         if (IN2_type_symbol == NULL)
 
       
 17691                           IN2_type_symbol = last_type_symbol;
 
       
 17692                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17693                         symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
 
       
 17694                         break;
 
       
 17695                         
       
 17696                     }
 
       
 17697                     
       
 17698                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 17699                     {
 
       
 17700                 
       
 17701                         function_name = (symbol_c*)(new pragma_c("__time_sub"));
 
       
 17702                         
       
 17703                         if (IN1_type_symbol == NULL)
 
       
 17704                           IN1_type_symbol = last_type_symbol;
 
       
 17705                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17706                         
       
 17707                         if (IN2_type_symbol == NULL)
 
       
 17708                           IN2_type_symbol = last_type_symbol;
 
       
 17709                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17710                         symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
 
       
 17711                         break;
 
       
 17712                         
       
 17713                     }
 
       
 17714                     
       
 17715                     
       
 17716                     ERROR;
 
       
 17717                 }
 
       
 17718                 
       
 17719             }
 
       
 17720             
       
 17721             
       
 17722             ERROR;
 
       
 17723         }
 
       
 17724         
       
 17725     }/*function_sub_dt_time*/
 
 17099     break;
 
 17726     break;
 
 17100 
 17727 
 17101 /****
 
 17728 /****
 
 17102  *DIV
 
 17729  *DIV
 
 17103  */
 
 17730  */
 
 17205             
 17832             
 17206             ERROR;
 
 17833             ERROR;
 
 17207         }
 
 17834         }
 
 17208         
 17835         
 17209     }/*function_div*/
 
 17836     }/*function_div*/
 
       
 17837     break;
 
       
 17838 
       
 17839 /****
 
       
 17840  *DIVTIME
 
       
 17841  */
 
       
 17842     case function_divtime :
 
       
 17843     {
 
       
 17844         symbol_c *last_type_symbol = NULL;
 
       
 17845 
       
 17846         {
 
       
 17847             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 17848             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17849             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 17850             symbol_c *IN1_type_symbol = NULL;
 
       
 17851             
       
 17852             /* Get the value from a foo(<param_value>) style call */
 
       
 17853             if (IN1_param_value == NULL)
 
       
 17854               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 17855             if (IN1_param_value != NULL) {
 
       
 17856               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 17857               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 17858             }
 
       
 17859             
       
 17860             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol))
 
       
 17861             {
 
       
 17862         
       
 17863                 {
 
       
 17864                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 17865                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 17866                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 17867                     symbol_c *IN2_type_symbol = NULL;
 
       
 17868                     
       
 17869                     /* Get the value from a foo(<param_value>) style call */
 
       
 17870                     if (IN2_param_value == NULL)
 
       
 17871                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 17872                     if (IN2_param_value != NULL) {
 
       
 17873                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 17874                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 17875                     }
 
       
 17876                     
       
 17877                     if(IN2_type_symbol == NULL || search_expression_type->is_num_type(IN2_type_symbol))
 
       
 17878                     {
 
       
 17879                 
       
 17880                         function_name = (symbol_c*)(new pragma_c("__time_div"));
 
       
 17881                         
       
 17882                         if (IN1_type_symbol == NULL)
 
       
 17883                           IN1_type_symbol = last_type_symbol;
 
       
 17884                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 17885                         
       
 17886                         if (IN2_type_symbol == NULL)
 
       
 17887                           IN2_type_symbol = last_type_symbol;
 
       
 17888                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 17889                         symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
 
       
 17890                         if (search_expression_type->is_literal_integer_type(function_type_suffix))
 
       
 17891                             function_type_suffix = &search_constant_type_c::lint_type_name;
 
       
 17892                         break;
 
       
 17893                         
       
 17894                     }
 
       
 17895                     
       
 17896                     
       
 17897                     ERROR;
 
       
 17898                 }
 
       
 17899                 
       
 17900             }
 
       
 17901             
       
 17902             
       
 17903             ERROR;
 
       
 17904         }
 
       
 17905         
       
 17906     }/*function_divtime*/
 
 17210     break;
 
 17907     break;
 
 17211 
 17908 
 17212 /****
 
 17909 /****
 
 17213  *MOD
 
 17910  *MOD
 
 17214  */
 
 17911  */
 
 19427             if (IN1_param_value != NULL) {
 
 20124             if (IN1_param_value != NULL) {
 
 19428               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
 20125               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
 19429               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
 20126               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
 19430             }
 
 20127             }
 
 19431             
 20128             
 19432             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
 
       
 19433             {
 
       
 19434         
       
 19435                 {
 
       
 19436                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 19437                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 19438                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 19439                     symbol_c *IN2_type_symbol = NULL;
 
       
 19440                     
       
 19441                     /* Get the value from a foo(<param_value>) style call */
 
       
 19442                     if (IN2_param_value == NULL)
 
       
 19443                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 19444                     if (IN2_param_value != NULL) {
 
       
 19445                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 19446                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 19447                     }
 
       
 19448                     
       
 19449                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
 
       
 19450                     {
 
       
 19451                 
       
 19452                         function_name = (symbol_c*)(new pragma_c("__time_add"));
 
       
 19453                         
       
 19454                         if (IN1_type_symbol == NULL)
 
       
 19455                           IN1_type_symbol = last_type_symbol;
 
       
 19456                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 19457                         
       
 19458                         if (IN2_type_symbol == NULL)
 
       
 19459                           IN2_type_symbol = last_type_symbol;
 
       
 19460                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 19461                         symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
 
       
 19462                         break;
 
       
 19463                         
       
 19464                     }
 
       
 19465                     
       
 19466                     
       
 19467                     ERROR;
 
       
 19468                 }
 
       
 19469                 
       
 19470             }
 
       
 19471             
       
 19472             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
 
 20129             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol))
 
 19473             {
 
 20130             {
 
 19474         
 20131         
 19475                 {
 
 20132                 {
 
 19476                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
 20133                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
 19543             
 20200             
 19544             ERROR;
 
 20201             ERROR;
 
 19545         }
 
 20202         }
 
 19546         
 20203         
 19547     }/*function_concat*/
 
 20204     }/*function_concat*/
 
       
 20205     break;
 
       
 20206 
       
 20207 /****
 
       
 20208  *CONCAT_DAT_TOD
 
       
 20209  */
 
       
 20210     case function_concat_dat_tod :
 
       
 20211     {
 
       
 20212         symbol_c *last_type_symbol = NULL;
 
       
 20213 
       
 20214         {
 
       
 20215             symbol_c *IN1_param_name = (symbol_c *)(new identifier_c("IN1"));
 
       
 20216             /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 20217             symbol_c *IN1_param_value = function_call_param_iterator.search_f(IN1_param_name);
 
       
 20218             symbol_c *IN1_type_symbol = NULL;
 
       
 20219             
       
 20220             /* Get the value from a foo(<param_value>) style call */
 
       
 20221             if (IN1_param_value == NULL)
 
       
 20222               IN1_param_value = function_call_param_iterator.next_nf();
 
       
 20223             if (IN1_param_value != NULL) {
 
       
 20224               IN1_type_symbol = search_expression_type->get_type(IN1_param_value);
 
       
 20225               last_type_symbol = last_type_symbol && IN1_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ;
 
       
 20226             }
 
       
 20227             
       
 20228             if(IN1_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
 
       
 20229             {
 
       
 20230         
       
 20231                 {
 
       
 20232                     symbol_c *IN2_param_name = (symbol_c *)(new identifier_c("IN2"));
 
       
 20233                     /* Get the value from a foo(<param_name> = <param_value>) style call */
 
       
 20234                     symbol_c *IN2_param_value = function_call_param_iterator.search_f(IN2_param_name);
 
       
 20235                     symbol_c *IN2_type_symbol = NULL;
 
       
 20236                     
       
 20237                     /* Get the value from a foo(<param_value>) style call */
 
       
 20238                     if (IN2_param_value == NULL)
 
       
 20239                       IN2_param_value = function_call_param_iterator.next_nf();
 
       
 20240                     if (IN2_param_value != NULL) {
 
       
 20241                       IN2_type_symbol = search_expression_type->get_type(IN2_param_value);
 
       
 20242                       last_type_symbol = last_type_symbol && IN2_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ;
 
       
 20243                     }
 
       
 20244                     
       
 20245                     if(IN2_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
 
       
 20246                     {
 
       
 20247                 
       
 20248                         function_name = (symbol_c*)(new pragma_c("__time_add"));
 
       
 20249                         
       
 20250                         if (IN1_type_symbol == NULL)
 
       
 20251                           IN1_type_symbol = last_type_symbol;
 
       
 20252                         ADD_PARAM_LIST(IN1_param_name, IN1_param_value, IN1_type_symbol, function_param_iterator_c::direction_in)
 
       
 20253                         
       
 20254                         if (IN2_type_symbol == NULL)
 
       
 20255                           IN2_type_symbol = last_type_symbol;
 
       
 20256                         ADD_PARAM_LIST(IN2_param_name, IN2_param_value, IN2_type_symbol, function_param_iterator_c::direction_in)
 
       
 20257                         symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
 
       
 20258                         break;
 
       
 20259                         
       
 20260                     }
 
       
 20261                     
       
 20262                     
       
 20263                     ERROR;
 
       
 20264                 }
 
       
 20265                 
       
 20266             }
 
       
 20267             
       
 20268             
       
 20269             ERROR;
 
       
 20270         }
 
       
 20271         
       
 20272     }/*function_concat_dat_tod*/
 
 19548     break;
 
 20273     break;
 
 19549 
 20274 
 19550 /****
 
 20275 /****
 
 19551  *INSERT
 
 20276  *INSERT
 
 19552  */
 
 20277  */
matiec