644                 symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   645                 s4o.print("(");

   646                 return_type_symbol->accept(*this);

   647                 s4o.print(")__real_to_time(");

   648                 IN_param_value->accept(*this);

   649                 s4o.print(")");

   650                 return NULL;

   651                 

   652             }

   653             

   654             ERROR;

   655         }

   656         

   657     }/*function_real_to_tod*/

   658     break;

   659 

   660 /****

   661  *REAL_TO_DT

   662  */

   663     case function_real_to_dt :

   664     {

   665         symbol_c *last_type_symbol = NULL;

   666 

   667         {

   668             identifier_c param_name("IN");

   669             /* Get the value from a foo(<param_name> = <param_value>) style call */

   670             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   671             

   672             /* Get the value from a foo(<param_value>) style call */

   673             if (IN_param_value == NULL)

   674               IN_param_value = function_call_param_iterator.next();

   675             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   676             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   677             

   678             if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   679             {

   680         

   681                 symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   682                 s4o.print("(");

   683                 return_type_symbol->accept(*this);

   684                 s4o.print(")__real_to_time(");

   685                 IN_param_value->accept(*this);

   686                 s4o.print(")");

   687                 return NULL;

   688                 

   689             }

   690             

   691             ERROR;

   692         }

   693         

   694     }/*function_real_to_dt*/

   695     break;

   696 

   697 /****

   698  *LREAL_TO_REAL

   699  */

   700     case function_lreal_to_real :

   701     {

   702         symbol_c *last_type_symbol = NULL;

   703 

   704         {

   705             identifier_c param_name("IN");

   706             /* Get the value from a foo(<param_name> = <param_value>) style call */

   707             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   708             

   709             /* Get the value from a foo(<param_value>) style call */

   710             if (IN_param_value == NULL)

   711               IN_param_value = function_call_param_iterator.next();

   712             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   713             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   714             

   715             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   716             {

   717         

   718                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   719                 s4o.print("(");

   720                 return_type_symbol->accept(*this);

   721                 s4o.print(")");

   722                 IN_param_value->accept(*this);

   723                 return NULL;

   724                 

   725             }

   726             

   727             ERROR;

   728         }

   729         

   730     }/*function_lreal_to_real*/

   731     break;

   732 

   733 /****

   734  *LREAL_TO_SINT

   735  */

   736     case function_lreal_to_sint :

   737     {

   738         symbol_c *last_type_symbol = NULL;

   739 

   740         {

   741             identifier_c param_name("IN");

   742             /* Get the value from a foo(<param_name> = <param_value>) style call */

   743             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   744             

   745             /* Get the value from a foo(<param_value>) style call */

   746             if (IN_param_value == NULL)

   747               IN_param_value = function_call_param_iterator.next();

   748             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   749             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   750             

   751             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   752             {

   753         

   754                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

   755                 s4o.print("(");

   756                 return_type_symbol->accept(*this);

   757                 s4o.print(")");

   758                 IN_param_value->accept(*this);

   759                 return NULL;

   760                 

   761             }

   762             

   763             ERROR;

   764         }

   765         

   766     }/*function_lreal_to_sint*/

   767     break;

   768 

   769 /****

   770  *LREAL_TO_INT

   771  */

   772     case function_lreal_to_int :

   773     {

   774         symbol_c *last_type_symbol = NULL;

   775 

   776         {

   777             identifier_c param_name("IN");

   778             /* Get the value from a foo(<param_name> = <param_value>) style call */

   779             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   780             

   781             /* Get the value from a foo(<param_value>) style call */

   782             if (IN_param_value == NULL)

   783               IN_param_value = function_call_param_iterator.next();

   784             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   785             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   786             

   787             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   788             {

   789         

   790                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

   791                 s4o.print("(");

   792                 return_type_symbol->accept(*this);

   793                 s4o.print(")");

   794                 IN_param_value->accept(*this);

   795                 return NULL;

   796                 

   797             }

   798             

   799             ERROR;

   800         }

   801         

   802     }/*function_lreal_to_int*/

   803     break;

   804 

   805 /****

   806  *LREAL_TO_DINT

   807  */

   808     case function_lreal_to_dint :

   809     {

   810         symbol_c *last_type_symbol = NULL;

   811 

   812         {

   813             identifier_c param_name("IN");

   814             /* Get the value from a foo(<param_name> = <param_value>) style call */

   815             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   816             

   817             /* Get the value from a foo(<param_value>) style call */

   818             if (IN_param_value == NULL)

   819               IN_param_value = function_call_param_iterator.next();

   820             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   821             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   822             

   823             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   824             {

   825         

   826                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   827                 s4o.print("(");

   828                 return_type_symbol->accept(*this);

   829                 s4o.print(")");

   830                 IN_param_value->accept(*this);

   831                 return NULL;

   832                 

   833             }

   834             

   835             ERROR;

   836         }

   837         

   838     }/*function_lreal_to_dint*/

   839     break;

   840 

   841 /****

   842  *LREAL_TO_LINT

   843  */

   844     case function_lreal_to_lint :

   845     {

   846         symbol_c *last_type_symbol = NULL;

   847 

   848         {

   849             identifier_c param_name("IN");

   850             /* Get the value from a foo(<param_name> = <param_value>) style call */

   851             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   852             

   853             /* Get the value from a foo(<param_value>) style call */

   854             if (IN_param_value == NULL)

   855               IN_param_value = function_call_param_iterator.next();

   856             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   857             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   858             

   859             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   860             {

   861         

   862                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   863                 s4o.print("(");

   864                 return_type_symbol->accept(*this);

   865                 s4o.print(")");

   866                 IN_param_value->accept(*this);

   867                 return NULL;

   868                 

   869             }

   870             

   871             ERROR;

   872         }

   873         

   874     }/*function_lreal_to_lint*/

   875     break;

   876 

   877 /****

   878  *LREAL_TO_USINT

   879  */

   880     case function_lreal_to_usint :

   881     {

   882         symbol_c *last_type_symbol = NULL;

   883 

   884         {

   885             identifier_c param_name("IN");

   886             /* Get the value from a foo(<param_name> = <param_value>) style call */

   887             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   888             

   889             /* Get the value from a foo(<param_value>) style call */

   890             if (IN_param_value == NULL)

   891               IN_param_value = function_call_param_iterator.next();

   892             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   893             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   894             

   895             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   896             {

   897         

   898                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   899                 s4o.print("(");

   900                 return_type_symbol->accept(*this);

   901                 s4o.print(")");

   902                 IN_param_value->accept(*this);

   903                 return NULL;

   904                 

   905             }

   906             

   907             ERROR;

   908         }

   909         

   910     }/*function_lreal_to_usint*/

   911     break;

   912 

   913 /****

   914  *LREAL_TO_UINT

   915  */

   916     case function_lreal_to_uint :

   917     {

   918         symbol_c *last_type_symbol = NULL;

   919 

   920         {

   921             identifier_c param_name("IN");

   922             /* Get the value from a foo(<param_name> = <param_value>) style call */

   923             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   924             

   925             /* Get the value from a foo(<param_value>) style call */

   926             if (IN_param_value == NULL)

   927               IN_param_value = function_call_param_iterator.next();

   928             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   929             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   930             

   931             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   932             {

   933         

   934                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   935                 s4o.print("(");

   936                 return_type_symbol->accept(*this);

   937                 s4o.print(")");

   938                 IN_param_value->accept(*this);

   939                 return NULL;

   940                 

   941             }

   942             

   943             ERROR;

   944         }

   945         

   946     }/*function_lreal_to_uint*/

   947     break;

   948 

   949 /****

   950  *LREAL_TO_UDINT

   951  */

   952     case function_lreal_to_udint :

   953     {

   954         symbol_c *last_type_symbol = NULL;

   955 

   956         {

   957             identifier_c param_name("IN");

   958             /* Get the value from a foo(<param_name> = <param_value>) style call */

   959             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   960             

   961             /* Get the value from a foo(<param_value>) style call */

   962             if (IN_param_value == NULL)

   963               IN_param_value = function_call_param_iterator.next();

   964             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   965             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   966             

   967             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

   968             {

   969         

   970                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   971                 s4o.print("(");

   972                 return_type_symbol->accept(*this);

   973                 s4o.print(")");

   974                 IN_param_value->accept(*this);

   975                 return NULL;

   976                 

   977             }

   978             

   979             ERROR;

   980         }

   981         

   982     }/*function_lreal_to_udint*/

   983     break;

   984 

   985 /****

   986  *LREAL_TO_ULINT

   987  */

   988     case function_lreal_to_ulint :

   989     {

   990         symbol_c *last_type_symbol = NULL;

   991 

   992         {

   993             identifier_c param_name("IN");

   994             /* Get the value from a foo(<param_name> = <param_value>) style call */

   995             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   996             

   997             /* Get the value from a foo(<param_value>) style call */

   998             if (IN_param_value == NULL)

   999               IN_param_value = function_call_param_iterator.next();

  1000             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1001             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1002             

  1003             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1004             {

  1005         

  1006                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

  1007                 s4o.print("(");

  1008                 return_type_symbol->accept(*this);

  1009                 s4o.print(")");

  1010                 IN_param_value->accept(*this);

  1011                 return NULL;

  1012                 

  1013             }

  1014             

  1015             ERROR;

  1016         }

  1017         

  1018     }/*function_lreal_to_ulint*/

  1019     break;

  1020 

  1021 /****

  1022  *LREAL_TO_TIME

  1023  */

  1024     case function_lreal_to_time :

  1025     {

  1026         symbol_c *last_type_symbol = NULL;

  1027 

  1028         {

  1029             identifier_c param_name("IN");

  1030             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1031             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1032             

  1033             /* Get the value from a foo(<param_value>) style call */

  1034             if (IN_param_value == NULL)

  1035               IN_param_value = function_call_param_iterator.next();

  1036             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1037             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1038             

  1039             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1040             {

  1041         

  1042                 symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

  1043                 s4o.print("(");

  1044                 return_type_symbol->accept(*this);

  1045                 s4o.print(")__real_to_time(");

  1046                 IN_param_value->accept(*this);

  1047                 s4o.print(")");

  1048                 return NULL;

  1049                 

  1050             }

  1051             

  1052             ERROR;

  1053         }

  1054         

  1055     }/*function_lreal_to_time*/

  1056     break;

  1057 

  1058 /****

  1059  *LREAL_TO_BOOL

  1060  */

  1061     case function_lreal_to_bool :

  1062     {

  1063         symbol_c *last_type_symbol = NULL;

  1064 

  1065         {

  1066             identifier_c param_name("IN");

  1067             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1068             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1069             

  1070             /* Get the value from a foo(<param_value>) style call */

  1071             if (IN_param_value == NULL)

  1072               IN_param_value = function_call_param_iterator.next();

  1073             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1074             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1075             

  1076             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1077             {

  1078         

  1079                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

  1080                 s4o.print("(");

  1081                 return_type_symbol->accept(*this);

  1082                 s4o.print(")");

  1083                 IN_param_value->accept(*this);

  1084                 return NULL;

  1085                 

  1086             }

  1087             

  1088             ERROR;

  1089         }

  1090         

  1091     }/*function_lreal_to_bool*/

  1092     break;

  1093 

  1094 /****

  1095  *LREAL_TO_BYTE

  1096  */

  1097     case function_lreal_to_byte :

  1098     {

  1099         symbol_c *last_type_symbol = NULL;

  1100 

  1101         {

  1102             identifier_c param_name("IN");

  1103             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1104             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1105             

  1106             /* Get the value from a foo(<param_value>) style call */

  1107             if (IN_param_value == NULL)

  1108               IN_param_value = function_call_param_iterator.next();

  1109             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1110             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1111             

  1112             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1113             {

  1114         

  1115                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

  1116                 s4o.print("(");

  1117                 return_type_symbol->accept(*this);

  1118                 s4o.print(")");

  1119                 IN_param_value->accept(*this);

  1120                 return NULL;

  1121                 

  1122             }

  1123             

  1124             ERROR;

  1125         }

  1126         

  1127     }/*function_lreal_to_byte*/

  1128     break;

  1129 

  1130 /****

  1131  *LREAL_TO_WORD

  1132  */

  1133     case function_lreal_to_word :

  1134     {

  1135         symbol_c *last_type_symbol = NULL;

  1136 

  1137         {

  1138             identifier_c param_name("IN");

  1139             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1140             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1141             

  1142             /* Get the value from a foo(<param_value>) style call */

  1143             if (IN_param_value == NULL)

  1144               IN_param_value = function_call_param_iterator.next();

  1145             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1146             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1147             

  1148             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1149             {

  1150         

  1151                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

  1152                 s4o.print("(");

  1153                 return_type_symbol->accept(*this);

  1154                 s4o.print(")");

  1155                 IN_param_value->accept(*this);

  1156                 return NULL;

  1157                 

  1158             }

  1159             

  1160             ERROR;

  1161         }

  1162         

  1163     }/*function_lreal_to_word*/

  1164     break;

  1165 

  1166 /****

  1167  *LREAL_TO_DWORD

  1168  */

  1169     case function_lreal_to_dword :

  1170     {

  1171         symbol_c *last_type_symbol = NULL;

  1172 

  1173         {

  1174             identifier_c param_name("IN");

  1175             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1176             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1177             

  1178             /* Get the value from a foo(<param_value>) style call */

  1179             if (IN_param_value == NULL)

  1180               IN_param_value = function_call_param_iterator.next();

  1181             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1182             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1183             

  1184             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1185             {

  1186         

  1187                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

  1188                 s4o.print("(");

  1189                 return_type_symbol->accept(*this);

  1190                 s4o.print(")");

  1191                 IN_param_value->accept(*this);

  1192                 return NULL;

  1193                 

  1194             }

  1195             

  1196             ERROR;

  1197         }

  1198         

  1199     }/*function_lreal_to_dword*/

  1200     break;

  1201 

  1202 /****

  1203  *LREAL_TO_LWORD

  1204  */

  1205     case function_lreal_to_lword :

  1206     {

  1207         symbol_c *last_type_symbol = NULL;

  1208 

  1209         {

  1210             identifier_c param_name("IN");

  1211             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1212             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1213             

  1214             /* Get the value from a foo(<param_value>) style call */

  1215             if (IN_param_value == NULL)

  1216               IN_param_value = function_call_param_iterator.next();

  1217             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1218             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1219             

  1220             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1221             {

  1222         

  1223                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

  1224                 s4o.print("(");

  1225                 return_type_symbol->accept(*this);

  1226                 s4o.print(")");

  1227                 IN_param_value->accept(*this);

  1228                 return NULL;

  1229                 

  1230             }

  1231             

  1232             ERROR;

  1233         }

  1234         

  1235     }/*function_lreal_to_lword*/

  1236     break;

  1237 

  1238 /****

  1239  *LREAL_TO_STRING

  1240  */

  1241     case function_lreal_to_string :

  1242     {

  1243         symbol_c *last_type_symbol = NULL;

  1244 

  1245         {

  1246             identifier_c param_name("IN");

  1247             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1248             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1249             

  1250             /* Get the value from a foo(<param_value>) style call */

  1251             if (IN_param_value == NULL)

  1252               IN_param_value = function_call_param_iterator.next();

  1253             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1254             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1255             

  1256             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1257             {

  1258         

  1259                 symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

  1260                 s4o.print("(");

  1261                 return_type_symbol->accept(*this);

  1262                 s4o.print(")__real_to_string(");

  1263                 IN_param_value->accept(*this);

  1264                 s4o.print(")");

  1265                 return NULL;

  1266                 

  1267             }

  1268             

  1269             ERROR;

  1270         }

  1271         

  1272     }/*function_lreal_to_string*/

  1273     break;

  1274 

  1275 /****

  1276  *LREAL_TO_DATE

  1277  */

  1278     case function_lreal_to_date :

  1279     {

  1280         symbol_c *last_type_symbol = NULL;

  1281 

  1282         {

  1283             identifier_c param_name("IN");

  1284             /* Get the value from a foo(<param_name> = <param_value>) style call */

  1285             symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

  1286             

  1287             /* Get the value from a foo(<param_value>) style call */

  1288             if (IN_param_value == NULL)

  1289               IN_param_value = function_call_param_iterator.next();

  1290             symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

  1291             last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

  1292             

  1293             if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))

  1294             {

  1295