stage4/generate_c/il_code_gen.c
changeset 199 b075f28ec081
parent 169 bea932bc60b0
child 208 c72748a12ae3
equal deleted inserted replaced
198:f68ef6f05e17 199:b075f28ec081
    45             last_type_symbol = param_data_type;
    45             last_type_symbol = param_data_type;
    46             
    46             
    47             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
    47             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
    48             {
    48             {
    49         
    49         
       
    50                 function_name = (symbol_c*)(new pragma_c("__move_"));
    50                 
    51                 
    51                 if (IN_type_symbol == NULL)
    52                 if (IN_type_symbol == NULL)
    52                   IN_type_symbol = last_type_symbol;
    53                   IN_type_symbol = last_type_symbol;
    53                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
    54                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
    54                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
    55                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
    55                 function_type_prefix = return_type_symbol;
    56                 function_type_prefix = return_type_symbol;
       
    57                 function_type_suffix = IN_type_symbol;
    56                 break;
    58                 break;
    57                 
    59                 
    58             }
    60             }
    59             
    61             
    60             
    62             
    79             last_type_symbol = param_data_type;
    81             last_type_symbol = param_data_type;
    80             
    82             
    81             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
    83             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
    82             {
    84             {
    83         
    85         
       
    86                 function_name = (symbol_c*)(new pragma_c("__move_"));
    84                 
    87                 
    85                 if (IN_type_symbol == NULL)
    88                 if (IN_type_symbol == NULL)
    86                   IN_type_symbol = last_type_symbol;
    89                   IN_type_symbol = last_type_symbol;
    87                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
    90                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
    88                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
    91                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
    89                 function_type_prefix = return_type_symbol;
    92                 function_type_prefix = return_type_symbol;
       
    93                 function_type_suffix = IN_type_symbol;
    90                 break;
    94                 break;
    91                 
    95                 
    92             }
    96             }
    93             
    97             
    94             
    98             
   113             last_type_symbol = param_data_type;
   117             last_type_symbol = param_data_type;
   114             
   118             
   115             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   119             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   116             {
   120             {
   117         
   121         
       
   122                 function_name = (symbol_c*)(new pragma_c("__move_"));
   118                 
   123                 
   119                 if (IN_type_symbol == NULL)
   124                 if (IN_type_symbol == NULL)
   120                   IN_type_symbol = last_type_symbol;
   125                   IN_type_symbol = last_type_symbol;
   121                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   126                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   122                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
   127                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
   123                 function_type_prefix = return_type_symbol;
   128                 function_type_prefix = return_type_symbol;
       
   129                 function_type_suffix = IN_type_symbol;
   124                 break;
   130                 break;
   125                 
   131                 
   126             }
   132             }
   127             
   133             
   128             
   134             
   182             last_type_symbol = param_data_type;
   188             last_type_symbol = param_data_type;
   183             
   189             
   184             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   190             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   185             {
   191             {
   186         
   192         
       
   193                 function_name = (symbol_c*)(new pragma_c("__move_"));
   187                 
   194                 
   188                 if (IN_type_symbol == NULL)
   195                 if (IN_type_symbol == NULL)
   189                   IN_type_symbol = last_type_symbol;
   196                   IN_type_symbol = last_type_symbol;
   190                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   197                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   191                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
   198                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
   192                 function_type_prefix = return_type_symbol;
   199                 function_type_prefix = return_type_symbol;
       
   200                 function_type_suffix = IN_type_symbol;
   193                 break;
   201                 break;
   194                 
   202                 
   195             }
   203             }
   196             
   204             
   197             
   205             
   286             last_type_symbol = param_data_type;
   294             last_type_symbol = param_data_type;
   287             
   295             
   288             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   296             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   289             {
   297             {
   290         
   298         
       
   299                 function_name = (symbol_c*)(new pragma_c("__move_"));
   291                 
   300                 
   292                 if (IN_type_symbol == NULL)
   301                 if (IN_type_symbol == NULL)
   293                   IN_type_symbol = last_type_symbol;
   302                   IN_type_symbol = last_type_symbol;
   294                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   303                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   295                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
   304                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
   296                 function_type_prefix = return_type_symbol;
   305                 function_type_prefix = return_type_symbol;
       
   306                 function_type_suffix = IN_type_symbol;
   297                 break;
   307                 break;
   298                 
   308                 
   299             }
   309             }
   300             
   310             
   301             
   311             
   320             last_type_symbol = param_data_type;
   330             last_type_symbol = param_data_type;
   321             
   331             
   322             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   332             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   323             {
   333             {
   324         
   334         
       
   335                 function_name = (symbol_c*)(new pragma_c("__move_"));
   325                 
   336                 
   326                 if (IN_type_symbol == NULL)
   337                 if (IN_type_symbol == NULL)
   327                   IN_type_symbol = last_type_symbol;
   338                   IN_type_symbol = last_type_symbol;
   328                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   339                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   329                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
   340                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
   330                 function_type_prefix = return_type_symbol;
   341                 function_type_prefix = return_type_symbol;
       
   342                 function_type_suffix = IN_type_symbol;
   331                 break;
   343                 break;
   332                 
   344                 
   333             }
   345             }
   334             
   346             
   335             
   347             
   389             last_type_symbol = param_data_type;
   401             last_type_symbol = param_data_type;
   390             
   402             
   391             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   403             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   392             {
   404             {
   393         
   405         
       
   406                 function_name = (symbol_c*)(new pragma_c("__move_"));
   394                 
   407                 
   395                 if (IN_type_symbol == NULL)
   408                 if (IN_type_symbol == NULL)
   396                   IN_type_symbol = last_type_symbol;
   409                   IN_type_symbol = last_type_symbol;
   397                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   410                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   398                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
   411                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
   399                 function_type_prefix = return_type_symbol;
   412                 function_type_prefix = return_type_symbol;
       
   413                 function_type_suffix = IN_type_symbol;
   400                 break;
   414                 break;
   401                 
   415                 
   402             }
   416             }
   403             
   417             
   404             
   418             
   423             last_type_symbol = param_data_type;
   437             last_type_symbol = param_data_type;
   424             
   438             
   425             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   439             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   426             {
   440             {
   427         
   441         
       
   442                 function_name = (symbol_c*)(new pragma_c("__move_"));
   428                 
   443                 
   429                 if (IN_type_symbol == NULL)
   444                 if (IN_type_symbol == NULL)
   430                   IN_type_symbol = last_type_symbol;
   445                   IN_type_symbol = last_type_symbol;
   431                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   446                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   432                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
   447                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
   433                 function_type_prefix = return_type_symbol;
   448                 function_type_prefix = return_type_symbol;
       
   449                 function_type_suffix = IN_type_symbol;
   434                 break;
   450                 break;
   435                 
   451                 
   436             }
   452             }
   437             
   453             
   438             
   454             
   457             last_type_symbol = param_data_type;
   473             last_type_symbol = param_data_type;
   458             
   474             
   459             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   475             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   460             {
   476             {
   461         
   477         
       
   478                 function_name = (symbol_c*)(new pragma_c("__move_"));
   462                 
   479                 
   463                 if (IN_type_symbol == NULL)
   480                 if (IN_type_symbol == NULL)
   464                   IN_type_symbol = last_type_symbol;
   481                   IN_type_symbol = last_type_symbol;
   465                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   482                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   466                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
   483                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
   467                 function_type_prefix = return_type_symbol;
   484                 function_type_prefix = return_type_symbol;
       
   485                 function_type_suffix = IN_type_symbol;
   468                 break;
   486                 break;
   469                 
   487                 
   470             }
   488             }
   471             
   489             
   472             
   490             
   491             last_type_symbol = param_data_type;
   509             last_type_symbol = param_data_type;
   492             
   510             
   493             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   511             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   494             {
   512             {
   495         
   513         
       
   514                 function_name = (symbol_c*)(new pragma_c("__move_"));
   496                 
   515                 
   497                 if (IN_type_symbol == NULL)
   516                 if (IN_type_symbol == NULL)
   498                   IN_type_symbol = last_type_symbol;
   517                   IN_type_symbol = last_type_symbol;
   499                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   518                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   500                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
   519                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
   501                 function_type_prefix = return_type_symbol;
   520                 function_type_prefix = return_type_symbol;
       
   521                 function_type_suffix = IN_type_symbol;
   502                 break;
   522                 break;
   503                 
   523                 
   504             }
   524             }
   505             
   525             
   506             
   526             
   525             last_type_symbol = param_data_type;
   545             last_type_symbol = param_data_type;
   526             
   546             
   527             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   547             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   528             {
   548             {
   529         
   549         
       
   550                 function_name = (symbol_c*)(new pragma_c("__move_"));
   530                 
   551                 
   531                 if (IN_type_symbol == NULL)
   552                 if (IN_type_symbol == NULL)
   532                   IN_type_symbol = last_type_symbol;
   553                   IN_type_symbol = last_type_symbol;
   533                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   554                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   534                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
   555                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
   535                 function_type_prefix = return_type_symbol;
   556                 function_type_prefix = return_type_symbol;
       
   557                 function_type_suffix = IN_type_symbol;
   536                 break;
   558                 break;
   537                 
   559                 
   538             }
   560             }
   539             
   561             
   540             
   562             
   559             last_type_symbol = param_data_type;
   581             last_type_symbol = param_data_type;
   560             
   582             
   561             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   583             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   562             {
   584             {
   563         
   585         
       
   586                 function_name = (symbol_c*)(new pragma_c("__move_"));
   564                 
   587                 
   565                 if (IN_type_symbol == NULL)
   588                 if (IN_type_symbol == NULL)
   566                   IN_type_symbol = last_type_symbol;
   589                   IN_type_symbol = last_type_symbol;
   567                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   590                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   568                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
   591                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
   569                 function_type_prefix = return_type_symbol;
   592                 function_type_prefix = return_type_symbol;
       
   593                 function_type_suffix = IN_type_symbol;
   570                 break;
   594                 break;
   571                 
   595                 
   572             }
   596             }
   573             
   597             
   574             
   598             
   593             last_type_symbol = param_data_type;
   617             last_type_symbol = param_data_type;
   594             
   618             
   595             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   619             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   596             {
   620             {
   597         
   621         
       
   622                 function_name = (symbol_c*)(new pragma_c("__move_"));
   598                 
   623                 
   599                 if (IN_type_symbol == NULL)
   624                 if (IN_type_symbol == NULL)
   600                   IN_type_symbol = last_type_symbol;
   625                   IN_type_symbol = last_type_symbol;
   601                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   626                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   602                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
   627                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
   603                 function_type_prefix = return_type_symbol;
   628                 function_type_prefix = return_type_symbol;
       
   629                 function_type_suffix = IN_type_symbol;
   604                 break;
   630                 break;
   605                 
   631                 
   606             }
   632             }
   607             
   633             
   608             
   634             
   662             last_type_symbol = param_data_type;
   688             last_type_symbol = param_data_type;
   663             
   689             
   664             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   690             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
   665             {
   691             {
   666         
   692         
       
   693                 function_name = (symbol_c*)(new pragma_c("__move_"));
   667                 
   694                 
   668                 if (IN_type_symbol == NULL)
   695                 if (IN_type_symbol == NULL)
   669                   IN_type_symbol = last_type_symbol;
   696                   IN_type_symbol = last_type_symbol;
   670                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   697                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   671                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
   698                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
   672                 function_type_prefix = return_type_symbol;
   699                 function_type_prefix = return_type_symbol;
       
   700                 function_type_suffix = IN_type_symbol;
   673                 break;
   701                 break;
   674                 
   702                 
   675             }
   703             }
   676             
   704             
   677             
   705             
   696             last_type_symbol = param_data_type;
   724             last_type_symbol = param_data_type;
   697             
   725             
   698             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   726             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   699             {
   727             {
   700         
   728         
       
   729                 function_name = (symbol_c*)(new pragma_c("__move_"));
   701                 
   730                 
   702                 if (IN_type_symbol == NULL)
   731                 if (IN_type_symbol == NULL)
   703                   IN_type_symbol = last_type_symbol;
   732                   IN_type_symbol = last_type_symbol;
   704                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   733                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   705                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
   734                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
   706                 function_type_prefix = return_type_symbol;
   735                 function_type_prefix = return_type_symbol;
       
   736                 function_type_suffix = IN_type_symbol;
   707                 break;
   737                 break;
   708                 
   738                 
   709             }
   739             }
   710             
   740             
   711             
   741             
   730             last_type_symbol = param_data_type;
   760             last_type_symbol = param_data_type;
   731             
   761             
   732             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   762             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   733             {
   763             {
   734         
   764         
       
   765                 function_name = (symbol_c*)(new pragma_c("__move_"));
   735                 
   766                 
   736                 if (IN_type_symbol == NULL)
   767                 if (IN_type_symbol == NULL)
   737                   IN_type_symbol = last_type_symbol;
   768                   IN_type_symbol = last_type_symbol;
   738                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   769                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   739                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
   770                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
   740                 function_type_prefix = return_type_symbol;
   771                 function_type_prefix = return_type_symbol;
       
   772                 function_type_suffix = IN_type_symbol;
   741                 break;
   773                 break;
   742                 
   774                 
   743             }
   775             }
   744             
   776             
   745             
   777             
   764             last_type_symbol = param_data_type;
   796             last_type_symbol = param_data_type;
   765             
   797             
   766             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   798             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   767             {
   799             {
   768         
   800         
       
   801                 function_name = (symbol_c*)(new pragma_c("__move_"));
   769                 
   802                 
   770                 if (IN_type_symbol == NULL)
   803                 if (IN_type_symbol == NULL)
   771                   IN_type_symbol = last_type_symbol;
   804                   IN_type_symbol = last_type_symbol;
   772                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   805                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   773                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
   806                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
   774                 function_type_prefix = return_type_symbol;
   807                 function_type_prefix = return_type_symbol;
       
   808                 function_type_suffix = IN_type_symbol;
   775                 break;
   809                 break;
   776                 
   810                 
   777             }
   811             }
   778             
   812             
   779             
   813             
   833             last_type_symbol = param_data_type;
   867             last_type_symbol = param_data_type;
   834             
   868             
   835             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   869             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   836             {
   870             {
   837         
   871         
       
   872                 function_name = (symbol_c*)(new pragma_c("__move_"));
   838                 
   873                 
   839                 if (IN_type_symbol == NULL)
   874                 if (IN_type_symbol == NULL)
   840                   IN_type_symbol = last_type_symbol;
   875                   IN_type_symbol = last_type_symbol;
   841                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   876                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   842                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
   877                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
   843                 function_type_prefix = return_type_symbol;
   878                 function_type_prefix = return_type_symbol;
       
   879                 function_type_suffix = IN_type_symbol;
   844                 break;
   880                 break;
   845                 
   881                 
   846             }
   882             }
   847             
   883             
   848             
   884             
   937             last_type_symbol = param_data_type;
   973             last_type_symbol = param_data_type;
   938             
   974             
   939             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   975             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   940             {
   976             {
   941         
   977         
       
   978                 function_name = (symbol_c*)(new pragma_c("__move_"));
   942                 
   979                 
   943                 if (IN_type_symbol == NULL)
   980                 if (IN_type_symbol == NULL)
   944                   IN_type_symbol = last_type_symbol;
   981                   IN_type_symbol = last_type_symbol;
   945                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   982                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   946                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
   983                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
   947                 function_type_prefix = return_type_symbol;
   984                 function_type_prefix = return_type_symbol;
       
   985                 function_type_suffix = IN_type_symbol;
   948                 break;
   986                 break;
   949                 
   987                 
   950             }
   988             }
   951             
   989             
   952             
   990             
   971             last_type_symbol = param_data_type;
  1009             last_type_symbol = param_data_type;
   972             
  1010             
   973             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1011             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
   974             {
  1012             {
   975         
  1013         
       
  1014                 function_name = (symbol_c*)(new pragma_c("__move_"));
   976                 
  1015                 
   977                 if (IN_type_symbol == NULL)
  1016                 if (IN_type_symbol == NULL)
   978                   IN_type_symbol = last_type_symbol;
  1017                   IN_type_symbol = last_type_symbol;
   979                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1018                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
   980                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  1019                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
   981                 function_type_prefix = return_type_symbol;
  1020                 function_type_prefix = return_type_symbol;
       
  1021                 function_type_suffix = IN_type_symbol;
   982                 break;
  1022                 break;
   983                 
  1023                 
   984             }
  1024             }
   985             
  1025             
   986             
  1026             
  1040             last_type_symbol = param_data_type;
  1080             last_type_symbol = param_data_type;
  1041             
  1081             
  1042             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1082             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1043             {
  1083             {
  1044         
  1084         
       
  1085                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1045                 
  1086                 
  1046                 if (IN_type_symbol == NULL)
  1087                 if (IN_type_symbol == NULL)
  1047                   IN_type_symbol = last_type_symbol;
  1088                   IN_type_symbol = last_type_symbol;
  1048                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1089                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1049                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  1090                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  1050                 function_type_prefix = return_type_symbol;
  1091                 function_type_prefix = return_type_symbol;
       
  1092                 function_type_suffix = IN_type_symbol;
  1051                 break;
  1093                 break;
  1052                 
  1094                 
  1053             }
  1095             }
  1054             
  1096             
  1055             
  1097             
  1074             last_type_symbol = param_data_type;
  1116             last_type_symbol = param_data_type;
  1075             
  1117             
  1076             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1118             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1077             {
  1119             {
  1078         
  1120         
       
  1121                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1079                 
  1122                 
  1080                 if (IN_type_symbol == NULL)
  1123                 if (IN_type_symbol == NULL)
  1081                   IN_type_symbol = last_type_symbol;
  1124                   IN_type_symbol = last_type_symbol;
  1082                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1125                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1083                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  1126                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  1084                 function_type_prefix = return_type_symbol;
  1127                 function_type_prefix = return_type_symbol;
       
  1128                 function_type_suffix = IN_type_symbol;
  1085                 break;
  1129                 break;
  1086                 
  1130                 
  1087             }
  1131             }
  1088             
  1132             
  1089             
  1133             
  1108             last_type_symbol = param_data_type;
  1152             last_type_symbol = param_data_type;
  1109             
  1153             
  1110             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1154             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1111             {
  1155             {
  1112         
  1156         
       
  1157                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1113                 
  1158                 
  1114                 if (IN_type_symbol == NULL)
  1159                 if (IN_type_symbol == NULL)
  1115                   IN_type_symbol = last_type_symbol;
  1160                   IN_type_symbol = last_type_symbol;
  1116                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1161                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1117                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  1162                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  1118                 function_type_prefix = return_type_symbol;
  1163                 function_type_prefix = return_type_symbol;
       
  1164                 function_type_suffix = IN_type_symbol;
  1119                 break;
  1165                 break;
  1120                 
  1166                 
  1121             }
  1167             }
  1122             
  1168             
  1123             
  1169             
  1142             last_type_symbol = param_data_type;
  1188             last_type_symbol = param_data_type;
  1143             
  1189             
  1144             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1190             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1145             {
  1191             {
  1146         
  1192         
       
  1193                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1147                 
  1194                 
  1148                 if (IN_type_symbol == NULL)
  1195                 if (IN_type_symbol == NULL)
  1149                   IN_type_symbol = last_type_symbol;
  1196                   IN_type_symbol = last_type_symbol;
  1150                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1197                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1151                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  1198                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  1152                 function_type_prefix = return_type_symbol;
  1199                 function_type_prefix = return_type_symbol;
       
  1200                 function_type_suffix = IN_type_symbol;
  1153                 break;
  1201                 break;
  1154                 
  1202                 
  1155             }
  1203             }
  1156             
  1204             
  1157             
  1205             
  1176             last_type_symbol = param_data_type;
  1224             last_type_symbol = param_data_type;
  1177             
  1225             
  1178             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1226             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1179             {
  1227             {
  1180         
  1228         
       
  1229                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1181                 
  1230                 
  1182                 if (IN_type_symbol == NULL)
  1231                 if (IN_type_symbol == NULL)
  1183                   IN_type_symbol = last_type_symbol;
  1232                   IN_type_symbol = last_type_symbol;
  1184                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1233                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1185                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  1234                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  1186                 function_type_prefix = return_type_symbol;
  1235                 function_type_prefix = return_type_symbol;
       
  1236                 function_type_suffix = IN_type_symbol;
  1187                 break;
  1237                 break;
  1188                 
  1238                 
  1189             }
  1239             }
  1190             
  1240             
  1191             
  1241             
  1210             last_type_symbol = param_data_type;
  1260             last_type_symbol = param_data_type;
  1211             
  1261             
  1212             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1262             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1213             {
  1263             {
  1214         
  1264         
       
  1265                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1215                 
  1266                 
  1216                 if (IN_type_symbol == NULL)
  1267                 if (IN_type_symbol == NULL)
  1217                   IN_type_symbol = last_type_symbol;
  1268                   IN_type_symbol = last_type_symbol;
  1218                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1269                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1219                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  1270                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  1220                 function_type_prefix = return_type_symbol;
  1271                 function_type_prefix = return_type_symbol;
       
  1272                 function_type_suffix = IN_type_symbol;
  1221                 break;
  1273                 break;
  1222                 
  1274                 
  1223             }
  1275             }
  1224             
  1276             
  1225             
  1277             
  1244             last_type_symbol = param_data_type;
  1296             last_type_symbol = param_data_type;
  1245             
  1297             
  1246             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1298             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1247             {
  1299             {
  1248         
  1300         
       
  1301                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1249                 
  1302                 
  1250                 if (IN_type_symbol == NULL)
  1303                 if (IN_type_symbol == NULL)
  1251                   IN_type_symbol = last_type_symbol;
  1304                   IN_type_symbol = last_type_symbol;
  1252                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1305                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1253                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  1306                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  1254                 function_type_prefix = return_type_symbol;
  1307                 function_type_prefix = return_type_symbol;
       
  1308                 function_type_suffix = IN_type_symbol;
  1255                 break;
  1309                 break;
  1256                 
  1310                 
  1257             }
  1311             }
  1258             
  1312             
  1259             
  1313             
  1313             last_type_symbol = param_data_type;
  1367             last_type_symbol = param_data_type;
  1314             
  1368             
  1315             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1369             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
  1316             {
  1370             {
  1317         
  1371         
       
  1372                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1318                 
  1373                 
  1319                 if (IN_type_symbol == NULL)
  1374                 if (IN_type_symbol == NULL)
  1320                   IN_type_symbol = last_type_symbol;
  1375                   IN_type_symbol = last_type_symbol;
  1321                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1376                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1322                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  1377                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  1323                 function_type_prefix = return_type_symbol;
  1378                 function_type_prefix = return_type_symbol;
       
  1379                 function_type_suffix = IN_type_symbol;
  1324                 break;
  1380                 break;
  1325                 
  1381                 
  1326             }
  1382             }
  1327             
  1383             
  1328             
  1384             
  1347             last_type_symbol = param_data_type;
  1403             last_type_symbol = param_data_type;
  1348             
  1404             
  1349             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1405             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1350             {
  1406             {
  1351         
  1407         
       
  1408                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1352                 
  1409                 
  1353                 if (IN_type_symbol == NULL)
  1410                 if (IN_type_symbol == NULL)
  1354                   IN_type_symbol = last_type_symbol;
  1411                   IN_type_symbol = last_type_symbol;
  1355                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1412                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1356                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  1413                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  1357                 function_type_prefix = return_type_symbol;
  1414                 function_type_prefix = return_type_symbol;
       
  1415                 function_type_suffix = IN_type_symbol;
  1358                 break;
  1416                 break;
  1359                 
  1417                 
  1360             }
  1418             }
  1361             
  1419             
  1362             
  1420             
  1381             last_type_symbol = param_data_type;
  1439             last_type_symbol = param_data_type;
  1382             
  1440             
  1383             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1441             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1384             {
  1442             {
  1385         
  1443         
       
  1444                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1386                 
  1445                 
  1387                 if (IN_type_symbol == NULL)
  1446                 if (IN_type_symbol == NULL)
  1388                   IN_type_symbol = last_type_symbol;
  1447                   IN_type_symbol = last_type_symbol;
  1389                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1448                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1390                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  1449                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  1391                 function_type_prefix = return_type_symbol;
  1450                 function_type_prefix = return_type_symbol;
       
  1451                 function_type_suffix = IN_type_symbol;
  1392                 break;
  1452                 break;
  1393                 
  1453                 
  1394             }
  1454             }
  1395             
  1455             
  1396             
  1456             
  1415             last_type_symbol = param_data_type;
  1475             last_type_symbol = param_data_type;
  1416             
  1476             
  1417             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1477             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1418             {
  1478             {
  1419         
  1479         
       
  1480                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1420                 
  1481                 
  1421                 if (IN_type_symbol == NULL)
  1482                 if (IN_type_symbol == NULL)
  1422                   IN_type_symbol = last_type_symbol;
  1483                   IN_type_symbol = last_type_symbol;
  1423                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1484                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1424                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  1485                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  1425                 function_type_prefix = return_type_symbol;
  1486                 function_type_prefix = return_type_symbol;
       
  1487                 function_type_suffix = IN_type_symbol;
  1426                 break;
  1488                 break;
  1427                 
  1489                 
  1428             }
  1490             }
  1429             
  1491             
  1430             
  1492             
  1484             last_type_symbol = param_data_type;
  1546             last_type_symbol = param_data_type;
  1485             
  1547             
  1486             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1548             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1487             {
  1549             {
  1488         
  1550         
       
  1551                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1489                 
  1552                 
  1490                 if (IN_type_symbol == NULL)
  1553                 if (IN_type_symbol == NULL)
  1491                   IN_type_symbol = last_type_symbol;
  1554                   IN_type_symbol = last_type_symbol;
  1492                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1555                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1493                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  1556                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  1494                 function_type_prefix = return_type_symbol;
  1557                 function_type_prefix = return_type_symbol;
       
  1558                 function_type_suffix = IN_type_symbol;
  1495                 break;
  1559                 break;
  1496                 
  1560                 
  1497             }
  1561             }
  1498             
  1562             
  1499             
  1563             
  1588             last_type_symbol = param_data_type;
  1652             last_type_symbol = param_data_type;
  1589             
  1653             
  1590             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1654             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1591             {
  1655             {
  1592         
  1656         
       
  1657                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1593                 
  1658                 
  1594                 if (IN_type_symbol == NULL)
  1659                 if (IN_type_symbol == NULL)
  1595                   IN_type_symbol = last_type_symbol;
  1660                   IN_type_symbol = last_type_symbol;
  1596                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1661                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1597                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  1662                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  1598                 function_type_prefix = return_type_symbol;
  1663                 function_type_prefix = return_type_symbol;
       
  1664                 function_type_suffix = IN_type_symbol;
  1599                 break;
  1665                 break;
  1600                 
  1666                 
  1601             }
  1667             }
  1602             
  1668             
  1603             
  1669             
  1622             last_type_symbol = param_data_type;
  1688             last_type_symbol = param_data_type;
  1623             
  1689             
  1624             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1690             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1625             {
  1691             {
  1626         
  1692         
       
  1693                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1627                 
  1694                 
  1628                 if (IN_type_symbol == NULL)
  1695                 if (IN_type_symbol == NULL)
  1629                   IN_type_symbol = last_type_symbol;
  1696                   IN_type_symbol = last_type_symbol;
  1630                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1697                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1631                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  1698                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  1632                 function_type_prefix = return_type_symbol;
  1699                 function_type_prefix = return_type_symbol;
       
  1700                 function_type_suffix = IN_type_symbol;
  1633                 break;
  1701                 break;
  1634                 
  1702                 
  1635             }
  1703             }
  1636             
  1704             
  1637             
  1705             
  1691             last_type_symbol = param_data_type;
  1759             last_type_symbol = param_data_type;
  1692             
  1760             
  1693             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1761             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1694             {
  1762             {
  1695         
  1763         
       
  1764                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1696                 
  1765                 
  1697                 if (IN_type_symbol == NULL)
  1766                 if (IN_type_symbol == NULL)
  1698                   IN_type_symbol = last_type_symbol;
  1767                   IN_type_symbol = last_type_symbol;
  1699                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1768                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1700                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  1769                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  1701                 function_type_prefix = return_type_symbol;
  1770                 function_type_prefix = return_type_symbol;
       
  1771                 function_type_suffix = IN_type_symbol;
  1702                 break;
  1772                 break;
  1703                 
  1773                 
  1704             }
  1774             }
  1705             
  1775             
  1706             
  1776             
  1725             last_type_symbol = param_data_type;
  1795             last_type_symbol = param_data_type;
  1726             
  1796             
  1727             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1797             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1728             {
  1798             {
  1729         
  1799         
       
  1800                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1730                 
  1801                 
  1731                 if (IN_type_symbol == NULL)
  1802                 if (IN_type_symbol == NULL)
  1732                   IN_type_symbol = last_type_symbol;
  1803                   IN_type_symbol = last_type_symbol;
  1733                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1804                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1734                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  1805                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  1735                 function_type_prefix = return_type_symbol;
  1806                 function_type_prefix = return_type_symbol;
       
  1807                 function_type_suffix = IN_type_symbol;
  1736                 break;
  1808                 break;
  1737                 
  1809                 
  1738             }
  1810             }
  1739             
  1811             
  1740             
  1812             
  1759             last_type_symbol = param_data_type;
  1831             last_type_symbol = param_data_type;
  1760             
  1832             
  1761             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1833             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1762             {
  1834             {
  1763         
  1835         
       
  1836                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1764                 
  1837                 
  1765                 if (IN_type_symbol == NULL)
  1838                 if (IN_type_symbol == NULL)
  1766                   IN_type_symbol = last_type_symbol;
  1839                   IN_type_symbol = last_type_symbol;
  1767                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1840                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1768                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  1841                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  1769                 function_type_prefix = return_type_symbol;
  1842                 function_type_prefix = return_type_symbol;
       
  1843                 function_type_suffix = IN_type_symbol;
  1770                 break;
  1844                 break;
  1771                 
  1845                 
  1772             }
  1846             }
  1773             
  1847             
  1774             
  1848             
  1793             last_type_symbol = param_data_type;
  1867             last_type_symbol = param_data_type;
  1794             
  1868             
  1795             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1869             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1796             {
  1870             {
  1797         
  1871         
       
  1872                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1798                 
  1873                 
  1799                 if (IN_type_symbol == NULL)
  1874                 if (IN_type_symbol == NULL)
  1800                   IN_type_symbol = last_type_symbol;
  1875                   IN_type_symbol = last_type_symbol;
  1801                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1876                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1802                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  1877                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  1803                 function_type_prefix = return_type_symbol;
  1878                 function_type_prefix = return_type_symbol;
       
  1879                 function_type_suffix = IN_type_symbol;
  1804                 break;
  1880                 break;
  1805                 
  1881                 
  1806             }
  1882             }
  1807             
  1883             
  1808             
  1884             
  1827             last_type_symbol = param_data_type;
  1903             last_type_symbol = param_data_type;
  1828             
  1904             
  1829             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1905             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1830             {
  1906             {
  1831         
  1907         
       
  1908                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1832                 
  1909                 
  1833                 if (IN_type_symbol == NULL)
  1910                 if (IN_type_symbol == NULL)
  1834                   IN_type_symbol = last_type_symbol;
  1911                   IN_type_symbol = last_type_symbol;
  1835                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1912                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1836                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  1913                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  1837                 function_type_prefix = return_type_symbol;
  1914                 function_type_prefix = return_type_symbol;
       
  1915                 function_type_suffix = IN_type_symbol;
  1838                 break;
  1916                 break;
  1839                 
  1917                 
  1840             }
  1918             }
  1841             
  1919             
  1842             
  1920             
  1861             last_type_symbol = param_data_type;
  1939             last_type_symbol = param_data_type;
  1862             
  1940             
  1863             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1941             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1864             {
  1942             {
  1865         
  1943         
       
  1944                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1866                 
  1945                 
  1867                 if (IN_type_symbol == NULL)
  1946                 if (IN_type_symbol == NULL)
  1868                   IN_type_symbol = last_type_symbol;
  1947                   IN_type_symbol = last_type_symbol;
  1869                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1948                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1870                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  1949                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  1871                 function_type_prefix = return_type_symbol;
  1950                 function_type_prefix = return_type_symbol;
       
  1951                 function_type_suffix = IN_type_symbol;
  1872                 break;
  1952                 break;
  1873                 
  1953                 
  1874             }
  1954             }
  1875             
  1955             
  1876             
  1956             
  1895             last_type_symbol = param_data_type;
  1975             last_type_symbol = param_data_type;
  1896             
  1976             
  1897             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1977             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1898             {
  1978             {
  1899         
  1979         
       
  1980                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1900                 
  1981                 
  1901                 if (IN_type_symbol == NULL)
  1982                 if (IN_type_symbol == NULL)
  1902                   IN_type_symbol = last_type_symbol;
  1983                   IN_type_symbol = last_type_symbol;
  1903                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1984                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1904                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  1985                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  1905                 function_type_prefix = return_type_symbol;
  1986                 function_type_prefix = return_type_symbol;
       
  1987                 function_type_suffix = IN_type_symbol;
  1906                 break;
  1988                 break;
  1907                 
  1989                 
  1908             }
  1990             }
  1909             
  1991             
  1910             
  1992             
  1964             last_type_symbol = param_data_type;
  2046             last_type_symbol = param_data_type;
  1965             
  2047             
  1966             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  2048             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
  1967             {
  2049             {
  1968         
  2050         
       
  2051                 function_name = (symbol_c*)(new pragma_c("__move_"));
  1969                 
  2052                 
  1970                 if (IN_type_symbol == NULL)
  2053                 if (IN_type_symbol == NULL)
  1971                   IN_type_symbol = last_type_symbol;
  2054                   IN_type_symbol = last_type_symbol;
  1972                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2055                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  1973                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  2056                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  1974                 function_type_prefix = return_type_symbol;
  2057                 function_type_prefix = return_type_symbol;
       
  2058                 function_type_suffix = IN_type_symbol;
  1975                 break;
  2059                 break;
  1976                 
  2060                 
  1977             }
  2061             }
  1978             
  2062             
  1979             
  2063             
  1998             last_type_symbol = param_data_type;
  2082             last_type_symbol = param_data_type;
  1999             
  2083             
  2000             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2084             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2001             {
  2085             {
  2002         
  2086         
       
  2087                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2003                 
  2088                 
  2004                 if (IN_type_symbol == NULL)
  2089                 if (IN_type_symbol == NULL)
  2005                   IN_type_symbol = last_type_symbol;
  2090                   IN_type_symbol = last_type_symbol;
  2006                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2091                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2007                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  2092                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  2008                 function_type_prefix = return_type_symbol;
  2093                 function_type_prefix = return_type_symbol;
       
  2094                 function_type_suffix = IN_type_symbol;
  2009                 break;
  2095                 break;
  2010                 
  2096                 
  2011             }
  2097             }
  2012             
  2098             
  2013             
  2099             
  2032             last_type_symbol = param_data_type;
  2118             last_type_symbol = param_data_type;
  2033             
  2119             
  2034             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2120             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2035             {
  2121             {
  2036         
  2122         
       
  2123                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2037                 
  2124                 
  2038                 if (IN_type_symbol == NULL)
  2125                 if (IN_type_symbol == NULL)
  2039                   IN_type_symbol = last_type_symbol;
  2126                   IN_type_symbol = last_type_symbol;
  2040                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2127                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2041                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  2128                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  2042                 function_type_prefix = return_type_symbol;
  2129                 function_type_prefix = return_type_symbol;
       
  2130                 function_type_suffix = IN_type_symbol;
  2043                 break;
  2131                 break;
  2044                 
  2132                 
  2045             }
  2133             }
  2046             
  2134             
  2047             
  2135             
  2066             last_type_symbol = param_data_type;
  2154             last_type_symbol = param_data_type;
  2067             
  2155             
  2068             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2156             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2069             {
  2157             {
  2070         
  2158         
       
  2159                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2071                 
  2160                 
  2072                 if (IN_type_symbol == NULL)
  2161                 if (IN_type_symbol == NULL)
  2073                   IN_type_symbol = last_type_symbol;
  2162                   IN_type_symbol = last_type_symbol;
  2074                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2163                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2075                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  2164                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  2076                 function_type_prefix = return_type_symbol;
  2165                 function_type_prefix = return_type_symbol;
       
  2166                 function_type_suffix = IN_type_symbol;
  2077                 break;
  2167                 break;
  2078                 
  2168                 
  2079             }
  2169             }
  2080             
  2170             
  2081             
  2171             
  2135             last_type_symbol = param_data_type;
  2225             last_type_symbol = param_data_type;
  2136             
  2226             
  2137             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2227             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2138             {
  2228             {
  2139         
  2229         
       
  2230                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2140                 
  2231                 
  2141                 if (IN_type_symbol == NULL)
  2232                 if (IN_type_symbol == NULL)
  2142                   IN_type_symbol = last_type_symbol;
  2233                   IN_type_symbol = last_type_symbol;
  2143                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2234                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2144                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  2235                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  2145                 function_type_prefix = return_type_symbol;
  2236                 function_type_prefix = return_type_symbol;
       
  2237                 function_type_suffix = IN_type_symbol;
  2146                 break;
  2238                 break;
  2147                 
  2239                 
  2148             }
  2240             }
  2149             
  2241             
  2150             
  2242             
  2239             last_type_symbol = param_data_type;
  2331             last_type_symbol = param_data_type;
  2240             
  2332             
  2241             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2333             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2242             {
  2334             {
  2243         
  2335         
       
  2336                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2244                 
  2337                 
  2245                 if (IN_type_symbol == NULL)
  2338                 if (IN_type_symbol == NULL)
  2246                   IN_type_symbol = last_type_symbol;
  2339                   IN_type_symbol = last_type_symbol;
  2247                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2340                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2248                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  2341                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  2249                 function_type_prefix = return_type_symbol;
  2342                 function_type_prefix = return_type_symbol;
       
  2343                 function_type_suffix = IN_type_symbol;
  2250                 break;
  2344                 break;
  2251                 
  2345                 
  2252             }
  2346             }
  2253             
  2347             
  2254             
  2348             
  2273             last_type_symbol = param_data_type;
  2367             last_type_symbol = param_data_type;
  2274             
  2368             
  2275             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2369             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2276             {
  2370             {
  2277         
  2371         
       
  2372                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2278                 
  2373                 
  2279                 if (IN_type_symbol == NULL)
  2374                 if (IN_type_symbol == NULL)
  2280                   IN_type_symbol = last_type_symbol;
  2375                   IN_type_symbol = last_type_symbol;
  2281                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2376                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2282                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  2377                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  2283                 function_type_prefix = return_type_symbol;
  2378                 function_type_prefix = return_type_symbol;
       
  2379                 function_type_suffix = IN_type_symbol;
  2284                 break;
  2380                 break;
  2285                 
  2381                 
  2286             }
  2382             }
  2287             
  2383             
  2288             
  2384             
  2342             last_type_symbol = param_data_type;
  2438             last_type_symbol = param_data_type;
  2343             
  2439             
  2344             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2440             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2345             {
  2441             {
  2346         
  2442         
       
  2443                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2347                 
  2444                 
  2348                 if (IN_type_symbol == NULL)
  2445                 if (IN_type_symbol == NULL)
  2349                   IN_type_symbol = last_type_symbol;
  2446                   IN_type_symbol = last_type_symbol;
  2350                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2447                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2351                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  2448                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  2352                 function_type_prefix = return_type_symbol;
  2449                 function_type_prefix = return_type_symbol;
       
  2450                 function_type_suffix = IN_type_symbol;
  2353                 break;
  2451                 break;
  2354                 
  2452                 
  2355             }
  2453             }
  2356             
  2454             
  2357             
  2455             
  2376             last_type_symbol = param_data_type;
  2474             last_type_symbol = param_data_type;
  2377             
  2475             
  2378             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2476             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2379             {
  2477             {
  2380         
  2478         
       
  2479                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2381                 
  2480                 
  2382                 if (IN_type_symbol == NULL)
  2481                 if (IN_type_symbol == NULL)
  2383                   IN_type_symbol = last_type_symbol;
  2482                   IN_type_symbol = last_type_symbol;
  2384                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2483                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2385                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  2484                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  2386                 function_type_prefix = return_type_symbol;
  2485                 function_type_prefix = return_type_symbol;
       
  2486                 function_type_suffix = IN_type_symbol;
  2387                 break;
  2487                 break;
  2388                 
  2488                 
  2389             }
  2489             }
  2390             
  2490             
  2391             
  2491             
  2410             last_type_symbol = param_data_type;
  2510             last_type_symbol = param_data_type;
  2411             
  2511             
  2412             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2512             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2413             {
  2513             {
  2414         
  2514         
       
  2515                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2415                 
  2516                 
  2416                 if (IN_type_symbol == NULL)
  2517                 if (IN_type_symbol == NULL)
  2417                   IN_type_symbol = last_type_symbol;
  2518                   IN_type_symbol = last_type_symbol;
  2418                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2519                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2419                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  2520                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  2420                 function_type_prefix = return_type_symbol;
  2521                 function_type_prefix = return_type_symbol;
       
  2522                 function_type_suffix = IN_type_symbol;
  2421                 break;
  2523                 break;
  2422                 
  2524                 
  2423             }
  2525             }
  2424             
  2526             
  2425             
  2527             
  2444             last_type_symbol = param_data_type;
  2546             last_type_symbol = param_data_type;
  2445             
  2547             
  2446             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2548             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2447             {
  2549             {
  2448         
  2550         
       
  2551                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2449                 
  2552                 
  2450                 if (IN_type_symbol == NULL)
  2553                 if (IN_type_symbol == NULL)
  2451                   IN_type_symbol = last_type_symbol;
  2554                   IN_type_symbol = last_type_symbol;
  2452                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2555                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2453                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  2556                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  2454                 function_type_prefix = return_type_symbol;
  2557                 function_type_prefix = return_type_symbol;
       
  2558                 function_type_suffix = IN_type_symbol;
  2455                 break;
  2559                 break;
  2456                 
  2560                 
  2457             }
  2561             }
  2458             
  2562             
  2459             
  2563             
  2478             last_type_symbol = param_data_type;
  2582             last_type_symbol = param_data_type;
  2479             
  2583             
  2480             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2584             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2481             {
  2585             {
  2482         
  2586         
       
  2587                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2483                 
  2588                 
  2484                 if (IN_type_symbol == NULL)
  2589                 if (IN_type_symbol == NULL)
  2485                   IN_type_symbol = last_type_symbol;
  2590                   IN_type_symbol = last_type_symbol;
  2486                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2591                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2487                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  2592                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  2488                 function_type_prefix = return_type_symbol;
  2593                 function_type_prefix = return_type_symbol;
       
  2594                 function_type_suffix = IN_type_symbol;
  2489                 break;
  2595                 break;
  2490                 
  2596                 
  2491             }
  2597             }
  2492             
  2598             
  2493             
  2599             
  2512             last_type_symbol = param_data_type;
  2618             last_type_symbol = param_data_type;
  2513             
  2619             
  2514             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2620             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2515             {
  2621             {
  2516         
  2622         
       
  2623                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2517                 
  2624                 
  2518                 if (IN_type_symbol == NULL)
  2625                 if (IN_type_symbol == NULL)
  2519                   IN_type_symbol = last_type_symbol;
  2626                   IN_type_symbol = last_type_symbol;
  2520                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2627                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2521                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  2628                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  2522                 function_type_prefix = return_type_symbol;
  2629                 function_type_prefix = return_type_symbol;
       
  2630                 function_type_suffix = IN_type_symbol;
  2523                 break;
  2631                 break;
  2524                 
  2632                 
  2525             }
  2633             }
  2526             
  2634             
  2527             
  2635             
  2546             last_type_symbol = param_data_type;
  2654             last_type_symbol = param_data_type;
  2547             
  2655             
  2548             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2656             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2549             {
  2657             {
  2550         
  2658         
       
  2659                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2551                 
  2660                 
  2552                 if (IN_type_symbol == NULL)
  2661                 if (IN_type_symbol == NULL)
  2553                   IN_type_symbol = last_type_symbol;
  2662                   IN_type_symbol = last_type_symbol;
  2554                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2663                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2555                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  2664                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  2556                 function_type_prefix = return_type_symbol;
  2665                 function_type_prefix = return_type_symbol;
       
  2666                 function_type_suffix = IN_type_symbol;
  2557                 break;
  2667                 break;
  2558                 
  2668                 
  2559             }
  2669             }
  2560             
  2670             
  2561             
  2671             
  2615             last_type_symbol = param_data_type;
  2725             last_type_symbol = param_data_type;
  2616             
  2726             
  2617             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2727             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
  2618             {
  2728             {
  2619         
  2729         
       
  2730                 function_name = (symbol_c*)(new pragma_c("__move_"));
  2620                 
  2731                 
  2621                 if (IN_type_symbol == NULL)
  2732                 if (IN_type_symbol == NULL)
  2622                   IN_type_symbol = last_type_symbol;
  2733                   IN_type_symbol = last_type_symbol;
  2623                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2734                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  2624                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  2735                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  2625                 function_type_prefix = return_type_symbol;
  2736                 function_type_prefix = return_type_symbol;
       
  2737                 function_type_suffix = IN_type_symbol;
  2626                 break;
  2738                 break;
  2627                 
  2739                 
  2628             }
  2740             }
  2629             
  2741             
  2630             
  2742             
  3174             last_type_symbol = param_data_type;
  3286             last_type_symbol = param_data_type;
  3175             
  3287             
  3176             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3288             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3177             {
  3289             {
  3178         
  3290         
       
  3291                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3179                 
  3292                 
  3180                 if (IN_type_symbol == NULL)
  3293                 if (IN_type_symbol == NULL)
  3181                   IN_type_symbol = last_type_symbol;
  3294                   IN_type_symbol = last_type_symbol;
  3182                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3295                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3183                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  3296                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  3184                 function_type_prefix = return_type_symbol;
  3297                 function_type_prefix = return_type_symbol;
       
  3298                 function_type_suffix = IN_type_symbol;
  3185                 break;
  3299                 break;
  3186                 
  3300                 
  3187             }
  3301             }
  3188             
  3302             
  3189             
  3303             
  3208             last_type_symbol = param_data_type;
  3322             last_type_symbol = param_data_type;
  3209             
  3323             
  3210             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3324             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3211             {
  3325             {
  3212         
  3326         
       
  3327                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3213                 
  3328                 
  3214                 if (IN_type_symbol == NULL)
  3329                 if (IN_type_symbol == NULL)
  3215                   IN_type_symbol = last_type_symbol;
  3330                   IN_type_symbol = last_type_symbol;
  3216                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3331                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3217                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  3332                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  3218                 function_type_prefix = return_type_symbol;
  3333                 function_type_prefix = return_type_symbol;
       
  3334                 function_type_suffix = IN_type_symbol;
  3219                 break;
  3335                 break;
  3220                 
  3336                 
  3221             }
  3337             }
  3222             
  3338             
  3223             
  3339             
  3242             last_type_symbol = param_data_type;
  3358             last_type_symbol = param_data_type;
  3243             
  3359             
  3244             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3360             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3245             {
  3361             {
  3246         
  3362         
       
  3363                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3247                 
  3364                 
  3248                 if (IN_type_symbol == NULL)
  3365                 if (IN_type_symbol == NULL)
  3249                   IN_type_symbol = last_type_symbol;
  3366                   IN_type_symbol = last_type_symbol;
  3250                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3367                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3251                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  3368                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  3252                 function_type_prefix = return_type_symbol;
  3369                 function_type_prefix = return_type_symbol;
       
  3370                 function_type_suffix = IN_type_symbol;
  3253                 break;
  3371                 break;
  3254                 
  3372                 
  3255             }
  3373             }
  3256             
  3374             
  3257             
  3375             
  3276             last_type_symbol = param_data_type;
  3394             last_type_symbol = param_data_type;
  3277             
  3395             
  3278             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3396             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3279             {
  3397             {
  3280         
  3398         
       
  3399                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3281                 
  3400                 
  3282                 if (IN_type_symbol == NULL)
  3401                 if (IN_type_symbol == NULL)
  3283                   IN_type_symbol = last_type_symbol;
  3402                   IN_type_symbol = last_type_symbol;
  3284                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3403                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3285                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  3404                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  3286                 function_type_prefix = return_type_symbol;
  3405                 function_type_prefix = return_type_symbol;
       
  3406                 function_type_suffix = IN_type_symbol;
  3287                 break;
  3407                 break;
  3288                 
  3408                 
  3289             }
  3409             }
  3290             
  3410             
  3291             
  3411             
  3415             last_type_symbol = param_data_type;
  3535             last_type_symbol = param_data_type;
  3416             
  3536             
  3417             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3537             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3418             {
  3538             {
  3419         
  3539         
       
  3540                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3420                 
  3541                 
  3421                 if (IN_type_symbol == NULL)
  3542                 if (IN_type_symbol == NULL)
  3422                   IN_type_symbol = last_type_symbol;
  3543                   IN_type_symbol = last_type_symbol;
  3423                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3544                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3424                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  3545                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  3425                 function_type_prefix = return_type_symbol;
  3546                 function_type_prefix = return_type_symbol;
       
  3547                 function_type_suffix = IN_type_symbol;
  3426                 break;
  3548                 break;
  3427                 
  3549                 
  3428             }
  3550             }
  3429             
  3551             
  3430             
  3552             
  3449             last_type_symbol = param_data_type;
  3571             last_type_symbol = param_data_type;
  3450             
  3572             
  3451             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3573             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3452             {
  3574             {
  3453         
  3575         
       
  3576                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3454                 
  3577                 
  3455                 if (IN_type_symbol == NULL)
  3578                 if (IN_type_symbol == NULL)
  3456                   IN_type_symbol = last_type_symbol;
  3579                   IN_type_symbol = last_type_symbol;
  3457                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3580                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3458                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  3581                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  3459                 function_type_prefix = return_type_symbol;
  3582                 function_type_prefix = return_type_symbol;
       
  3583                 function_type_suffix = IN_type_symbol;
  3460                 break;
  3584                 break;
  3461                 
  3585                 
  3462             }
  3586             }
  3463             
  3587             
  3464             
  3588             
  3518             last_type_symbol = param_data_type;
  3642             last_type_symbol = param_data_type;
  3519             
  3643             
  3520             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3644             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3521             {
  3645             {
  3522         
  3646         
       
  3647                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3523                 
  3648                 
  3524                 if (IN_type_symbol == NULL)
  3649                 if (IN_type_symbol == NULL)
  3525                   IN_type_symbol = last_type_symbol;
  3650                   IN_type_symbol = last_type_symbol;
  3526                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3651                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3527                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  3652                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  3528                 function_type_prefix = return_type_symbol;
  3653                 function_type_prefix = return_type_symbol;
       
  3654                 function_type_suffix = IN_type_symbol;
  3529                 break;
  3655                 break;
  3530                 
  3656                 
  3531             }
  3657             }
  3532             
  3658             
  3533             
  3659             
  3552             last_type_symbol = param_data_type;
  3678             last_type_symbol = param_data_type;
  3553             
  3679             
  3554             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3680             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3555             {
  3681             {
  3556         
  3682         
       
  3683                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3557                 
  3684                 
  3558                 if (IN_type_symbol == NULL)
  3685                 if (IN_type_symbol == NULL)
  3559                   IN_type_symbol = last_type_symbol;
  3686                   IN_type_symbol = last_type_symbol;
  3560                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3687                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3561                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  3688                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  3562                 function_type_prefix = return_type_symbol;
  3689                 function_type_prefix = return_type_symbol;
       
  3690                 function_type_suffix = IN_type_symbol;
  3563                 break;
  3691                 break;
  3564                 
  3692                 
  3565             }
  3693             }
  3566             
  3694             
  3567             
  3695             
  3586             last_type_symbol = param_data_type;
  3714             last_type_symbol = param_data_type;
  3587             
  3715             
  3588             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3716             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3589             {
  3717             {
  3590         
  3718         
       
  3719                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3591                 
  3720                 
  3592                 if (IN_type_symbol == NULL)
  3721                 if (IN_type_symbol == NULL)
  3593                   IN_type_symbol = last_type_symbol;
  3722                   IN_type_symbol = last_type_symbol;
  3594                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3723                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3595                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  3724                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  3596                 function_type_prefix = return_type_symbol;
  3725                 function_type_prefix = return_type_symbol;
       
  3726                 function_type_suffix = IN_type_symbol;
  3597                 break;
  3727                 break;
  3598                 
  3728                 
  3599             }
  3729             }
  3600             
  3730             
  3601             
  3731             
  3620             last_type_symbol = param_data_type;
  3750             last_type_symbol = param_data_type;
  3621             
  3751             
  3622             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3752             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3623             {
  3753             {
  3624         
  3754         
       
  3755                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3625                 
  3756                 
  3626                 if (IN_type_symbol == NULL)
  3757                 if (IN_type_symbol == NULL)
  3627                   IN_type_symbol = last_type_symbol;
  3758                   IN_type_symbol = last_type_symbol;
  3628                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3759                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3629                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  3760                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  3630                 function_type_prefix = return_type_symbol;
  3761                 function_type_prefix = return_type_symbol;
       
  3762                 function_type_suffix = IN_type_symbol;
  3631                 break;
  3763                 break;
  3632                 
  3764                 
  3633             }
  3765             }
  3634             
  3766             
  3635             
  3767             
  3654             last_type_symbol = param_data_type;
  3786             last_type_symbol = param_data_type;
  3655             
  3787             
  3656             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3788             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3657             {
  3789             {
  3658         
  3790         
       
  3791                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3659                 
  3792                 
  3660                 if (IN_type_symbol == NULL)
  3793                 if (IN_type_symbol == NULL)
  3661                   IN_type_symbol = last_type_symbol;
  3794                   IN_type_symbol = last_type_symbol;
  3662                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3795                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3663                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  3796                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  3664                 function_type_prefix = return_type_symbol;
  3797                 function_type_prefix = return_type_symbol;
       
  3798                 function_type_suffix = IN_type_symbol;
  3665                 break;
  3799                 break;
  3666                 
  3800                 
  3667             }
  3801             }
  3668             
  3802             
  3669             
  3803             
  3688             last_type_symbol = param_data_type;
  3822             last_type_symbol = param_data_type;
  3689             
  3823             
  3690             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3824             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3691             {
  3825             {
  3692         
  3826         
       
  3827                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3693                 
  3828                 
  3694                 if (IN_type_symbol == NULL)
  3829                 if (IN_type_symbol == NULL)
  3695                   IN_type_symbol = last_type_symbol;
  3830                   IN_type_symbol = last_type_symbol;
  3696                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3831                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3697                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  3832                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  3698                 function_type_prefix = return_type_symbol;
  3833                 function_type_prefix = return_type_symbol;
       
  3834                 function_type_suffix = IN_type_symbol;
  3699                 break;
  3835                 break;
  3700                 
  3836                 
  3701             }
  3837             }
  3702             
  3838             
  3703             
  3839             
  3722             last_type_symbol = param_data_type;
  3858             last_type_symbol = param_data_type;
  3723             
  3859             
  3724             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3860             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3725             {
  3861             {
  3726         
  3862         
       
  3863                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3727                 
  3864                 
  3728                 if (IN_type_symbol == NULL)
  3865                 if (IN_type_symbol == NULL)
  3729                   IN_type_symbol = last_type_symbol;
  3866                   IN_type_symbol = last_type_symbol;
  3730                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3867                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3731                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  3868                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  3732                 function_type_prefix = return_type_symbol;
  3869                 function_type_prefix = return_type_symbol;
       
  3870                 function_type_suffix = IN_type_symbol;
  3733                 break;
  3871                 break;
  3734                 
  3872                 
  3735             }
  3873             }
  3736             
  3874             
  3737             
  3875             
  3791             last_type_symbol = param_data_type;
  3929             last_type_symbol = param_data_type;
  3792             
  3930             
  3793             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3931             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
  3794             {
  3932             {
  3795         
  3933         
       
  3934                 function_name = (symbol_c*)(new pragma_c("__move_"));
  3796                 
  3935                 
  3797                 if (IN_type_symbol == NULL)
  3936                 if (IN_type_symbol == NULL)
  3798                   IN_type_symbol = last_type_symbol;
  3937                   IN_type_symbol = last_type_symbol;
  3799                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3938                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  3800                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  3939                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  3801                 function_type_prefix = return_type_symbol;
  3940                 function_type_prefix = return_type_symbol;
       
  3941                 function_type_suffix = IN_type_symbol;
  3802                 break;
  3942                 break;
  3803                 
  3943                 
  3804             }
  3944             }
  3805             
  3945             
  3806             
  3946             
  4875             last_type_symbol = param_data_type;
  5015             last_type_symbol = param_data_type;
  4876             
  5016             
  4877             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5017             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  4878             {
  5018             {
  4879         
  5019         
       
  5020                 function_name = (symbol_c*)(new pragma_c("__move_"));
  4880                 
  5021                 
  4881                 if (IN_type_symbol == NULL)
  5022                 if (IN_type_symbol == NULL)
  4882                   IN_type_symbol = last_type_symbol;
  5023                   IN_type_symbol = last_type_symbol;
  4883                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5024                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  4884                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  5025                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  4885                 function_type_prefix = return_type_symbol;
  5026                 function_type_prefix = return_type_symbol;
       
  5027                 function_type_suffix = IN_type_symbol;
  4886                 break;
  5028                 break;
  4887                 
  5029                 
  4888             }
  5030             }
  4889             
  5031             
  4890             
  5032             
  4909             last_type_symbol = param_data_type;
  5051             last_type_symbol = param_data_type;
  4910             
  5052             
  4911             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5053             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  4912             {
  5054             {
  4913         
  5055         
       
  5056                 function_name = (symbol_c*)(new pragma_c("__move_"));
  4914                 
  5057                 
  4915                 if (IN_type_symbol == NULL)
  5058                 if (IN_type_symbol == NULL)
  4916                   IN_type_symbol = last_type_symbol;
  5059                   IN_type_symbol = last_type_symbol;
  4917                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5060                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  4918                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  5061                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  4919                 function_type_prefix = return_type_symbol;
  5062                 function_type_prefix = return_type_symbol;
       
  5063                 function_type_suffix = IN_type_symbol;
  4920                 break;
  5064                 break;
  4921                 
  5065                 
  4922             }
  5066             }
  4923             
  5067             
  4924             
  5068             
  4943             last_type_symbol = param_data_type;
  5087             last_type_symbol = param_data_type;
  4944             
  5088             
  4945             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5089             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  4946             {
  5090             {
  4947         
  5091         
       
  5092                 function_name = (symbol_c*)(new pragma_c("__move_"));
  4948                 
  5093                 
  4949                 if (IN_type_symbol == NULL)
  5094                 if (IN_type_symbol == NULL)
  4950                   IN_type_symbol = last_type_symbol;
  5095                   IN_type_symbol = last_type_symbol;
  4951                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5096                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  4952                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  5097                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  4953                 function_type_prefix = return_type_symbol;
  5098                 function_type_prefix = return_type_symbol;
       
  5099                 function_type_suffix = IN_type_symbol;
  4954                 break;
  5100                 break;
  4955                 
  5101                 
  4956             }
  5102             }
  4957             
  5103             
  4958             
  5104             
  4977             last_type_symbol = param_data_type;
  5123             last_type_symbol = param_data_type;
  4978             
  5124             
  4979             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5125             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  4980             {
  5126             {
  4981         
  5127         
       
  5128                 function_name = (symbol_c*)(new pragma_c("__move_"));
  4982                 
  5129                 
  4983                 if (IN_type_symbol == NULL)
  5130                 if (IN_type_symbol == NULL)
  4984                   IN_type_symbol = last_type_symbol;
  5131                   IN_type_symbol = last_type_symbol;
  4985                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5132                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  4986                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  5133                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  4987                 function_type_prefix = return_type_symbol;
  5134                 function_type_prefix = return_type_symbol;
       
  5135                 function_type_suffix = IN_type_symbol;
  4988                 break;
  5136                 break;
  4989                 
  5137                 
  4990             }
  5138             }
  4991             
  5139             
  4992             
  5140             
  5046             last_type_symbol = param_data_type;
  5194             last_type_symbol = param_data_type;
  5047             
  5195             
  5048             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5196             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5049             {
  5197             {
  5050         
  5198         
       
  5199                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5051                 
  5200                 
  5052                 if (IN_type_symbol == NULL)
  5201                 if (IN_type_symbol == NULL)
  5053                   IN_type_symbol = last_type_symbol;
  5202                   IN_type_symbol = last_type_symbol;
  5054                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5203                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5055                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  5204                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  5056                 function_type_prefix = return_type_symbol;
  5205                 function_type_prefix = return_type_symbol;
       
  5206                 function_type_suffix = IN_type_symbol;
  5057                 break;
  5207                 break;
  5058                 
  5208                 
  5059             }
  5209             }
  5060             
  5210             
  5061             
  5211             
  5150             last_type_symbol = param_data_type;
  5300             last_type_symbol = param_data_type;
  5151             
  5301             
  5152             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5302             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5153             {
  5303             {
  5154         
  5304         
       
  5305                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5155                 
  5306                 
  5156                 if (IN_type_symbol == NULL)
  5307                 if (IN_type_symbol == NULL)
  5157                   IN_type_symbol = last_type_symbol;
  5308                   IN_type_symbol = last_type_symbol;
  5158                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5309                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5159                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  5310                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  5160                 function_type_prefix = return_type_symbol;
  5311                 function_type_prefix = return_type_symbol;
       
  5312                 function_type_suffix = IN_type_symbol;
  5161                 break;
  5313                 break;
  5162                 
  5314                 
  5163             }
  5315             }
  5164             
  5316             
  5165             
  5317             
  5219             last_type_symbol = param_data_type;
  5371             last_type_symbol = param_data_type;
  5220             
  5372             
  5221             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5373             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5222             {
  5374             {
  5223         
  5375         
       
  5376                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5224                 
  5377                 
  5225                 if (IN_type_symbol == NULL)
  5378                 if (IN_type_symbol == NULL)
  5226                   IN_type_symbol = last_type_symbol;
  5379                   IN_type_symbol = last_type_symbol;
  5227                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5380                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5228                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  5381                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  5229                 function_type_prefix = return_type_symbol;
  5382                 function_type_prefix = return_type_symbol;
       
  5383                 function_type_suffix = IN_type_symbol;
  5230                 break;
  5384                 break;
  5231                 
  5385                 
  5232             }
  5386             }
  5233             
  5387             
  5234             
  5388             
  5253             last_type_symbol = param_data_type;
  5407             last_type_symbol = param_data_type;
  5254             
  5408             
  5255             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5409             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5256             {
  5410             {
  5257         
  5411         
       
  5412                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5258                 
  5413                 
  5259                 if (IN_type_symbol == NULL)
  5414                 if (IN_type_symbol == NULL)
  5260                   IN_type_symbol = last_type_symbol;
  5415                   IN_type_symbol = last_type_symbol;
  5261                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5416                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5262                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  5417                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  5263                 function_type_prefix = return_type_symbol;
  5418                 function_type_prefix = return_type_symbol;
       
  5419                 function_type_suffix = IN_type_symbol;
  5264                 break;
  5420                 break;
  5265                 
  5421                 
  5266             }
  5422             }
  5267             
  5423             
  5268             
  5424             
  5287             last_type_symbol = param_data_type;
  5443             last_type_symbol = param_data_type;
  5288             
  5444             
  5289             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5445             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5290             {
  5446             {
  5291         
  5447         
       
  5448                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5292                 
  5449                 
  5293                 if (IN_type_symbol == NULL)
  5450                 if (IN_type_symbol == NULL)
  5294                   IN_type_symbol = last_type_symbol;
  5451                   IN_type_symbol = last_type_symbol;
  5295                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5452                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5296                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  5453                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  5297                 function_type_prefix = return_type_symbol;
  5454                 function_type_prefix = return_type_symbol;
       
  5455                 function_type_suffix = IN_type_symbol;
  5298                 break;
  5456                 break;
  5299                 
  5457                 
  5300             }
  5458             }
  5301             
  5459             
  5302             
  5460             
  5321             last_type_symbol = param_data_type;
  5479             last_type_symbol = param_data_type;
  5322             
  5480             
  5323             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5481             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5324             {
  5482             {
  5325         
  5483         
       
  5484                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5326                 
  5485                 
  5327                 if (IN_type_symbol == NULL)
  5486                 if (IN_type_symbol == NULL)
  5328                   IN_type_symbol = last_type_symbol;
  5487                   IN_type_symbol = last_type_symbol;
  5329                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5488                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5330                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  5489                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  5331                 function_type_prefix = return_type_symbol;
  5490                 function_type_prefix = return_type_symbol;
       
  5491                 function_type_suffix = IN_type_symbol;
  5332                 break;
  5492                 break;
  5333                 
  5493                 
  5334             }
  5494             }
  5335             
  5495             
  5336             
  5496             
  5355             last_type_symbol = param_data_type;
  5515             last_type_symbol = param_data_type;
  5356             
  5516             
  5357             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5517             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5358             {
  5518             {
  5359         
  5519         
       
  5520                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5360                 
  5521                 
  5361                 if (IN_type_symbol == NULL)
  5522                 if (IN_type_symbol == NULL)
  5362                   IN_type_symbol = last_type_symbol;
  5523                   IN_type_symbol = last_type_symbol;
  5363                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5524                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5364                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  5525                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  5365                 function_type_prefix = return_type_symbol;
  5526                 function_type_prefix = return_type_symbol;
       
  5527                 function_type_suffix = IN_type_symbol;
  5366                 break;
  5528                 break;
  5367                 
  5529                 
  5368             }
  5530             }
  5369             
  5531             
  5370             
  5532             
  5389             last_type_symbol = param_data_type;
  5551             last_type_symbol = param_data_type;
  5390             
  5552             
  5391             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5553             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5392             {
  5554             {
  5393         
  5555         
       
  5556                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5394                 
  5557                 
  5395                 if (IN_type_symbol == NULL)
  5558                 if (IN_type_symbol == NULL)
  5396                   IN_type_symbol = last_type_symbol;
  5559                   IN_type_symbol = last_type_symbol;
  5397                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5560                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5398                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  5561                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  5399                 function_type_prefix = return_type_symbol;
  5562                 function_type_prefix = return_type_symbol;
       
  5563                 function_type_suffix = IN_type_symbol;
  5400                 break;
  5564                 break;
  5401                 
  5565                 
  5402             }
  5566             }
  5403             
  5567             
  5404             
  5568             
  5423             last_type_symbol = param_data_type;
  5587             last_type_symbol = param_data_type;
  5424             
  5588             
  5425             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5589             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5426             {
  5590             {
  5427         
  5591         
       
  5592                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5428                 
  5593                 
  5429                 if (IN_type_symbol == NULL)
  5594                 if (IN_type_symbol == NULL)
  5430                   IN_type_symbol = last_type_symbol;
  5595                   IN_type_symbol = last_type_symbol;
  5431                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5596                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5432                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  5597                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  5433                 function_type_prefix = return_type_symbol;
  5598                 function_type_prefix = return_type_symbol;
       
  5599                 function_type_suffix = IN_type_symbol;
  5434                 break;
  5600                 break;
  5435                 
  5601                 
  5436             }
  5602             }
  5437             
  5603             
  5438             
  5604             
  5492             last_type_symbol = param_data_type;
  5658             last_type_symbol = param_data_type;
  5493             
  5659             
  5494             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5660             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
  5495             {
  5661             {
  5496         
  5662         
       
  5663                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5497                 
  5664                 
  5498                 if (IN_type_symbol == NULL)
  5665                 if (IN_type_symbol == NULL)
  5499                   IN_type_symbol = last_type_symbol;
  5666                   IN_type_symbol = last_type_symbol;
  5500                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5667                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5501                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  5668                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  5502                 function_type_prefix = return_type_symbol;
  5669                 function_type_prefix = return_type_symbol;
       
  5670                 function_type_suffix = IN_type_symbol;
  5503                 break;
  5671                 break;
  5504                 
  5672                 
  5505             }
  5673             }
  5506             
  5674             
  5507             
  5675             
  5526             last_type_symbol = param_data_type;
  5694             last_type_symbol = param_data_type;
  5527             
  5695             
  5528             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5696             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5529             {
  5697             {
  5530         
  5698         
       
  5699                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5531                 
  5700                 
  5532                 if (IN_type_symbol == NULL)
  5701                 if (IN_type_symbol == NULL)
  5533                   IN_type_symbol = last_type_symbol;
  5702                   IN_type_symbol = last_type_symbol;
  5534                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5703                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5535                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  5704                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  5536                 function_type_prefix = return_type_symbol;
  5705                 function_type_prefix = return_type_symbol;
       
  5706                 function_type_suffix = IN_type_symbol;
  5537                 break;
  5707                 break;
  5538                 
  5708                 
  5539             }
  5709             }
  5540             
  5710             
  5541             
  5711             
  5560             last_type_symbol = param_data_type;
  5730             last_type_symbol = param_data_type;
  5561             
  5731             
  5562             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5732             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5563             {
  5733             {
  5564         
  5734         
       
  5735                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5565                 
  5736                 
  5566                 if (IN_type_symbol == NULL)
  5737                 if (IN_type_symbol == NULL)
  5567                   IN_type_symbol = last_type_symbol;
  5738                   IN_type_symbol = last_type_symbol;
  5568                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5739                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5569                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  5740                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  5570                 function_type_prefix = return_type_symbol;
  5741                 function_type_prefix = return_type_symbol;
       
  5742                 function_type_suffix = IN_type_symbol;
  5571                 break;
  5743                 break;
  5572                 
  5744                 
  5573             }
  5745             }
  5574             
  5746             
  5575             
  5747             
  5594             last_type_symbol = param_data_type;
  5766             last_type_symbol = param_data_type;
  5595             
  5767             
  5596             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5768             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5597             {
  5769             {
  5598         
  5770         
       
  5771                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5599                 
  5772                 
  5600                 if (IN_type_symbol == NULL)
  5773                 if (IN_type_symbol == NULL)
  5601                   IN_type_symbol = last_type_symbol;
  5774                   IN_type_symbol = last_type_symbol;
  5602                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5775                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5603                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  5776                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  5604                 function_type_prefix = return_type_symbol;
  5777                 function_type_prefix = return_type_symbol;
       
  5778                 function_type_suffix = IN_type_symbol;
  5605                 break;
  5779                 break;
  5606                 
  5780                 
  5607             }
  5781             }
  5608             
  5782             
  5609             
  5783             
  5628             last_type_symbol = param_data_type;
  5802             last_type_symbol = param_data_type;
  5629             
  5803             
  5630             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5804             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5631             {
  5805             {
  5632         
  5806         
       
  5807                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5633                 
  5808                 
  5634                 if (IN_type_symbol == NULL)
  5809                 if (IN_type_symbol == NULL)
  5635                   IN_type_symbol = last_type_symbol;
  5810                   IN_type_symbol = last_type_symbol;
  5636                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5811                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5637                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  5812                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  5638                 function_type_prefix = return_type_symbol;
  5813                 function_type_prefix = return_type_symbol;
       
  5814                 function_type_suffix = IN_type_symbol;
  5639                 break;
  5815                 break;
  5640                 
  5816                 
  5641             }
  5817             }
  5642             
  5818             
  5643             
  5819             
  5697             last_type_symbol = param_data_type;
  5873             last_type_symbol = param_data_type;
  5698             
  5874             
  5699             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5875             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5700             {
  5876             {
  5701         
  5877         
       
  5878                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5702                 
  5879                 
  5703                 if (IN_type_symbol == NULL)
  5880                 if (IN_type_symbol == NULL)
  5704                   IN_type_symbol = last_type_symbol;
  5881                   IN_type_symbol = last_type_symbol;
  5705                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5882                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5706                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  5883                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  5707                 function_type_prefix = return_type_symbol;
  5884                 function_type_prefix = return_type_symbol;
       
  5885                 function_type_suffix = IN_type_symbol;
  5708                 break;
  5886                 break;
  5709                 
  5887                 
  5710             }
  5888             }
  5711             
  5889             
  5712             
  5890             
  5801             last_type_symbol = param_data_type;
  5979             last_type_symbol = param_data_type;
  5802             
  5980             
  5803             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5981             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5804             {
  5982             {
  5805         
  5983         
       
  5984                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5806                 
  5985                 
  5807                 if (IN_type_symbol == NULL)
  5986                 if (IN_type_symbol == NULL)
  5808                   IN_type_symbol = last_type_symbol;
  5987                   IN_type_symbol = last_type_symbol;
  5809                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5988                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5810                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  5989                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  5811                 function_type_prefix = return_type_symbol;
  5990                 function_type_prefix = return_type_symbol;
       
  5991                 function_type_suffix = IN_type_symbol;
  5812                 break;
  5992                 break;
  5813                 
  5993                 
  5814             }
  5994             }
  5815             
  5995             
  5816             
  5996             
  5870             last_type_symbol = param_data_type;
  6050             last_type_symbol = param_data_type;
  5871             
  6051             
  5872             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6052             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5873             {
  6053             {
  5874         
  6054         
       
  6055                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5875                 
  6056                 
  5876                 if (IN_type_symbol == NULL)
  6057                 if (IN_type_symbol == NULL)
  5877                   IN_type_symbol = last_type_symbol;
  6058                   IN_type_symbol = last_type_symbol;
  5878                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6059                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5879                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  6060                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  5880                 function_type_prefix = return_type_symbol;
  6061                 function_type_prefix = return_type_symbol;
       
  6062                 function_type_suffix = IN_type_symbol;
  5881                 break;
  6063                 break;
  5882                 
  6064                 
  5883             }
  6065             }
  5884             
  6066             
  5885             
  6067             
  5904             last_type_symbol = param_data_type;
  6086             last_type_symbol = param_data_type;
  5905             
  6087             
  5906             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6088             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5907             {
  6089             {
  5908         
  6090         
       
  6091                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5909                 
  6092                 
  5910                 if (IN_type_symbol == NULL)
  6093                 if (IN_type_symbol == NULL)
  5911                   IN_type_symbol = last_type_symbol;
  6094                   IN_type_symbol = last_type_symbol;
  5912                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6095                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5913                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  6096                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  5914                 function_type_prefix = return_type_symbol;
  6097                 function_type_prefix = return_type_symbol;
       
  6098                 function_type_suffix = IN_type_symbol;
  5915                 break;
  6099                 break;
  5916                 
  6100                 
  5917             }
  6101             }
  5918             
  6102             
  5919             
  6103             
  5938             last_type_symbol = param_data_type;
  6122             last_type_symbol = param_data_type;
  5939             
  6123             
  5940             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6124             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5941             {
  6125             {
  5942         
  6126         
       
  6127                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5943                 
  6128                 
  5944                 if (IN_type_symbol == NULL)
  6129                 if (IN_type_symbol == NULL)
  5945                   IN_type_symbol = last_type_symbol;
  6130                   IN_type_symbol = last_type_symbol;
  5946                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6131                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5947                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  6132                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  5948                 function_type_prefix = return_type_symbol;
  6133                 function_type_prefix = return_type_symbol;
       
  6134                 function_type_suffix = IN_type_symbol;
  5949                 break;
  6135                 break;
  5950                 
  6136                 
  5951             }
  6137             }
  5952             
  6138             
  5953             
  6139             
  5972             last_type_symbol = param_data_type;
  6158             last_type_symbol = param_data_type;
  5973             
  6159             
  5974             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6160             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  5975             {
  6161             {
  5976         
  6162         
       
  6163                 function_name = (symbol_c*)(new pragma_c("__move_"));
  5977                 
  6164                 
  5978                 if (IN_type_symbol == NULL)
  6165                 if (IN_type_symbol == NULL)
  5979                   IN_type_symbol = last_type_symbol;
  6166                   IN_type_symbol = last_type_symbol;
  5980                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6167                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  5981                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  6168                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  5982                 function_type_prefix = return_type_symbol;
  6169                 function_type_prefix = return_type_symbol;
       
  6170                 function_type_suffix = IN_type_symbol;
  5983                 break;
  6171                 break;
  5984                 
  6172                 
  5985             }
  6173             }
  5986             
  6174             
  5987             
  6175             
  6006             last_type_symbol = param_data_type;
  6194             last_type_symbol = param_data_type;
  6007             
  6195             
  6008             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6196             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6009             {
  6197             {
  6010         
  6198         
       
  6199                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6011                 
  6200                 
  6012                 if (IN_type_symbol == NULL)
  6201                 if (IN_type_symbol == NULL)
  6013                   IN_type_symbol = last_type_symbol;
  6202                   IN_type_symbol = last_type_symbol;
  6014                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6203                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6015                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  6204                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  6016                 function_type_prefix = return_type_symbol;
  6205                 function_type_prefix = return_type_symbol;
       
  6206                 function_type_suffix = IN_type_symbol;
  6017                 break;
  6207                 break;
  6018                 
  6208                 
  6019             }
  6209             }
  6020             
  6210             
  6021             
  6211             
  6040             last_type_symbol = param_data_type;
  6230             last_type_symbol = param_data_type;
  6041             
  6231             
  6042             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6232             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6043             {
  6233             {
  6044         
  6234         
       
  6235                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6045                 
  6236                 
  6046                 if (IN_type_symbol == NULL)
  6237                 if (IN_type_symbol == NULL)
  6047                   IN_type_symbol = last_type_symbol;
  6238                   IN_type_symbol = last_type_symbol;
  6048                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6239                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6049                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  6240                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  6050                 function_type_prefix = return_type_symbol;
  6241                 function_type_prefix = return_type_symbol;
       
  6242                 function_type_suffix = IN_type_symbol;
  6051                 break;
  6243                 break;
  6052                 
  6244                 
  6053             }
  6245             }
  6054             
  6246             
  6055             
  6247             
  6074             last_type_symbol = param_data_type;
  6266             last_type_symbol = param_data_type;
  6075             
  6267             
  6076             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6268             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6077             {
  6269             {
  6078         
  6270         
       
  6271                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6079                 
  6272                 
  6080                 if (IN_type_symbol == NULL)
  6273                 if (IN_type_symbol == NULL)
  6081                   IN_type_symbol = last_type_symbol;
  6274                   IN_type_symbol = last_type_symbol;
  6082                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6275                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6083                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  6276                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  6084                 function_type_prefix = return_type_symbol;
  6277                 function_type_prefix = return_type_symbol;
       
  6278                 function_type_suffix = IN_type_symbol;
  6085                 break;
  6279                 break;
  6086                 
  6280                 
  6087             }
  6281             }
  6088             
  6282             
  6089             
  6283             
  6143             last_type_symbol = param_data_type;
  6337             last_type_symbol = param_data_type;
  6144             
  6338             
  6145             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6339             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol))
  6146             {
  6340             {
  6147         
  6341         
       
  6342                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6148                 
  6343                 
  6149                 if (IN_type_symbol == NULL)
  6344                 if (IN_type_symbol == NULL)
  6150                   IN_type_symbol = last_type_symbol;
  6345                   IN_type_symbol = last_type_symbol;
  6151                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6346                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6152                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  6347                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  6153                 function_type_prefix = return_type_symbol;
  6348                 function_type_prefix = return_type_symbol;
       
  6349                 function_type_suffix = IN_type_symbol;
  6154                 break;
  6350                 break;
  6155                 
  6351                 
  6156             }
  6352             }
  6157             
  6353             
  6158             
  6354             
  6842             last_type_symbol = param_data_type;
  7038             last_type_symbol = param_data_type;
  6843             
  7039             
  6844             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7040             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  6845             {
  7041             {
  6846         
  7042         
       
  7043                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6847                 
  7044                 
  6848                 if (IN_type_symbol == NULL)
  7045                 if (IN_type_symbol == NULL)
  6849                   IN_type_symbol = last_type_symbol;
  7046                   IN_type_symbol = last_type_symbol;
  6850                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7047                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6851                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  7048                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  6852                 function_type_prefix = return_type_symbol;
  7049                 function_type_prefix = return_type_symbol;
       
  7050                 function_type_suffix = IN_type_symbol;
  6853                 break;
  7051                 break;
  6854                 
  7052                 
  6855             }
  7053             }
  6856             
  7054             
  6857             
  7055             
  6876             last_type_symbol = param_data_type;
  7074             last_type_symbol = param_data_type;
  6877             
  7075             
  6878             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7076             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  6879             {
  7077             {
  6880         
  7078         
       
  7079                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6881                 
  7080                 
  6882                 if (IN_type_symbol == NULL)
  7081                 if (IN_type_symbol == NULL)
  6883                   IN_type_symbol = last_type_symbol;
  7082                   IN_type_symbol = last_type_symbol;
  6884                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7083                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6885                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  7084                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  6886                 function_type_prefix = return_type_symbol;
  7085                 function_type_prefix = return_type_symbol;
       
  7086                 function_type_suffix = IN_type_symbol;
  6887                 break;
  7087                 break;
  6888                 
  7088                 
  6889             }
  7089             }
  6890             
  7090             
  6891             
  7091             
  6910             last_type_symbol = param_data_type;
  7110             last_type_symbol = param_data_type;
  6911             
  7111             
  6912             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7112             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  6913             {
  7113             {
  6914         
  7114         
       
  7115                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6915                 
  7116                 
  6916                 if (IN_type_symbol == NULL)
  7117                 if (IN_type_symbol == NULL)
  6917                   IN_type_symbol = last_type_symbol;
  7118                   IN_type_symbol = last_type_symbol;
  6918                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7119                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6919                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  7120                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  6920                 function_type_prefix = return_type_symbol;
  7121                 function_type_prefix = return_type_symbol;
       
  7122                 function_type_suffix = IN_type_symbol;
  6921                 break;
  7123                 break;
  6922                 
  7124                 
  6923             }
  7125             }
  6924             
  7126             
  6925             
  7127             
  6944             last_type_symbol = param_data_type;
  7146             last_type_symbol = param_data_type;
  6945             
  7147             
  6946             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7148             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  6947             {
  7149             {
  6948         
  7150         
       
  7151                 function_name = (symbol_c*)(new pragma_c("__move_"));
  6949                 
  7152                 
  6950                 if (IN_type_symbol == NULL)
  7153                 if (IN_type_symbol == NULL)
  6951                   IN_type_symbol = last_type_symbol;
  7154                   IN_type_symbol = last_type_symbol;
  6952                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7155                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  6953                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  7156                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  6954                 function_type_prefix = return_type_symbol;
  7157                 function_type_prefix = return_type_symbol;
       
  7158                 function_type_suffix = IN_type_symbol;
  6955                 break;
  7159                 break;
  6956                 
  7160                 
  6957             }
  7161             }
  6958             
  7162             
  6959             
  7163             
  7013             last_type_symbol = param_data_type;
  7217             last_type_symbol = param_data_type;
  7014             
  7218             
  7015             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7219             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7016             {
  7220             {
  7017         
  7221         
       
  7222                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7018                 
  7223                 
  7019                 if (IN_type_symbol == NULL)
  7224                 if (IN_type_symbol == NULL)
  7020                   IN_type_symbol = last_type_symbol;
  7225                   IN_type_symbol = last_type_symbol;
  7021                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7226                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7022                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  7227                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  7023                 function_type_prefix = return_type_symbol;
  7228                 function_type_prefix = return_type_symbol;
       
  7229                 function_type_suffix = IN_type_symbol;
  7024                 break;
  7230                 break;
  7025                 
  7231                 
  7026             }
  7232             }
  7027             
  7233             
  7028             
  7234             
  7117             last_type_symbol = param_data_type;
  7323             last_type_symbol = param_data_type;
  7118             
  7324             
  7119             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7325             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7120             {
  7326             {
  7121         
  7327         
       
  7328                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7122                 
  7329                 
  7123                 if (IN_type_symbol == NULL)
  7330                 if (IN_type_symbol == NULL)
  7124                   IN_type_symbol = last_type_symbol;
  7331                   IN_type_symbol = last_type_symbol;
  7125                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7332                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7126                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  7333                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  7127                 function_type_prefix = return_type_symbol;
  7334                 function_type_prefix = return_type_symbol;
       
  7335                 function_type_suffix = IN_type_symbol;
  7128                 break;
  7336                 break;
  7129                 
  7337                 
  7130             }
  7338             }
  7131             
  7339             
  7132             
  7340             
  7151             last_type_symbol = param_data_type;
  7359             last_type_symbol = param_data_type;
  7152             
  7360             
  7153             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7361             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7154             {
  7362             {
  7155         
  7363         
       
  7364                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7156                 
  7365                 
  7157                 if (IN_type_symbol == NULL)
  7366                 if (IN_type_symbol == NULL)
  7158                   IN_type_symbol = last_type_symbol;
  7367                   IN_type_symbol = last_type_symbol;
  7159                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7368                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7160                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  7369                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  7161                 function_type_prefix = return_type_symbol;
  7370                 function_type_prefix = return_type_symbol;
       
  7371                 function_type_suffix = IN_type_symbol;
  7162                 break;
  7372                 break;
  7163                 
  7373                 
  7164             }
  7374             }
  7165             
  7375             
  7166             
  7376             
  7220             last_type_symbol = param_data_type;
  7430             last_type_symbol = param_data_type;
  7221             
  7431             
  7222             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7432             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7223             {
  7433             {
  7224         
  7434         
       
  7435                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7225                 
  7436                 
  7226                 if (IN_type_symbol == NULL)
  7437                 if (IN_type_symbol == NULL)
  7227                   IN_type_symbol = last_type_symbol;
  7438                   IN_type_symbol = last_type_symbol;
  7228                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7439                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7229                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  7440                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  7230                 function_type_prefix = return_type_symbol;
  7441                 function_type_prefix = return_type_symbol;
       
  7442                 function_type_suffix = IN_type_symbol;
  7231                 break;
  7443                 break;
  7232                 
  7444                 
  7233             }
  7445             }
  7234             
  7446             
  7235             
  7447             
  7254             last_type_symbol = param_data_type;
  7466             last_type_symbol = param_data_type;
  7255             
  7467             
  7256             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7468             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7257             {
  7469             {
  7258         
  7470         
       
  7471                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7259                 
  7472                 
  7260                 if (IN_type_symbol == NULL)
  7473                 if (IN_type_symbol == NULL)
  7261                   IN_type_symbol = last_type_symbol;
  7474                   IN_type_symbol = last_type_symbol;
  7262                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7475                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7263                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  7476                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  7264                 function_type_prefix = return_type_symbol;
  7477                 function_type_prefix = return_type_symbol;
       
  7478                 function_type_suffix = IN_type_symbol;
  7265                 break;
  7479                 break;
  7266                 
  7480                 
  7267             }
  7481             }
  7268             
  7482             
  7269             
  7483             
  7288             last_type_symbol = param_data_type;
  7502             last_type_symbol = param_data_type;
  7289             
  7503             
  7290             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7504             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7291             {
  7505             {
  7292         
  7506         
       
  7507                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7293                 
  7508                 
  7294                 if (IN_type_symbol == NULL)
  7509                 if (IN_type_symbol == NULL)
  7295                   IN_type_symbol = last_type_symbol;
  7510                   IN_type_symbol = last_type_symbol;
  7296                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7511                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7297                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  7512                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  7298                 function_type_prefix = return_type_symbol;
  7513                 function_type_prefix = return_type_symbol;
       
  7514                 function_type_suffix = IN_type_symbol;
  7299                 break;
  7515                 break;
  7300                 
  7516                 
  7301             }
  7517             }
  7302             
  7518             
  7303             
  7519             
  7322             last_type_symbol = param_data_type;
  7538             last_type_symbol = param_data_type;
  7323             
  7539             
  7324             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7540             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7325             {
  7541             {
  7326         
  7542         
       
  7543                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7327                 
  7544                 
  7328                 if (IN_type_symbol == NULL)
  7545                 if (IN_type_symbol == NULL)
  7329                   IN_type_symbol = last_type_symbol;
  7546                   IN_type_symbol = last_type_symbol;
  7330                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7547                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7331                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  7548                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  7332                 function_type_prefix = return_type_symbol;
  7549                 function_type_prefix = return_type_symbol;
       
  7550                 function_type_suffix = IN_type_symbol;
  7333                 break;
  7551                 break;
  7334                 
  7552                 
  7335             }
  7553             }
  7336             
  7554             
  7337             
  7555             
  7356             last_type_symbol = param_data_type;
  7574             last_type_symbol = param_data_type;
  7357             
  7575             
  7358             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7576             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7359             {
  7577             {
  7360         
  7578         
       
  7579                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7361                 
  7580                 
  7362                 if (IN_type_symbol == NULL)
  7581                 if (IN_type_symbol == NULL)
  7363                   IN_type_symbol = last_type_symbol;
  7582                   IN_type_symbol = last_type_symbol;
  7364                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7583                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7365                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  7584                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  7366                 function_type_prefix = return_type_symbol;
  7585                 function_type_prefix = return_type_symbol;
       
  7586                 function_type_suffix = IN_type_symbol;
  7367                 break;
  7587                 break;
  7368                 
  7588                 
  7369             }
  7589             }
  7370             
  7590             
  7371             
  7591             
  7390             last_type_symbol = param_data_type;
  7610             last_type_symbol = param_data_type;
  7391             
  7611             
  7392             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7612             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7393             {
  7613             {
  7394         
  7614         
       
  7615                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7395                 
  7616                 
  7396                 if (IN_type_symbol == NULL)
  7617                 if (IN_type_symbol == NULL)
  7397                   IN_type_symbol = last_type_symbol;
  7618                   IN_type_symbol = last_type_symbol;
  7398                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7619                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7399                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  7620                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  7400                 function_type_prefix = return_type_symbol;
  7621                 function_type_prefix = return_type_symbol;
       
  7622                 function_type_suffix = IN_type_symbol;
  7401                 break;
  7623                 break;
  7402                 
  7624                 
  7403             }
  7625             }
  7404             
  7626             
  7405             
  7627             
  7459             last_type_symbol = param_data_type;
  7681             last_type_symbol = param_data_type;
  7460             
  7682             
  7461             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7683             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol))
  7462             {
  7684             {
  7463         
  7685         
       
  7686                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7464                 
  7687                 
  7465                 if (IN_type_symbol == NULL)
  7688                 if (IN_type_symbol == NULL)
  7466                   IN_type_symbol = last_type_symbol;
  7689                   IN_type_symbol = last_type_symbol;
  7467                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7690                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7468                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  7691                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  7469                 function_type_prefix = return_type_symbol;
  7692                 function_type_prefix = return_type_symbol;
       
  7693                 function_type_suffix = IN_type_symbol;
  7470                 break;
  7694                 break;
  7471                 
  7695                 
  7472             }
  7696             }
  7473             
  7697             
  7474             
  7698             
  7493             last_type_symbol = param_data_type;
  7717             last_type_symbol = param_data_type;
  7494             
  7718             
  7495             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7719             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7496             {
  7720             {
  7497         
  7721         
       
  7722                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7498                 
  7723                 
  7499                 if (IN_type_symbol == NULL)
  7724                 if (IN_type_symbol == NULL)
  7500                   IN_type_symbol = last_type_symbol;
  7725                   IN_type_symbol = last_type_symbol;
  7501                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7726                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7502                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  7727                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  7503                 function_type_prefix = return_type_symbol;
  7728                 function_type_prefix = return_type_symbol;
       
  7729                 function_type_suffix = IN_type_symbol;
  7504                 break;
  7730                 break;
  7505                 
  7731                 
  7506             }
  7732             }
  7507             
  7733             
  7508             
  7734             
  7527             last_type_symbol = param_data_type;
  7753             last_type_symbol = param_data_type;
  7528             
  7754             
  7529             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7755             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7530             {
  7756             {
  7531         
  7757         
       
  7758                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7532                 
  7759                 
  7533                 if (IN_type_symbol == NULL)
  7760                 if (IN_type_symbol == NULL)
  7534                   IN_type_symbol = last_type_symbol;
  7761                   IN_type_symbol = last_type_symbol;
  7535                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7762                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7536                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  7763                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  7537                 function_type_prefix = return_type_symbol;
  7764                 function_type_prefix = return_type_symbol;
       
  7765                 function_type_suffix = IN_type_symbol;
  7538                 break;
  7766                 break;
  7539                 
  7767                 
  7540             }
  7768             }
  7541             
  7769             
  7542             
  7770             
  7561             last_type_symbol = param_data_type;
  7789             last_type_symbol = param_data_type;
  7562             
  7790             
  7563             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7791             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7564             {
  7792             {
  7565         
  7793         
       
  7794                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7566                 
  7795                 
  7567                 if (IN_type_symbol == NULL)
  7796                 if (IN_type_symbol == NULL)
  7568                   IN_type_symbol = last_type_symbol;
  7797                   IN_type_symbol = last_type_symbol;
  7569                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7798                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7570                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  7799                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  7571                 function_type_prefix = return_type_symbol;
  7800                 function_type_prefix = return_type_symbol;
       
  7801                 function_type_suffix = IN_type_symbol;
  7572                 break;
  7802                 break;
  7573                 
  7803                 
  7574             }
  7804             }
  7575             
  7805             
  7576             
  7806             
  7595             last_type_symbol = param_data_type;
  7825             last_type_symbol = param_data_type;
  7596             
  7826             
  7597             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7827             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7598             {
  7828             {
  7599         
  7829         
       
  7830                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7600                 
  7831                 
  7601                 if (IN_type_symbol == NULL)
  7832                 if (IN_type_symbol == NULL)
  7602                   IN_type_symbol = last_type_symbol;
  7833                   IN_type_symbol = last_type_symbol;
  7603                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7834                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7604                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  7835                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  7605                 function_type_prefix = return_type_symbol;
  7836                 function_type_prefix = return_type_symbol;
       
  7837                 function_type_suffix = IN_type_symbol;
  7606                 break;
  7838                 break;
  7607                 
  7839                 
  7608             }
  7840             }
  7609             
  7841             
  7610             
  7842             
  7664             last_type_symbol = param_data_type;
  7896             last_type_symbol = param_data_type;
  7665             
  7897             
  7666             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7898             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7667             {
  7899             {
  7668         
  7900         
       
  7901                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7669                 
  7902                 
  7670                 if (IN_type_symbol == NULL)
  7903                 if (IN_type_symbol == NULL)
  7671                   IN_type_symbol = last_type_symbol;
  7904                   IN_type_symbol = last_type_symbol;
  7672                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7905                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7673                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  7906                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  7674                 function_type_prefix = return_type_symbol;
  7907                 function_type_prefix = return_type_symbol;
       
  7908                 function_type_suffix = IN_type_symbol;
  7675                 break;
  7909                 break;
  7676                 
  7910                 
  7677             }
  7911             }
  7678             
  7912             
  7679             
  7913             
  7768             last_type_symbol = param_data_type;
  8002             last_type_symbol = param_data_type;
  7769             
  8003             
  7770             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8004             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7771             {
  8005             {
  7772         
  8006         
       
  8007                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7773                 
  8008                 
  7774                 if (IN_type_symbol == NULL)
  8009                 if (IN_type_symbol == NULL)
  7775                   IN_type_symbol = last_type_symbol;
  8010                   IN_type_symbol = last_type_symbol;
  7776                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8011                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7777                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  8012                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  7778                 function_type_prefix = return_type_symbol;
  8013                 function_type_prefix = return_type_symbol;
       
  8014                 function_type_suffix = IN_type_symbol;
  7779                 break;
  8015                 break;
  7780                 
  8016                 
  7781             }
  8017             }
  7782             
  8018             
  7783             
  8019             
  7802             last_type_symbol = param_data_type;
  8038             last_type_symbol = param_data_type;
  7803             
  8039             
  7804             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8040             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7805             {
  8041             {
  7806         
  8042         
       
  8043                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7807                 
  8044                 
  7808                 if (IN_type_symbol == NULL)
  8045                 if (IN_type_symbol == NULL)
  7809                   IN_type_symbol = last_type_symbol;
  8046                   IN_type_symbol = last_type_symbol;
  7810                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8047                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7811                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  8048                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  7812                 function_type_prefix = return_type_symbol;
  8049                 function_type_prefix = return_type_symbol;
       
  8050                 function_type_suffix = IN_type_symbol;
  7813                 break;
  8051                 break;
  7814                 
  8052                 
  7815             }
  8053             }
  7816             
  8054             
  7817             
  8055             
  7871             last_type_symbol = param_data_type;
  8109             last_type_symbol = param_data_type;
  7872             
  8110             
  7873             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8111             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7874             {
  8112             {
  7875         
  8113         
       
  8114                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7876                 
  8115                 
  7877                 if (IN_type_symbol == NULL)
  8116                 if (IN_type_symbol == NULL)
  7878                   IN_type_symbol = last_type_symbol;
  8117                   IN_type_symbol = last_type_symbol;
  7879                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8118                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7880                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  8119                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  7881                 function_type_prefix = return_type_symbol;
  8120                 function_type_prefix = return_type_symbol;
       
  8121                 function_type_suffix = IN_type_symbol;
  7882                 break;
  8122                 break;
  7883                 
  8123                 
  7884             }
  8124             }
  7885             
  8125             
  7886             
  8126             
  7905             last_type_symbol = param_data_type;
  8145             last_type_symbol = param_data_type;
  7906             
  8146             
  7907             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8147             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7908             {
  8148             {
  7909         
  8149         
       
  8150                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7910                 
  8151                 
  7911                 if (IN_type_symbol == NULL)
  8152                 if (IN_type_symbol == NULL)
  7912                   IN_type_symbol = last_type_symbol;
  8153                   IN_type_symbol = last_type_symbol;
  7913                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8154                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7914                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  8155                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  7915                 function_type_prefix = return_type_symbol;
  8156                 function_type_prefix = return_type_symbol;
       
  8157                 function_type_suffix = IN_type_symbol;
  7916                 break;
  8158                 break;
  7917                 
  8159                 
  7918             }
  8160             }
  7919             
  8161             
  7920             
  8162             
  7939             last_type_symbol = param_data_type;
  8181             last_type_symbol = param_data_type;
  7940             
  8182             
  7941             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8183             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7942             {
  8184             {
  7943         
  8185         
       
  8186                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7944                 
  8187                 
  7945                 if (IN_type_symbol == NULL)
  8188                 if (IN_type_symbol == NULL)
  7946                   IN_type_symbol = last_type_symbol;
  8189                   IN_type_symbol = last_type_symbol;
  7947                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8190                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7948                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  8191                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  7949                 function_type_prefix = return_type_symbol;
  8192                 function_type_prefix = return_type_symbol;
       
  8193                 function_type_suffix = IN_type_symbol;
  7950                 break;
  8194                 break;
  7951                 
  8195                 
  7952             }
  8196             }
  7953             
  8197             
  7954             
  8198             
  7973             last_type_symbol = param_data_type;
  8217             last_type_symbol = param_data_type;
  7974             
  8218             
  7975             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8219             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  7976             {
  8220             {
  7977         
  8221         
       
  8222                 function_name = (symbol_c*)(new pragma_c("__move_"));
  7978                 
  8223                 
  7979                 if (IN_type_symbol == NULL)
  8224                 if (IN_type_symbol == NULL)
  7980                   IN_type_symbol = last_type_symbol;
  8225                   IN_type_symbol = last_type_symbol;
  7981                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8226                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  7982                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  8227                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  7983                 function_type_prefix = return_type_symbol;
  8228                 function_type_prefix = return_type_symbol;
       
  8229                 function_type_suffix = IN_type_symbol;
  7984                 break;
  8230                 break;
  7985                 
  8231                 
  7986             }
  8232             }
  7987             
  8233             
  7988             
  8234             
  8007             last_type_symbol = param_data_type;
  8253             last_type_symbol = param_data_type;
  8008             
  8254             
  8009             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8255             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8010             {
  8256             {
  8011         
  8257         
       
  8258                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8012                 
  8259                 
  8013                 if (IN_type_symbol == NULL)
  8260                 if (IN_type_symbol == NULL)
  8014                   IN_type_symbol = last_type_symbol;
  8261                   IN_type_symbol = last_type_symbol;
  8015                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8262                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8016                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  8263                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  8017                 function_type_prefix = return_type_symbol;
  8264                 function_type_prefix = return_type_symbol;
       
  8265                 function_type_suffix = IN_type_symbol;
  8018                 break;
  8266                 break;
  8019                 
  8267                 
  8020             }
  8268             }
  8021             
  8269             
  8022             
  8270             
  8041             last_type_symbol = param_data_type;
  8289             last_type_symbol = param_data_type;
  8042             
  8290             
  8043             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8291             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8044             {
  8292             {
  8045         
  8293         
       
  8294                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8046                 
  8295                 
  8047                 if (IN_type_symbol == NULL)
  8296                 if (IN_type_symbol == NULL)
  8048                   IN_type_symbol = last_type_symbol;
  8297                   IN_type_symbol = last_type_symbol;
  8049                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8298                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8050                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  8299                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  8051                 function_type_prefix = return_type_symbol;
  8300                 function_type_prefix = return_type_symbol;
       
  8301                 function_type_suffix = IN_type_symbol;
  8052                 break;
  8302                 break;
  8053                 
  8303                 
  8054             }
  8304             }
  8055             
  8305             
  8056             
  8306             
  8110             last_type_symbol = param_data_type;
  8360             last_type_symbol = param_data_type;
  8111             
  8361             
  8112             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8362             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol))
  8113             {
  8363             {
  8114         
  8364         
       
  8365                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8115                 
  8366                 
  8116                 if (IN_type_symbol == NULL)
  8367                 if (IN_type_symbol == NULL)
  8117                   IN_type_symbol = last_type_symbol;
  8368                   IN_type_symbol = last_type_symbol;
  8118                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8369                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8119                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  8370                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  8120                 function_type_prefix = return_type_symbol;
  8371                 function_type_prefix = return_type_symbol;
       
  8372                 function_type_suffix = IN_type_symbol;
  8121                 break;
  8373                 break;
  8122                 
  8374                 
  8123             }
  8375             }
  8124             
  8376             
  8125             
  8377             
  8144             last_type_symbol = param_data_type;
  8396             last_type_symbol = param_data_type;
  8145             
  8397             
  8146             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8398             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8147             {
  8399             {
  8148         
  8400         
       
  8401                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8149                 
  8402                 
  8150                 if (IN_type_symbol == NULL)
  8403                 if (IN_type_symbol == NULL)
  8151                   IN_type_symbol = last_type_symbol;
  8404                   IN_type_symbol = last_type_symbol;
  8152                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8405                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8153                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  8406                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  8154                 function_type_prefix = return_type_symbol;
  8407                 function_type_prefix = return_type_symbol;
       
  8408                 function_type_suffix = IN_type_symbol;
  8155                 break;
  8409                 break;
  8156                 
  8410                 
  8157             }
  8411             }
  8158             
  8412             
  8159             
  8413             
  8178             last_type_symbol = param_data_type;
  8432             last_type_symbol = param_data_type;
  8179             
  8433             
  8180             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8434             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8181             {
  8435             {
  8182         
  8436         
       
  8437                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8183                 
  8438                 
  8184                 if (IN_type_symbol == NULL)
  8439                 if (IN_type_symbol == NULL)
  8185                   IN_type_symbol = last_type_symbol;
  8440                   IN_type_symbol = last_type_symbol;
  8186                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8441                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8187                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  8442                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  8188                 function_type_prefix = return_type_symbol;
  8443                 function_type_prefix = return_type_symbol;
       
  8444                 function_type_suffix = IN_type_symbol;
  8189                 break;
  8445                 break;
  8190                 
  8446                 
  8191             }
  8447             }
  8192             
  8448             
  8193             
  8449             
  8212             last_type_symbol = param_data_type;
  8468             last_type_symbol = param_data_type;
  8213             
  8469             
  8214             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8470             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8215             {
  8471             {
  8216         
  8472         
       
  8473                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8217                 
  8474                 
  8218                 if (IN_type_symbol == NULL)
  8475                 if (IN_type_symbol == NULL)
  8219                   IN_type_symbol = last_type_symbol;
  8476                   IN_type_symbol = last_type_symbol;
  8220                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8477                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8221                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  8478                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  8222                 function_type_prefix = return_type_symbol;
  8479                 function_type_prefix = return_type_symbol;
       
  8480                 function_type_suffix = IN_type_symbol;
  8223                 break;
  8481                 break;
  8224                 
  8482                 
  8225             }
  8483             }
  8226             
  8484             
  8227             
  8485             
  8246             last_type_symbol = param_data_type;
  8504             last_type_symbol = param_data_type;
  8247             
  8505             
  8248             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8506             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8249             {
  8507             {
  8250         
  8508         
       
  8509                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8251                 
  8510                 
  8252                 if (IN_type_symbol == NULL)
  8511                 if (IN_type_symbol == NULL)
  8253                   IN_type_symbol = last_type_symbol;
  8512                   IN_type_symbol = last_type_symbol;
  8254                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8513                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8255                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  8514                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  8256                 function_type_prefix = return_type_symbol;
  8515                 function_type_prefix = return_type_symbol;
       
  8516                 function_type_suffix = IN_type_symbol;
  8257                 break;
  8517                 break;
  8258                 
  8518                 
  8259             }
  8519             }
  8260             
  8520             
  8261             
  8521             
  8315             last_type_symbol = param_data_type;
  8575             last_type_symbol = param_data_type;
  8316             
  8576             
  8317             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8577             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8318             {
  8578             {
  8319         
  8579         
       
  8580                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8320                 
  8581                 
  8321                 if (IN_type_symbol == NULL)
  8582                 if (IN_type_symbol == NULL)
  8322                   IN_type_symbol = last_type_symbol;
  8583                   IN_type_symbol = last_type_symbol;
  8323                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8584                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8324                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  8585                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  8325                 function_type_prefix = return_type_symbol;
  8586                 function_type_prefix = return_type_symbol;
       
  8587                 function_type_suffix = IN_type_symbol;
  8326                 break;
  8588                 break;
  8327                 
  8589                 
  8328             }
  8590             }
  8329             
  8591             
  8330             
  8592             
  8419             last_type_symbol = param_data_type;
  8681             last_type_symbol = param_data_type;
  8420             
  8682             
  8421             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8683             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8422             {
  8684             {
  8423         
  8685         
       
  8686                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8424                 
  8687                 
  8425                 if (IN_type_symbol == NULL)
  8688                 if (IN_type_symbol == NULL)
  8426                   IN_type_symbol = last_type_symbol;
  8689                   IN_type_symbol = last_type_symbol;
  8427                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8690                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8428                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  8691                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  8429                 function_type_prefix = return_type_symbol;
  8692                 function_type_prefix = return_type_symbol;
       
  8693                 function_type_suffix = IN_type_symbol;
  8430                 break;
  8694                 break;
  8431                 
  8695                 
  8432             }
  8696             }
  8433             
  8697             
  8434             
  8698             
  8453             last_type_symbol = param_data_type;
  8717             last_type_symbol = param_data_type;
  8454             
  8718             
  8455             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8719             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8456             {
  8720             {
  8457         
  8721         
       
  8722                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8458                 
  8723                 
  8459                 if (IN_type_symbol == NULL)
  8724                 if (IN_type_symbol == NULL)
  8460                   IN_type_symbol = last_type_symbol;
  8725                   IN_type_symbol = last_type_symbol;
  8461                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8726                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8462                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  8727                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  8463                 function_type_prefix = return_type_symbol;
  8728                 function_type_prefix = return_type_symbol;
       
  8729                 function_type_suffix = IN_type_symbol;
  8464                 break;
  8730                 break;
  8465                 
  8731                 
  8466             }
  8732             }
  8467             
  8733             
  8468             
  8734             
  8522             last_type_symbol = param_data_type;
  8788             last_type_symbol = param_data_type;
  8523             
  8789             
  8524             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8790             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8525             {
  8791             {
  8526         
  8792         
       
  8793                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8527                 
  8794                 
  8528                 if (IN_type_symbol == NULL)
  8795                 if (IN_type_symbol == NULL)
  8529                   IN_type_symbol = last_type_symbol;
  8796                   IN_type_symbol = last_type_symbol;
  8530                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8797                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8531                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  8798                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  8532                 function_type_prefix = return_type_symbol;
  8799                 function_type_prefix = return_type_symbol;
       
  8800                 function_type_suffix = IN_type_symbol;
  8533                 break;
  8801                 break;
  8534                 
  8802                 
  8535             }
  8803             }
  8536             
  8804             
  8537             
  8805             
  8556             last_type_symbol = param_data_type;
  8824             last_type_symbol = param_data_type;
  8557             
  8825             
  8558             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8826             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8559             {
  8827             {
  8560         
  8828         
       
  8829                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8561                 
  8830                 
  8562                 if (IN_type_symbol == NULL)
  8831                 if (IN_type_symbol == NULL)
  8563                   IN_type_symbol = last_type_symbol;
  8832                   IN_type_symbol = last_type_symbol;
  8564                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8833                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8565                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  8834                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  8566                 function_type_prefix = return_type_symbol;
  8835                 function_type_prefix = return_type_symbol;
       
  8836                 function_type_suffix = IN_type_symbol;
  8567                 break;
  8837                 break;
  8568                 
  8838                 
  8569             }
  8839             }
  8570             
  8840             
  8571             
  8841             
  8590             last_type_symbol = param_data_type;
  8860             last_type_symbol = param_data_type;
  8591             
  8861             
  8592             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8862             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8593             {
  8863             {
  8594         
  8864         
       
  8865                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8595                 
  8866                 
  8596                 if (IN_type_symbol == NULL)
  8867                 if (IN_type_symbol == NULL)
  8597                   IN_type_symbol = last_type_symbol;
  8868                   IN_type_symbol = last_type_symbol;
  8598                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8869                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8599                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  8870                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  8600                 function_type_prefix = return_type_symbol;
  8871                 function_type_prefix = return_type_symbol;
       
  8872                 function_type_suffix = IN_type_symbol;
  8601                 break;
  8873                 break;
  8602                 
  8874                 
  8603             }
  8875             }
  8604             
  8876             
  8605             
  8877             
  8624             last_type_symbol = param_data_type;
  8896             last_type_symbol = param_data_type;
  8625             
  8897             
  8626             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8898             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8627             {
  8899             {
  8628         
  8900         
       
  8901                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8629                 
  8902                 
  8630                 if (IN_type_symbol == NULL)
  8903                 if (IN_type_symbol == NULL)
  8631                   IN_type_symbol = last_type_symbol;
  8904                   IN_type_symbol = last_type_symbol;
  8632                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8905                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8633                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  8906                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  8634                 function_type_prefix = return_type_symbol;
  8907                 function_type_prefix = return_type_symbol;
       
  8908                 function_type_suffix = IN_type_symbol;
  8635                 break;
  8909                 break;
  8636                 
  8910                 
  8637             }
  8911             }
  8638             
  8912             
  8639             
  8913             
  8658             last_type_symbol = param_data_type;
  8932             last_type_symbol = param_data_type;
  8659             
  8933             
  8660             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8934             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8661             {
  8935             {
  8662         
  8936         
       
  8937                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8663                 
  8938                 
  8664                 if (IN_type_symbol == NULL)
  8939                 if (IN_type_symbol == NULL)
  8665                   IN_type_symbol = last_type_symbol;
  8940                   IN_type_symbol = last_type_symbol;
  8666                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8941                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8667                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  8942                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  8668                 function_type_prefix = return_type_symbol;
  8943                 function_type_prefix = return_type_symbol;
       
  8944                 function_type_suffix = IN_type_symbol;
  8669                 break;
  8945                 break;
  8670                 
  8946                 
  8671             }
  8947             }
  8672             
  8948             
  8673             
  8949             
  8692             last_type_symbol = param_data_type;
  8968             last_type_symbol = param_data_type;
  8693             
  8969             
  8694             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8970             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8695             {
  8971             {
  8696         
  8972         
       
  8973                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8697                 
  8974                 
  8698                 if (IN_type_symbol == NULL)
  8975                 if (IN_type_symbol == NULL)
  8699                   IN_type_symbol = last_type_symbol;
  8976                   IN_type_symbol = last_type_symbol;
  8700                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8977                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8701                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  8978                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  8702                 function_type_prefix = return_type_symbol;
  8979                 function_type_prefix = return_type_symbol;
       
  8980                 function_type_suffix = IN_type_symbol;
  8703                 break;
  8981                 break;
  8704                 
  8982                 
  8705             }
  8983             }
  8706             
  8984             
  8707             
  8985             
  8761             last_type_symbol = param_data_type;
  9039             last_type_symbol = param_data_type;
  8762             
  9040             
  8763             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  9041             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol))
  8764             {
  9042             {
  8765         
  9043         
       
  9044                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8766                 
  9045                 
  8767                 if (IN_type_symbol == NULL)
  9046                 if (IN_type_symbol == NULL)
  8768                   IN_type_symbol = last_type_symbol;
  9047                   IN_type_symbol = last_type_symbol;
  8769                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9048                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8770                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  9049                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  8771                 function_type_prefix = return_type_symbol;
  9050                 function_type_prefix = return_type_symbol;
       
  9051                 function_type_suffix = IN_type_symbol;
  8772                 break;
  9052                 break;
  8773                 
  9053                 
  8774             }
  9054             }
  8775             
  9055             
  8776             
  9056             
  8795             last_type_symbol = param_data_type;
  9075             last_type_symbol = param_data_type;
  8796             
  9076             
  8797             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9077             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  8798             {
  9078             {
  8799         
  9079         
       
  9080                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8800                 
  9081                 
  8801                 if (IN_type_symbol == NULL)
  9082                 if (IN_type_symbol == NULL)
  8802                   IN_type_symbol = last_type_symbol;
  9083                   IN_type_symbol = last_type_symbol;
  8803                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9084                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8804                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  9085                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  8805                 function_type_prefix = return_type_symbol;
  9086                 function_type_prefix = return_type_symbol;
       
  9087                 function_type_suffix = IN_type_symbol;
  8806                 break;
  9088                 break;
  8807                 
  9089                 
  8808             }
  9090             }
  8809             
  9091             
  8810             
  9092             
  8829             last_type_symbol = param_data_type;
  9111             last_type_symbol = param_data_type;
  8830             
  9112             
  8831             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9113             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  8832             {
  9114             {
  8833         
  9115         
       
  9116                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8834                 
  9117                 
  8835                 if (IN_type_symbol == NULL)
  9118                 if (IN_type_symbol == NULL)
  8836                   IN_type_symbol = last_type_symbol;
  9119                   IN_type_symbol = last_type_symbol;
  8837                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9120                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8838                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  9121                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  8839                 function_type_prefix = return_type_symbol;
  9122                 function_type_prefix = return_type_symbol;
       
  9123                 function_type_suffix = IN_type_symbol;
  8840                 break;
  9124                 break;
  8841                 
  9125                 
  8842             }
  9126             }
  8843             
  9127             
  8844             
  9128             
  8863             last_type_symbol = param_data_type;
  9147             last_type_symbol = param_data_type;
  8864             
  9148             
  8865             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9149             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  8866             {
  9150             {
  8867         
  9151         
       
  9152                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8868                 
  9153                 
  8869                 if (IN_type_symbol == NULL)
  9154                 if (IN_type_symbol == NULL)
  8870                   IN_type_symbol = last_type_symbol;
  9155                   IN_type_symbol = last_type_symbol;
  8871                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9156                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8872                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  9157                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  8873                 function_type_prefix = return_type_symbol;
  9158                 function_type_prefix = return_type_symbol;
       
  9159                 function_type_suffix = IN_type_symbol;
  8874                 break;
  9160                 break;
  8875                 
  9161                 
  8876             }
  9162             }
  8877             
  9163             
  8878             
  9164             
  8897             last_type_symbol = param_data_type;
  9183             last_type_symbol = param_data_type;
  8898             
  9184             
  8899             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9185             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  8900             {
  9186             {
  8901         
  9187         
       
  9188                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8902                 
  9189                 
  8903                 if (IN_type_symbol == NULL)
  9190                 if (IN_type_symbol == NULL)
  8904                   IN_type_symbol = last_type_symbol;
  9191                   IN_type_symbol = last_type_symbol;
  8905                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9192                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8906                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  9193                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  8907                 function_type_prefix = return_type_symbol;
  9194                 function_type_prefix = return_type_symbol;
       
  9195                 function_type_suffix = IN_type_symbol;
  8908                 break;
  9196                 break;
  8909                 
  9197                 
  8910             }
  9198             }
  8911             
  9199             
  8912             
  9200             
  8966             last_type_symbol = param_data_type;
  9254             last_type_symbol = param_data_type;
  8967             
  9255             
  8968             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9256             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  8969             {
  9257             {
  8970         
  9258         
       
  9259                 function_name = (symbol_c*)(new pragma_c("__move_"));
  8971                 
  9260                 
  8972                 if (IN_type_symbol == NULL)
  9261                 if (IN_type_symbol == NULL)
  8973                   IN_type_symbol = last_type_symbol;
  9262                   IN_type_symbol = last_type_symbol;
  8974                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9263                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  8975                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  9264                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  8976                 function_type_prefix = return_type_symbol;
  9265                 function_type_prefix = return_type_symbol;
       
  9266                 function_type_suffix = IN_type_symbol;
  8977                 break;
  9267                 break;
  8978                 
  9268                 
  8979             }
  9269             }
  8980             
  9270             
  8981             
  9271             
  9070             last_type_symbol = param_data_type;
  9360             last_type_symbol = param_data_type;
  9071             
  9361             
  9072             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9362             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9073             {
  9363             {
  9074         
  9364         
       
  9365                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9075                 
  9366                 
  9076                 if (IN_type_symbol == NULL)
  9367                 if (IN_type_symbol == NULL)
  9077                   IN_type_symbol = last_type_symbol;
  9368                   IN_type_symbol = last_type_symbol;
  9078                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9369                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9079                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  9370                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  9080                 function_type_prefix = return_type_symbol;
  9371                 function_type_prefix = return_type_symbol;
       
  9372                 function_type_suffix = IN_type_symbol;
  9081                 break;
  9373                 break;
  9082                 
  9374                 
  9083             }
  9375             }
  9084             
  9376             
  9085             
  9377             
  9104             last_type_symbol = param_data_type;
  9396             last_type_symbol = param_data_type;
  9105             
  9397             
  9106             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9398             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9107             {
  9399             {
  9108         
  9400         
       
  9401                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9109                 
  9402                 
  9110                 if (IN_type_symbol == NULL)
  9403                 if (IN_type_symbol == NULL)
  9111                   IN_type_symbol = last_type_symbol;
  9404                   IN_type_symbol = last_type_symbol;
  9112                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9405                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9113                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  9406                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  9114                 function_type_prefix = return_type_symbol;
  9407                 function_type_prefix = return_type_symbol;
       
  9408                 function_type_suffix = IN_type_symbol;
  9115                 break;
  9409                 break;
  9116                 
  9410                 
  9117             }
  9411             }
  9118             
  9412             
  9119             
  9413             
  9173             last_type_symbol = param_data_type;
  9467             last_type_symbol = param_data_type;
  9174             
  9468             
  9175             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9469             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9176             {
  9470             {
  9177         
  9471         
       
  9472                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9178                 
  9473                 
  9179                 if (IN_type_symbol == NULL)
  9474                 if (IN_type_symbol == NULL)
  9180                   IN_type_symbol = last_type_symbol;
  9475                   IN_type_symbol = last_type_symbol;
  9181                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9476                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9182                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  9477                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  9183                 function_type_prefix = return_type_symbol;
  9478                 function_type_prefix = return_type_symbol;
       
  9479                 function_type_suffix = IN_type_symbol;
  9184                 break;
  9480                 break;
  9185                 
  9481                 
  9186             }
  9482             }
  9187             
  9483             
  9188             
  9484             
  9207             last_type_symbol = param_data_type;
  9503             last_type_symbol = param_data_type;
  9208             
  9504             
  9209             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9505             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9210             {
  9506             {
  9211         
  9507         
       
  9508                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9212                 
  9509                 
  9213                 if (IN_type_symbol == NULL)
  9510                 if (IN_type_symbol == NULL)
  9214                   IN_type_symbol = last_type_symbol;
  9511                   IN_type_symbol = last_type_symbol;
  9215                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9512                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9216                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  9513                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  9217                 function_type_prefix = return_type_symbol;
  9514                 function_type_prefix = return_type_symbol;
       
  9515                 function_type_suffix = IN_type_symbol;
  9218                 break;
  9516                 break;
  9219                 
  9517                 
  9220             }
  9518             }
  9221             
  9519             
  9222             
  9520             
  9241             last_type_symbol = param_data_type;
  9539             last_type_symbol = param_data_type;
  9242             
  9540             
  9243             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9541             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9244             {
  9542             {
  9245         
  9543         
       
  9544                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9246                 
  9545                 
  9247                 if (IN_type_symbol == NULL)
  9546                 if (IN_type_symbol == NULL)
  9248                   IN_type_symbol = last_type_symbol;
  9547                   IN_type_symbol = last_type_symbol;
  9249                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9548                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9250                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  9549                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  9251                 function_type_prefix = return_type_symbol;
  9550                 function_type_prefix = return_type_symbol;
       
  9551                 function_type_suffix = IN_type_symbol;
  9252                 break;
  9552                 break;
  9253                 
  9553                 
  9254             }
  9554             }
  9255             
  9555             
  9256             
  9556             
  9275             last_type_symbol = param_data_type;
  9575             last_type_symbol = param_data_type;
  9276             
  9576             
  9277             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9577             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9278             {
  9578             {
  9279         
  9579         
       
  9580                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9280                 
  9581                 
  9281                 if (IN_type_symbol == NULL)
  9582                 if (IN_type_symbol == NULL)
  9282                   IN_type_symbol = last_type_symbol;
  9583                   IN_type_symbol = last_type_symbol;
  9283                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9584                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9284                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  9585                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
  9285                 function_type_prefix = return_type_symbol;
  9586                 function_type_prefix = return_type_symbol;
       
  9587                 function_type_suffix = IN_type_symbol;
  9286                 break;
  9588                 break;
  9287                 
  9589                 
  9288             }
  9590             }
  9289             
  9591             
  9290             
  9592             
  9309             last_type_symbol = param_data_type;
  9611             last_type_symbol = param_data_type;
  9310             
  9612             
  9311             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9613             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9312             {
  9614             {
  9313         
  9615         
       
  9616                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9314                 
  9617                 
  9315                 if (IN_type_symbol == NULL)
  9618                 if (IN_type_symbol == NULL)
  9316                   IN_type_symbol = last_type_symbol;
  9619                   IN_type_symbol = last_type_symbol;
  9317                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9620                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9318                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  9621                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  9319                 function_type_prefix = return_type_symbol;
  9622                 function_type_prefix = return_type_symbol;
       
  9623                 function_type_suffix = IN_type_symbol;
  9320                 break;
  9624                 break;
  9321                 
  9625                 
  9322             }
  9626             }
  9323             
  9627             
  9324             
  9628             
  9343             last_type_symbol = param_data_type;
  9647             last_type_symbol = param_data_type;
  9344             
  9648             
  9345             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9649             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9346             {
  9650             {
  9347         
  9651         
       
  9652                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9348                 
  9653                 
  9349                 if (IN_type_symbol == NULL)
  9654                 if (IN_type_symbol == NULL)
  9350                   IN_type_symbol = last_type_symbol;
  9655                   IN_type_symbol = last_type_symbol;
  9351                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9656                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9352                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  9657                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
  9353                 function_type_prefix = return_type_symbol;
  9658                 function_type_prefix = return_type_symbol;
       
  9659                 function_type_suffix = IN_type_symbol;
  9354                 break;
  9660                 break;
  9355                 
  9661                 
  9356             }
  9662             }
  9357             
  9663             
  9358             
  9664             
  9412             last_type_symbol = param_data_type;
  9718             last_type_symbol = param_data_type;
  9413             
  9719             
  9414             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9720             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol))
  9415             {
  9721             {
  9416         
  9722         
       
  9723                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9417                 
  9724                 
  9418                 if (IN_type_symbol == NULL)
  9725                 if (IN_type_symbol == NULL)
  9419                   IN_type_symbol = last_type_symbol;
  9726                   IN_type_symbol = last_type_symbol;
  9420                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9727                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9421                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  9728                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
  9422                 function_type_prefix = return_type_symbol;
  9729                 function_type_prefix = return_type_symbol;
       
  9730                 function_type_suffix = IN_type_symbol;
  9423                 break;
  9731                 break;
  9424                 
  9732                 
  9425             }
  9733             }
  9426             
  9734             
  9427             
  9735             
  9446             last_type_symbol = param_data_type;
  9754             last_type_symbol = param_data_type;
  9447             
  9755             
  9448             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9756             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9449             {
  9757             {
  9450         
  9758         
       
  9759                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9451                 
  9760                 
  9452                 if (IN_type_symbol == NULL)
  9761                 if (IN_type_symbol == NULL)
  9453                   IN_type_symbol = last_type_symbol;
  9762                   IN_type_symbol = last_type_symbol;
  9454                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9763                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9455                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  9764                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
  9456                 function_type_prefix = return_type_symbol;
  9765                 function_type_prefix = return_type_symbol;
       
  9766                 function_type_suffix = IN_type_symbol;
  9457                 break;
  9767                 break;
  9458                 
  9768                 
  9459             }
  9769             }
  9460             
  9770             
  9461             
  9771             
  9480             last_type_symbol = param_data_type;
  9790             last_type_symbol = param_data_type;
  9481             
  9791             
  9482             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9792             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9483             {
  9793             {
  9484         
  9794         
       
  9795                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9485                 
  9796                 
  9486                 if (IN_type_symbol == NULL)
  9797                 if (IN_type_symbol == NULL)
  9487                   IN_type_symbol = last_type_symbol;
  9798                   IN_type_symbol = last_type_symbol;
  9488                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9799                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9489                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  9800                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
  9490                 function_type_prefix = return_type_symbol;
  9801                 function_type_prefix = return_type_symbol;
       
  9802                 function_type_suffix = IN_type_symbol;
  9491                 break;
  9803                 break;
  9492                 
  9804                 
  9493             }
  9805             }
  9494             
  9806             
  9495             
  9807             
  9514             last_type_symbol = param_data_type;
  9826             last_type_symbol = param_data_type;
  9515             
  9827             
  9516             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9828             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9517             {
  9829             {
  9518         
  9830         
       
  9831                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9519                 
  9832                 
  9520                 if (IN_type_symbol == NULL)
  9833                 if (IN_type_symbol == NULL)
  9521                   IN_type_symbol = last_type_symbol;
  9834                   IN_type_symbol = last_type_symbol;
  9522                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9835                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9523                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  9836                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
  9524                 function_type_prefix = return_type_symbol;
  9837                 function_type_prefix = return_type_symbol;
       
  9838                 function_type_suffix = IN_type_symbol;
  9525                 break;
  9839                 break;
  9526                 
  9840                 
  9527             }
  9841             }
  9528             
  9842             
  9529             
  9843             
  9548             last_type_symbol = param_data_type;
  9862             last_type_symbol = param_data_type;
  9549             
  9863             
  9550             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9864             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9551             {
  9865             {
  9552         
  9866         
       
  9867                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9553                 
  9868                 
  9554                 if (IN_type_symbol == NULL)
  9869                 if (IN_type_symbol == NULL)
  9555                   IN_type_symbol = last_type_symbol;
  9870                   IN_type_symbol = last_type_symbol;
  9556                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9871                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9557                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  9872                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
  9558                 function_type_prefix = return_type_symbol;
  9873                 function_type_prefix = return_type_symbol;
       
  9874                 function_type_suffix = IN_type_symbol;
  9559                 break;
  9875                 break;
  9560                 
  9876                 
  9561             }
  9877             }
  9562             
  9878             
  9563             
  9879             
  9617             last_type_symbol = param_data_type;
  9933             last_type_symbol = param_data_type;
  9618             
  9934             
  9619             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9935             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9620             {
  9936             {
  9621         
  9937         
       
  9938                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9622                 
  9939                 
  9623                 if (IN_type_symbol == NULL)
  9940                 if (IN_type_symbol == NULL)
  9624                   IN_type_symbol = last_type_symbol;
  9941                   IN_type_symbol = last_type_symbol;
  9625                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9942                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9626                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  9943                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
  9627                 function_type_prefix = return_type_symbol;
  9944                 function_type_prefix = return_type_symbol;
       
  9945                 function_type_suffix = IN_type_symbol;
  9628                 break;
  9946                 break;
  9629                 
  9947                 
  9630             }
  9948             }
  9631             
  9949             
  9632             
  9950             
  9721             last_type_symbol = param_data_type;
 10039             last_type_symbol = param_data_type;
  9722             
 10040             
  9723             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10041             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9724             {
 10042             {
  9725         
 10043         
       
 10044                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9726                 
 10045                 
  9727                 if (IN_type_symbol == NULL)
 10046                 if (IN_type_symbol == NULL)
  9728                   IN_type_symbol = last_type_symbol;
 10047                   IN_type_symbol = last_type_symbol;
  9729                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10048                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9730                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
 10049                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
  9731                 function_type_prefix = return_type_symbol;
 10050                 function_type_prefix = return_type_symbol;
       
 10051                 function_type_suffix = IN_type_symbol;
  9732                 break;
 10052                 break;
  9733                 
 10053                 
  9734             }
 10054             }
  9735             
 10055             
  9736             
 10056             
  9755             last_type_symbol = param_data_type;
 10075             last_type_symbol = param_data_type;
  9756             
 10076             
  9757             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10077             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9758             {
 10078             {
  9759         
 10079         
       
 10080                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9760                 
 10081                 
  9761                 if (IN_type_symbol == NULL)
 10082                 if (IN_type_symbol == NULL)
  9762                   IN_type_symbol = last_type_symbol;
 10083                   IN_type_symbol = last_type_symbol;
  9763                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10084                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9764                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
 10085                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
  9765                 function_type_prefix = return_type_symbol;
 10086                 function_type_prefix = return_type_symbol;
       
 10087                 function_type_suffix = IN_type_symbol;
  9766                 break;
 10088                 break;
  9767                 
 10089                 
  9768             }
 10090             }
  9769             
 10091             
  9770             
 10092             
  9824             last_type_symbol = param_data_type;
 10146             last_type_symbol = param_data_type;
  9825             
 10147             
  9826             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10148             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9827             {
 10149             {
  9828         
 10150         
       
 10151                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9829                 
 10152                 
  9830                 if (IN_type_symbol == NULL)
 10153                 if (IN_type_symbol == NULL)
  9831                   IN_type_symbol = last_type_symbol;
 10154                   IN_type_symbol = last_type_symbol;
  9832                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10155                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9833                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
 10156                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
  9834                 function_type_prefix = return_type_symbol;
 10157                 function_type_prefix = return_type_symbol;
       
 10158                 function_type_suffix = IN_type_symbol;
  9835                 break;
 10159                 break;
  9836                 
 10160                 
  9837             }
 10161             }
  9838             
 10162             
  9839             
 10163             
  9858             last_type_symbol = param_data_type;
 10182             last_type_symbol = param_data_type;
  9859             
 10183             
  9860             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10184             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9861             {
 10185             {
  9862         
 10186         
       
 10187                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9863                 
 10188                 
  9864                 if (IN_type_symbol == NULL)
 10189                 if (IN_type_symbol == NULL)
  9865                   IN_type_symbol = last_type_symbol;
 10190                   IN_type_symbol = last_type_symbol;
  9866                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10191                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9867                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
 10192                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
  9868                 function_type_prefix = return_type_symbol;
 10193                 function_type_prefix = return_type_symbol;
       
 10194                 function_type_suffix = IN_type_symbol;
  9869                 break;
 10195                 break;
  9870                 
 10196                 
  9871             }
 10197             }
  9872             
 10198             
  9873             
 10199             
  9892             last_type_symbol = param_data_type;
 10218             last_type_symbol = param_data_type;
  9893             
 10219             
  9894             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10220             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9895             {
 10221             {
  9896         
 10222         
       
 10223                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9897                 
 10224                 
  9898                 if (IN_type_symbol == NULL)
 10225                 if (IN_type_symbol == NULL)
  9899                   IN_type_symbol = last_type_symbol;
 10226                   IN_type_symbol = last_type_symbol;
  9900                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10227                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9901                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
 10228                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
  9902                 function_type_prefix = return_type_symbol;
 10229                 function_type_prefix = return_type_symbol;
       
 10230                 function_type_suffix = IN_type_symbol;
  9903                 break;
 10231                 break;
  9904                 
 10232                 
  9905             }
 10233             }
  9906             
 10234             
  9907             
 10235             
  9926             last_type_symbol = param_data_type;
 10254             last_type_symbol = param_data_type;
  9927             
 10255             
  9928             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10256             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9929             {
 10257             {
  9930         
 10258         
       
 10259                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9931                 
 10260                 
  9932                 if (IN_type_symbol == NULL)
 10261                 if (IN_type_symbol == NULL)
  9933                   IN_type_symbol = last_type_symbol;
 10262                   IN_type_symbol = last_type_symbol;
  9934                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10263                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9935                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
 10264                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
  9936                 function_type_prefix = return_type_symbol;
 10265                 function_type_prefix = return_type_symbol;
       
 10266                 function_type_suffix = IN_type_symbol;
  9937                 break;
 10267                 break;
  9938                 
 10268                 
  9939             }
 10269             }
  9940             
 10270             
  9941             
 10271             
  9960             last_type_symbol = param_data_type;
 10290             last_type_symbol = param_data_type;
  9961             
 10291             
  9962             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10292             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9963             {
 10293             {
  9964         
 10294         
       
 10295                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9965                 
 10296                 
  9966                 if (IN_type_symbol == NULL)
 10297                 if (IN_type_symbol == NULL)
  9967                   IN_type_symbol = last_type_symbol;
 10298                   IN_type_symbol = last_type_symbol;
  9968                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10299                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
  9969                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
 10300                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
  9970                 function_type_prefix = return_type_symbol;
 10301                 function_type_prefix = return_type_symbol;
       
 10302                 function_type_suffix = IN_type_symbol;
  9971                 break;
 10303                 break;
  9972                 
 10304                 
  9973             }
 10305             }
  9974             
 10306             
  9975             
 10307             
  9994             last_type_symbol = param_data_type;
 10326             last_type_symbol = param_data_type;
  9995             
 10327             
  9996             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10328             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
  9997             {
 10329             {
  9998         
 10330         
       
 10331                 function_name = (symbol_c*)(new pragma_c("__move_"));
  9999                 
 10332                 
 10000                 if (IN_type_symbol == NULL)
 10333                 if (IN_type_symbol == NULL)
 10001                   IN_type_symbol = last_type_symbol;
 10334                   IN_type_symbol = last_type_symbol;
 10002                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10335                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10003                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
 10336                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
 10004                 function_type_prefix = return_type_symbol;
 10337                 function_type_prefix = return_type_symbol;
       
 10338                 function_type_suffix = IN_type_symbol;
 10005                 break;
 10339                 break;
 10006                 
 10340                 
 10007             }
 10341             }
 10008             
 10342             
 10009             
 10343             
 10063             last_type_symbol = param_data_type;
 10397             last_type_symbol = param_data_type;
 10064             
 10398             
 10065             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10399             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol))
 10066             {
 10400             {
 10067         
 10401         
       
 10402                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10068                 
 10403                 
 10069                 if (IN_type_symbol == NULL)
 10404                 if (IN_type_symbol == NULL)
 10070                   IN_type_symbol = last_type_symbol;
 10405                   IN_type_symbol = last_type_symbol;
 10071                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10406                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10072                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
 10407                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
 10073                 function_type_prefix = return_type_symbol;
 10408                 function_type_prefix = return_type_symbol;
       
 10409                 function_type_suffix = IN_type_symbol;
 10074                 break;
 10410                 break;
 10075                 
 10411                 
 10076             }
 10412             }
 10077             
 10413             
 10078             
 10414             
 10097             last_type_symbol = param_data_type;
 10433             last_type_symbol = param_data_type;
 10098             
 10434             
 10099             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10435             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10100             {
 10436             {
 10101         
 10437         
       
 10438                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10102                 
 10439                 
 10103                 if (IN_type_symbol == NULL)
 10440                 if (IN_type_symbol == NULL)
 10104                   IN_type_symbol = last_type_symbol;
 10441                   IN_type_symbol = last_type_symbol;
 10105                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10442                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10106                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
 10443                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
 10107                 function_type_prefix = return_type_symbol;
 10444                 function_type_prefix = return_type_symbol;
       
 10445                 function_type_suffix = IN_type_symbol;
 10108                 break;
 10446                 break;
 10109                 
 10447                 
 10110             }
 10448             }
 10111             
 10449             
 10112             
 10450             
 10131             last_type_symbol = param_data_type;
 10469             last_type_symbol = param_data_type;
 10132             
 10470             
 10133             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10471             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10134             {
 10472             {
 10135         
 10473         
       
 10474                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10136                 
 10475                 
 10137                 if (IN_type_symbol == NULL)
 10476                 if (IN_type_symbol == NULL)
 10138                   IN_type_symbol = last_type_symbol;
 10477                   IN_type_symbol = last_type_symbol;
 10139                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10478                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10140                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
 10479                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
 10141                 function_type_prefix = return_type_symbol;
 10480                 function_type_prefix = return_type_symbol;
       
 10481                 function_type_suffix = IN_type_symbol;
 10142                 break;
 10482                 break;
 10143                 
 10483                 
 10144             }
 10484             }
 10145             
 10485             
 10146             
 10486             
 10165             last_type_symbol = param_data_type;
 10505             last_type_symbol = param_data_type;
 10166             
 10506             
 10167             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10507             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10168             {
 10508             {
 10169         
 10509         
       
 10510                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10170                 
 10511                 
 10171                 if (IN_type_symbol == NULL)
 10512                 if (IN_type_symbol == NULL)
 10172                   IN_type_symbol = last_type_symbol;
 10513                   IN_type_symbol = last_type_symbol;
 10173                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10514                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10174                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
 10515                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
 10175                 function_type_prefix = return_type_symbol;
 10516                 function_type_prefix = return_type_symbol;
       
 10517                 function_type_suffix = IN_type_symbol;
 10176                 break;
 10518                 break;
 10177                 
 10519                 
 10178             }
 10520             }
 10179             
 10521             
 10180             
 10522             
 10199             last_type_symbol = param_data_type;
 10541             last_type_symbol = param_data_type;
 10200             
 10542             
 10201             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10543             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10202             {
 10544             {
 10203         
 10545         
       
 10546                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10204                 
 10547                 
 10205                 if (IN_type_symbol == NULL)
 10548                 if (IN_type_symbol == NULL)
 10206                   IN_type_symbol = last_type_symbol;
 10549                   IN_type_symbol = last_type_symbol;
 10207                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10550                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10208                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
 10551                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
 10209                 function_type_prefix = return_type_symbol;
 10552                 function_type_prefix = return_type_symbol;
       
 10553                 function_type_suffix = IN_type_symbol;
 10210                 break;
 10554                 break;
 10211                 
 10555                 
 10212             }
 10556             }
 10213             
 10557             
 10214             
 10558             
 10268             last_type_symbol = param_data_type;
 10612             last_type_symbol = param_data_type;
 10269             
 10613             
 10270             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10614             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10271             {
 10615             {
 10272         
 10616         
       
 10617                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10273                 
 10618                 
 10274                 if (IN_type_symbol == NULL)
 10619                 if (IN_type_symbol == NULL)
 10275                   IN_type_symbol = last_type_symbol;
 10620                   IN_type_symbol = last_type_symbol;
 10276                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10621                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10277                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
 10622                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
 10278                 function_type_prefix = return_type_symbol;
 10623                 function_type_prefix = return_type_symbol;
       
 10624                 function_type_suffix = IN_type_symbol;
 10279                 break;
 10625                 break;
 10280                 
 10626                 
 10281             }
 10627             }
 10282             
 10628             
 10283             
 10629             
 10372             last_type_symbol = param_data_type;
 10718             last_type_symbol = param_data_type;
 10373             
 10719             
 10374             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10720             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10375             {
 10721             {
 10376         
 10722         
       
 10723                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10377                 
 10724                 
 10378                 if (IN_type_symbol == NULL)
 10725                 if (IN_type_symbol == NULL)
 10379                   IN_type_symbol = last_type_symbol;
 10726                   IN_type_symbol = last_type_symbol;
 10380                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10727                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10381                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
 10728                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
 10382                 function_type_prefix = return_type_symbol;
 10729                 function_type_prefix = return_type_symbol;
       
 10730                 function_type_suffix = IN_type_symbol;
 10383                 break;
 10731                 break;
 10384                 
 10732                 
 10385             }
 10733             }
 10386             
 10734             
 10387             
 10735             
 10406             last_type_symbol = param_data_type;
 10754             last_type_symbol = param_data_type;
 10407             
 10755             
 10408             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10756             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10409             {
 10757             {
 10410         
 10758         
       
 10759                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10411                 
 10760                 
 10412                 if (IN_type_symbol == NULL)
 10761                 if (IN_type_symbol == NULL)
 10413                   IN_type_symbol = last_type_symbol;
 10762                   IN_type_symbol = last_type_symbol;
 10414                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10763                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10415                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
 10764                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
 10416                 function_type_prefix = return_type_symbol;
 10765                 function_type_prefix = return_type_symbol;
       
 10766                 function_type_suffix = IN_type_symbol;
 10417                 break;
 10767                 break;
 10418                 
 10768                 
 10419             }
 10769             }
 10420             
 10770             
 10421             
 10771             
 10475             last_type_symbol = param_data_type;
 10825             last_type_symbol = param_data_type;
 10476             
 10826             
 10477             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10827             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10478             {
 10828             {
 10479         
 10829         
       
 10830                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10480                 
 10831                 
 10481                 if (IN_type_symbol == NULL)
 10832                 if (IN_type_symbol == NULL)
 10482                   IN_type_symbol = last_type_symbol;
 10833                   IN_type_symbol = last_type_symbol;
 10483                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10834                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10484                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
 10835                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
 10485                 function_type_prefix = return_type_symbol;
 10836                 function_type_prefix = return_type_symbol;
       
 10837                 function_type_suffix = IN_type_symbol;
 10486                 break;
 10838                 break;
 10487                 
 10839                 
 10488             }
 10840             }
 10489             
 10841             
 10490             
 10842             
 10509             last_type_symbol = param_data_type;
 10861             last_type_symbol = param_data_type;
 10510             
 10862             
 10511             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10863             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10512             {
 10864             {
 10513         
 10865         
       
 10866                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10514                 
 10867                 
 10515                 if (IN_type_symbol == NULL)
 10868                 if (IN_type_symbol == NULL)
 10516                   IN_type_symbol = last_type_symbol;
 10869                   IN_type_symbol = last_type_symbol;
 10517                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10870                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10518                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
 10871                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
 10519                 function_type_prefix = return_type_symbol;
 10872                 function_type_prefix = return_type_symbol;
       
 10873                 function_type_suffix = IN_type_symbol;
 10520                 break;
 10874                 break;
 10521                 
 10875                 
 10522             }
 10876             }
 10523             
 10877             
 10524             
 10878             
 10543             last_type_symbol = param_data_type;
 10897             last_type_symbol = param_data_type;
 10544             
 10898             
 10545             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10899             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10546             {
 10900             {
 10547         
 10901         
       
 10902                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10548                 
 10903                 
 10549                 if (IN_type_symbol == NULL)
 10904                 if (IN_type_symbol == NULL)
 10550                   IN_type_symbol = last_type_symbol;
 10905                   IN_type_symbol = last_type_symbol;
 10551                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10906                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10552                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
 10907                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
 10553                 function_type_prefix = return_type_symbol;
 10908                 function_type_prefix = return_type_symbol;
       
 10909                 function_type_suffix = IN_type_symbol;
 10554                 break;
 10910                 break;
 10555                 
 10911                 
 10556             }
 10912             }
 10557             
 10913             
 10558             
 10914             
 10577             last_type_symbol = param_data_type;
 10933             last_type_symbol = param_data_type;
 10578             
 10934             
 10579             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10935             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10580             {
 10936             {
 10581         
 10937         
       
 10938                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10582                 
 10939                 
 10583                 if (IN_type_symbol == NULL)
 10940                 if (IN_type_symbol == NULL)
 10584                   IN_type_symbol = last_type_symbol;
 10941                   IN_type_symbol = last_type_symbol;
 10585                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10942                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10586                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
 10943                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
 10587                 function_type_prefix = return_type_symbol;
 10944                 function_type_prefix = return_type_symbol;
       
 10945                 function_type_suffix = IN_type_symbol;
 10588                 break;
 10946                 break;
 10589                 
 10947                 
 10590             }
 10948             }
 10591             
 10949             
 10592             
 10950             
 10611             last_type_symbol = param_data_type;
 10969             last_type_symbol = param_data_type;
 10612             
 10970             
 10613             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10971             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10614             {
 10972             {
 10615         
 10973         
       
 10974                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10616                 
 10975                 
 10617                 if (IN_type_symbol == NULL)
 10976                 if (IN_type_symbol == NULL)
 10618                   IN_type_symbol = last_type_symbol;
 10977                   IN_type_symbol = last_type_symbol;
 10619                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10978                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10620                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
 10979                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
 10621                 function_type_prefix = return_type_symbol;
 10980                 function_type_prefix = return_type_symbol;
       
 10981                 function_type_suffix = IN_type_symbol;
 10622                 break;
 10982                 break;
 10623                 
 10983                 
 10624             }
 10984             }
 10625             
 10985             
 10626             
 10986             
 10645             last_type_symbol = param_data_type;
 11005             last_type_symbol = param_data_type;
 10646             
 11006             
 10647             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 11007             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10648             {
 11008             {
 10649         
 11009         
       
 11010                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10650                 
 11011                 
 10651                 if (IN_type_symbol == NULL)
 11012                 if (IN_type_symbol == NULL)
 10652                   IN_type_symbol = last_type_symbol;
 11013                   IN_type_symbol = last_type_symbol;
 10653                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11014                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10654                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
 11015                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
 10655                 function_type_prefix = return_type_symbol;
 11016                 function_type_prefix = return_type_symbol;
       
 11017                 function_type_suffix = IN_type_symbol;
 10656                 break;
 11018                 break;
 10657                 
 11019                 
 10658             }
 11020             }
 10659             
 11021             
 10660             
 11022             
 10714             last_type_symbol = param_data_type;
 11076             last_type_symbol = param_data_type;
 10715             
 11077             
 10716             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 11078             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol))
 10717             {
 11079             {
 10718         
 11080         
       
 11081                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10719                 
 11082                 
 10720                 if (IN_type_symbol == NULL)
 11083                 if (IN_type_symbol == NULL)
 10721                   IN_type_symbol = last_type_symbol;
 11084                   IN_type_symbol = last_type_symbol;
 10722                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11085                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10723                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
 11086                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
 10724                 function_type_prefix = return_type_symbol;
 11087                 function_type_prefix = return_type_symbol;
       
 11088                 function_type_suffix = IN_type_symbol;
 10725                 break;
 11089                 break;
 10726                 
 11090                 
 10727             }
 11091             }
 10728             
 11092             
 10729             
 11093             
 10748             last_type_symbol = param_data_type;
 11112             last_type_symbol = param_data_type;
 10749             
 11113             
 10750             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11114             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 10751             {
 11115             {
 10752         
 11116         
       
 11117                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10753                 
 11118                 
 10754                 if (IN_type_symbol == NULL)
 11119                 if (IN_type_symbol == NULL)
 10755                   IN_type_symbol = last_type_symbol;
 11120                   IN_type_symbol = last_type_symbol;
 10756                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11121                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10757                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
 11122                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
 10758                 function_type_prefix = return_type_symbol;
 11123                 function_type_prefix = return_type_symbol;
       
 11124                 function_type_suffix = IN_type_symbol;
 10759                 break;
 11125                 break;
 10760                 
 11126                 
 10761             }
 11127             }
 10762             
 11128             
 10763             
 11129             
 10782             last_type_symbol = param_data_type;
 11148             last_type_symbol = param_data_type;
 10783             
 11149             
 10784             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11150             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 10785             {
 11151             {
 10786         
 11152         
       
 11153                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10787                 
 11154                 
 10788                 if (IN_type_symbol == NULL)
 11155                 if (IN_type_symbol == NULL)
 10789                   IN_type_symbol = last_type_symbol;
 11156                   IN_type_symbol = last_type_symbol;
 10790                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11157                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10791                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
 11158                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
 10792                 function_type_prefix = return_type_symbol;
 11159                 function_type_prefix = return_type_symbol;
       
 11160                 function_type_suffix = IN_type_symbol;
 10793                 break;
 11161                 break;
 10794                 
 11162                 
 10795             }
 11163             }
 10796             
 11164             
 10797             
 11165             
 10816             last_type_symbol = param_data_type;
 11184             last_type_symbol = param_data_type;
 10817             
 11185             
 10818             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11186             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 10819             {
 11187             {
 10820         
 11188         
       
 11189                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10821                 
 11190                 
 10822                 if (IN_type_symbol == NULL)
 11191                 if (IN_type_symbol == NULL)
 10823                   IN_type_symbol = last_type_symbol;
 11192                   IN_type_symbol = last_type_symbol;
 10824                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11193                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10825                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
 11194                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
 10826                 function_type_prefix = return_type_symbol;
 11195                 function_type_prefix = return_type_symbol;
       
 11196                 function_type_suffix = IN_type_symbol;
 10827                 break;
 11197                 break;
 10828                 
 11198                 
 10829             }
 11199             }
 10830             
 11200             
 10831             
 11201             
 10850             last_type_symbol = param_data_type;
 11220             last_type_symbol = param_data_type;
 10851             
 11221             
 10852             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11222             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 10853             {
 11223             {
 10854         
 11224         
       
 11225                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10855                 
 11226                 
 10856                 if (IN_type_symbol == NULL)
 11227                 if (IN_type_symbol == NULL)
 10857                   IN_type_symbol = last_type_symbol;
 11228                   IN_type_symbol = last_type_symbol;
 10858                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11229                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10859                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
 11230                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
 10860                 function_type_prefix = return_type_symbol;
 11231                 function_type_prefix = return_type_symbol;
       
 11232                 function_type_suffix = IN_type_symbol;
 10861                 break;
 11233                 break;
 10862                 
 11234                 
 10863             }
 11235             }
 10864             
 11236             
 10865             
 11237             
 10919             last_type_symbol = param_data_type;
 11291             last_type_symbol = param_data_type;
 10920             
 11292             
 10921             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11293             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 10922             {
 11294             {
 10923         
 11295         
       
 11296                 function_name = (symbol_c*)(new pragma_c("__move_"));
 10924                 
 11297                 
 10925                 if (IN_type_symbol == NULL)
 11298                 if (IN_type_symbol == NULL)
 10926                   IN_type_symbol = last_type_symbol;
 11299                   IN_type_symbol = last_type_symbol;
 10927                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11300                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 10928                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
 11301                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
 10929                 function_type_prefix = return_type_symbol;
 11302                 function_type_prefix = return_type_symbol;
       
 11303                 function_type_suffix = IN_type_symbol;
 10930                 break;
 11304                 break;
 10931                 
 11305                 
 10932             }
 11306             }
 10933             
 11307             
 10934             
 11308             
 11023             last_type_symbol = param_data_type;
 11397             last_type_symbol = param_data_type;
 11024             
 11398             
 11025             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11399             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11026             {
 11400             {
 11027         
 11401         
       
 11402                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11028                 
 11403                 
 11029                 if (IN_type_symbol == NULL)
 11404                 if (IN_type_symbol == NULL)
 11030                   IN_type_symbol = last_type_symbol;
 11405                   IN_type_symbol = last_type_symbol;
 11031                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11406                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11032                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
 11407                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
 11033                 function_type_prefix = return_type_symbol;
 11408                 function_type_prefix = return_type_symbol;
       
 11409                 function_type_suffix = IN_type_symbol;
 11034                 break;
 11410                 break;
 11035                 
 11411                 
 11036             }
 11412             }
 11037             
 11413             
 11038             
 11414             
 11057             last_type_symbol = param_data_type;
 11433             last_type_symbol = param_data_type;
 11058             
 11434             
 11059             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11435             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11060             {
 11436             {
 11061         
 11437         
       
 11438                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11062                 
 11439                 
 11063                 if (IN_type_symbol == NULL)
 11440                 if (IN_type_symbol == NULL)
 11064                   IN_type_symbol = last_type_symbol;
 11441                   IN_type_symbol = last_type_symbol;
 11065                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11442                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11066                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
 11443                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
 11067                 function_type_prefix = return_type_symbol;
 11444                 function_type_prefix = return_type_symbol;
       
 11445                 function_type_suffix = IN_type_symbol;
 11068                 break;
 11446                 break;
 11069                 
 11447                 
 11070             }
 11448             }
 11071             
 11449             
 11072             
 11450             
 11126             last_type_symbol = param_data_type;
 11504             last_type_symbol = param_data_type;
 11127             
 11505             
 11128             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11506             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11129             {
 11507             {
 11130         
 11508         
       
 11509                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11131                 
 11510                 
 11132                 if (IN_type_symbol == NULL)
 11511                 if (IN_type_symbol == NULL)
 11133                   IN_type_symbol = last_type_symbol;
 11512                   IN_type_symbol = last_type_symbol;
 11134                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11513                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11135                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
 11514                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
 11136                 function_type_prefix = return_type_symbol;
 11515                 function_type_prefix = return_type_symbol;
       
 11516                 function_type_suffix = IN_type_symbol;
 11137                 break;
 11517                 break;
 11138                 
 11518                 
 11139             }
 11519             }
 11140             
 11520             
 11141             
 11521             
 11160             last_type_symbol = param_data_type;
 11540             last_type_symbol = param_data_type;
 11161             
 11541             
 11162             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11542             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11163             {
 11543             {
 11164         
 11544         
       
 11545                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11165                 
 11546                 
 11166                 if (IN_type_symbol == NULL)
 11547                 if (IN_type_symbol == NULL)
 11167                   IN_type_symbol = last_type_symbol;
 11548                   IN_type_symbol = last_type_symbol;
 11168                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11549                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11169                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
 11550                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
 11170                 function_type_prefix = return_type_symbol;
 11551                 function_type_prefix = return_type_symbol;
       
 11552                 function_type_suffix = IN_type_symbol;
 11171                 break;
 11553                 break;
 11172                 
 11554                 
 11173             }
 11555             }
 11174             
 11556             
 11175             
 11557             
 11194             last_type_symbol = param_data_type;
 11576             last_type_symbol = param_data_type;
 11195             
 11577             
 11196             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11578             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11197             {
 11579             {
 11198         
 11580         
       
 11581                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11199                 
 11582                 
 11200                 if (IN_type_symbol == NULL)
 11583                 if (IN_type_symbol == NULL)
 11201                   IN_type_symbol = last_type_symbol;
 11584                   IN_type_symbol = last_type_symbol;
 11202                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11585                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11203                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
 11586                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
 11204                 function_type_prefix = return_type_symbol;
 11587                 function_type_prefix = return_type_symbol;
       
 11588                 function_type_suffix = IN_type_symbol;
 11205                 break;
 11589                 break;
 11206                 
 11590                 
 11207             }
 11591             }
 11208             
 11592             
 11209             
 11593             
 11228             last_type_symbol = param_data_type;
 11612             last_type_symbol = param_data_type;
 11229             
 11613             
 11230             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11614             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11231             {
 11615             {
 11232         
 11616         
       
 11617                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11233                 
 11618                 
 11234                 if (IN_type_symbol == NULL)
 11619                 if (IN_type_symbol == NULL)
 11235                   IN_type_symbol = last_type_symbol;
 11620                   IN_type_symbol = last_type_symbol;
 11236                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11621                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11237                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
 11622                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
 11238                 function_type_prefix = return_type_symbol;
 11623                 function_type_prefix = return_type_symbol;
       
 11624                 function_type_suffix = IN_type_symbol;
 11239                 break;
 11625                 break;
 11240                 
 11626                 
 11241             }
 11627             }
 11242             
 11628             
 11243             
 11629             
 11262             last_type_symbol = param_data_type;
 11648             last_type_symbol = param_data_type;
 11263             
 11649             
 11264             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11650             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11265             {
 11651             {
 11266         
 11652         
       
 11653                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11267                 
 11654                 
 11268                 if (IN_type_symbol == NULL)
 11655                 if (IN_type_symbol == NULL)
 11269                   IN_type_symbol = last_type_symbol;
 11656                   IN_type_symbol = last_type_symbol;
 11270                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11657                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11271                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
 11658                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
 11272                 function_type_prefix = return_type_symbol;
 11659                 function_type_prefix = return_type_symbol;
       
 11660                 function_type_suffix = IN_type_symbol;
 11273                 break;
 11661                 break;
 11274                 
 11662                 
 11275             }
 11663             }
 11276             
 11664             
 11277             
 11665             
 11296             last_type_symbol = param_data_type;
 11684             last_type_symbol = param_data_type;
 11297             
 11685             
 11298             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11686             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11299             {
 11687             {
 11300         
 11688         
       
 11689                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11301                 
 11690                 
 11302                 if (IN_type_symbol == NULL)
 11691                 if (IN_type_symbol == NULL)
 11303                   IN_type_symbol = last_type_symbol;
 11692                   IN_type_symbol = last_type_symbol;
 11304                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11693                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11305                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
 11694                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
 11306                 function_type_prefix = return_type_symbol;
 11695                 function_type_prefix = return_type_symbol;
       
 11696                 function_type_suffix = IN_type_symbol;
 11307                 break;
 11697                 break;
 11308                 
 11698                 
 11309             }
 11699             }
 11310             
 11700             
 11311             
 11701             
 11365             last_type_symbol = param_data_type;
 11755             last_type_symbol = param_data_type;
 11366             
 11756             
 11367             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11757             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))
 11368             {
 11758             {
 11369         
 11759         
       
 11760                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11370                 
 11761                 
 11371                 if (IN_type_symbol == NULL)
 11762                 if (IN_type_symbol == NULL)
 11372                   IN_type_symbol = last_type_symbol;
 11763                   IN_type_symbol = last_type_symbol;
 11373                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11764                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11374                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
 11765                 symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
 11375                 function_type_prefix = return_type_symbol;
 11766                 function_type_prefix = return_type_symbol;
       
 11767                 function_type_suffix = IN_type_symbol;
 11376                 break;
 11768                 break;
 11377                 
 11769                 
 11378             }
 11770             }
 11379             
 11771             
 11380             
 11772             
 11924             last_type_symbol = param_data_type;
 12316             last_type_symbol = param_data_type;
 11925             
 12317             
 11926             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12318             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 11927             {
 12319             {
 11928         
 12320         
       
 12321                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11929                 
 12322                 
 11930                 if (IN_type_symbol == NULL)
 12323                 if (IN_type_symbol == NULL)
 11931                   IN_type_symbol = last_type_symbol;
 12324                   IN_type_symbol = last_type_symbol;
 11932                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12325                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11933                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
 12326                 symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
 11934                 function_type_prefix = return_type_symbol;
 12327                 function_type_prefix = return_type_symbol;
       
 12328                 function_type_suffix = IN_type_symbol;
 11935                 break;
 12329                 break;
 11936                 
 12330                 
 11937             }
 12331             }
 11938             
 12332             
 11939             
 12333             
 11958             last_type_symbol = param_data_type;
 12352             last_type_symbol = param_data_type;
 11959             
 12353             
 11960             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12354             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 11961             {
 12355             {
 11962         
 12356         
       
 12357                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11963                 
 12358                 
 11964                 if (IN_type_symbol == NULL)
 12359                 if (IN_type_symbol == NULL)
 11965                   IN_type_symbol = last_type_symbol;
 12360                   IN_type_symbol = last_type_symbol;
 11966                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12361                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 11967                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
 12362                 symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
 11968                 function_type_prefix = return_type_symbol;
 12363                 function_type_prefix = return_type_symbol;
       
 12364                 function_type_suffix = IN_type_symbol;
 11969                 break;
 12365                 break;
 11970                 
 12366                 
 11971             }
 12367             }
 11972             
 12368             
 11973             
 12369             
 11992             last_type_symbol = param_data_type;
 12388             last_type_symbol = param_data_type;
 11993             
 12389             
 11994             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12390             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 11995             {
 12391             {
 11996         
 12392         
       
 12393                 function_name = (symbol_c*)(new pragma_c("__move_"));
 11997                 
 12394                 
 11998                 if (IN_type_symbol == NULL)
 12395                 if (IN_type_symbol == NULL)
 11999                   IN_type_symbol = last_type_symbol;
 12396                   IN_type_symbol = last_type_symbol;
 12000                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12397                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12001                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
 12398                 symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
 12002                 function_type_prefix = return_type_symbol;
 12399                 function_type_prefix = return_type_symbol;
       
 12400                 function_type_suffix = IN_type_symbol;
 12003                 break;
 12401                 break;
 12004                 
 12402                 
 12005             }
 12403             }
 12006             
 12404             
 12007             
 12405             
 12026             last_type_symbol = param_data_type;
 12424             last_type_symbol = param_data_type;
 12027             
 12425             
 12028             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12426             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12029             {
 12427             {
 12030         
 12428         
       
 12429                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12031                 
 12430                 
 12032                 if (IN_type_symbol == NULL)
 12431                 if (IN_type_symbol == NULL)
 12033                   IN_type_symbol = last_type_symbol;
 12432                   IN_type_symbol = last_type_symbol;
 12034                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12433                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12035                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
 12434                 symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
 12036                 function_type_prefix = return_type_symbol;
 12435                 function_type_prefix = return_type_symbol;
       
 12436                 function_type_suffix = IN_type_symbol;
 12037                 break;
 12437                 break;
 12038                 
 12438                 
 12039             }
 12439             }
 12040             
 12440             
 12041             
 12441             
 12095             last_type_symbol = param_data_type;
 12495             last_type_symbol = param_data_type;
 12096             
 12496             
 12097             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12497             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12098             {
 12498             {
 12099         
 12499         
       
 12500                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12100                 
 12501                 
 12101                 if (IN_type_symbol == NULL)
 12502                 if (IN_type_symbol == NULL)
 12102                   IN_type_symbol = last_type_symbol;
 12503                   IN_type_symbol = last_type_symbol;
 12103                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12504                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12104                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
 12505                 symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
 12105                 function_type_prefix = return_type_symbol;
 12506                 function_type_prefix = return_type_symbol;
       
 12507                 function_type_suffix = IN_type_symbol;
 12106                 break;
 12508                 break;
 12107                 
 12509                 
 12108             }
 12510             }
 12109             
 12511             
 12110             
 12512             
 12199             last_type_symbol = param_data_type;
 12601             last_type_symbol = param_data_type;
 12200             
 12602             
 12201             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12603             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12202             {
 12604             {
 12203         
 12605         
       
 12606                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12204                 
 12607                 
 12205                 if (IN_type_symbol == NULL)
 12608                 if (IN_type_symbol == NULL)
 12206                   IN_type_symbol = last_type_symbol;
 12609                   IN_type_symbol = last_type_symbol;
 12207                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12610                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12208                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
 12611                 symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
 12209                 function_type_prefix = return_type_symbol;
 12612                 function_type_prefix = return_type_symbol;
       
 12613                 function_type_suffix = IN_type_symbol;
 12210                 break;
 12614                 break;
 12211                 
 12615                 
 12212             }
 12616             }
 12213             
 12617             
 12214             
 12618             
 12233             last_type_symbol = param_data_type;
 12637             last_type_symbol = param_data_type;
 12234             
 12638             
 12235             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12639             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12236             {
 12640             {
 12237         
 12641         
       
 12642                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12238                 
 12643                 
 12239                 if (IN_type_symbol == NULL)
 12644                 if (IN_type_symbol == NULL)
 12240                   IN_type_symbol = last_type_symbol;
 12645                   IN_type_symbol = last_type_symbol;
 12241                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12646                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12242                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
 12647                 symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
 12243                 function_type_prefix = return_type_symbol;
 12648                 function_type_prefix = return_type_symbol;
       
 12649                 function_type_suffix = IN_type_symbol;
 12244                 break;
 12650                 break;
 12245                 
 12651                 
 12246             }
 12652             }
 12247             
 12653             
 12248             
 12654             
 12302             last_type_symbol = param_data_type;
 12708             last_type_symbol = param_data_type;
 12303             
 12709             
 12304             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12710             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12305             {
 12711             {
 12306         
 12712         
       
 12713                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12307                 
 12714                 
 12308                 if (IN_type_symbol == NULL)
 12715                 if (IN_type_symbol == NULL)
 12309                   IN_type_symbol = last_type_symbol;
 12716                   IN_type_symbol = last_type_symbol;
 12310                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12717                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12311                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
 12718                 symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
 12312                 function_type_prefix = return_type_symbol;
 12719                 function_type_prefix = return_type_symbol;
       
 12720                 function_type_suffix = IN_type_symbol;
 12313                 break;
 12721                 break;
 12314                 
 12722                 
 12315             }
 12723             }
 12316             
 12724             
 12317             
 12725             
 12336             last_type_symbol = param_data_type;
 12744             last_type_symbol = param_data_type;
 12337             
 12745             
 12338             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12746             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12339             {
 12747             {
 12340         
 12748         
       
 12749                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12341                 
 12750                 
 12342                 if (IN_type_symbol == NULL)
 12751                 if (IN_type_symbol == NULL)
 12343                   IN_type_symbol = last_type_symbol;
 12752                   IN_type_symbol = last_type_symbol;
 12344                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12753                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12345                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
 12754                 symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
 12346                 function_type_prefix = return_type_symbol;
 12755                 function_type_prefix = return_type_symbol;
       
 12756                 function_type_suffix = IN_type_symbol;
 12347                 break;
 12757                 break;
 12348                 
 12758                 
 12349             }
 12759             }
 12350             
 12760             
 12351             
 12761             
 12370             last_type_symbol = param_data_type;
 12780             last_type_symbol = param_data_type;
 12371             
 12781             
 12372             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12782             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12373             {
 12783             {
 12374         
 12784         
       
 12785                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12375                 
 12786                 
 12376                 if (IN_type_symbol == NULL)
 12787                 if (IN_type_symbol == NULL)
 12377                   IN_type_symbol = last_type_symbol;
 12788                   IN_type_symbol = last_type_symbol;
 12378                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12789                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12379                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
 12790                 symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
 12380                 function_type_prefix = return_type_symbol;
 12791                 function_type_prefix = return_type_symbol;
       
 12792                 function_type_suffix = IN_type_symbol;
 12381                 break;
 12793                 break;
 12382                 
 12794                 
 12383             }
 12795             }
 12384             
 12796             
 12385             
 12797             
 12404             last_type_symbol = param_data_type;
 12816             last_type_symbol = param_data_type;
 12405             
 12817             
 12406             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12818             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12407             {
 12819             {
 12408         
 12820         
       
 12821                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12409                 
 12822                 
 12410                 if (IN_type_symbol == NULL)
 12823                 if (IN_type_symbol == NULL)
 12411                   IN_type_symbol = last_type_symbol;
 12824                   IN_type_symbol = last_type_symbol;
 12412                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12825                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12413                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
 12826                 symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
 12414                 function_type_prefix = return_type_symbol;
 12827                 function_type_prefix = return_type_symbol;
       
 12828                 function_type_suffix = IN_type_symbol;
 12415                 break;
 12829                 break;
 12416                 
 12830                 
 12417             }
 12831             }
 12418             
 12832             
 12419             
 12833             
 12438             last_type_symbol = param_data_type;
 12852             last_type_symbol = param_data_type;
 12439             
 12853             
 12440             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12854             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12441             {
 12855             {
 12442         
 12856         
       
 12857                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12443                 
 12858                 
 12444                 if (IN_type_symbol == NULL)
 12859                 if (IN_type_symbol == NULL)
 12445                   IN_type_symbol = last_type_symbol;
 12860                   IN_type_symbol = last_type_symbol;
 12446                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12861                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12447                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
 12862                 symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
 12448                 function_type_prefix = return_type_symbol;
 12863                 function_type_prefix = return_type_symbol;
       
 12864                 function_type_suffix = IN_type_symbol;
 12449                 break;
 12865                 break;
 12450                 
 12866                 
 12451             }
 12867             }
 12452             
 12868             
 12453             
 12869             
 12472             last_type_symbol = param_data_type;
 12888             last_type_symbol = param_data_type;
 12473             
 12889             
 12474             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12890             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12475             {
 12891             {
 12476         
 12892         
       
 12893                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12477                 
 12894                 
 12478                 if (IN_type_symbol == NULL)
 12895                 if (IN_type_symbol == NULL)
 12479                   IN_type_symbol = last_type_symbol;
 12896                   IN_type_symbol = last_type_symbol;
 12480                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12897                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12481                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
 12898                 symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
 12482                 function_type_prefix = return_type_symbol;
 12899                 function_type_prefix = return_type_symbol;
       
 12900                 function_type_suffix = IN_type_symbol;
 12483                 break;
 12901                 break;
 12484                 
 12902                 
 12485             }
 12903             }
 12486             
 12904             
 12487             
 12905             
 12506             last_type_symbol = param_data_type;
 12924             last_type_symbol = param_data_type;
 12507             
 12925             
 12508             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12926             if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol))
 12509             {
 12927             {
 12510         
 12928         
       
 12929                 function_name = (symbol_c*)(new pragma_c("__move_"));
 12511                 
 12930                 
 12512                 if (IN_type_symbol == NULL)
 12931                 if (IN_type_symbol == NULL)
 12513                   IN_type_symbol = last_type_symbol;
 12932                   IN_type_symbol = last_type_symbol;
 12514                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12933                 ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)
 12515                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
 12934                 symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
 12516                 function_type_prefix = return_type_symbol;
 12935                 function_type_prefix = return_type_symbol;
       
 12936                 function_type_suffix = IN_type_symbol;
 12517                 break;
 12937                 break;
 12518                 
 12938                 
 12519             }
 12939             }
 12520             
 12940             
 12521             
 12941