New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
Changeset 6372 for branches/UKMO/dev_r5518_debug_isf_restart/NEMOGCM/EXTERNAL/AGRIF/LIB/WorkWithlistofmodulebysubroutine.c – NEMO

Ignore:
Timestamp:
2016-03-08T11:12:40+01:00 (8 years ago)
Author:
frrh
Message:

Reverse previous merge.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/UKMO/dev_r5518_debug_isf_restart/NEMOGCM/EXTERNAL/AGRIF/LIB/WorkWithlistofmodulebysubroutine.c

    r6371 r6372  
    6161           List_ModuleUsed_Var = Readthedependfile 
    6262                               (tmplistmodule->u_usemodule,List_ModuleUsed_Var); 
     63         printf("PPPPPPPPPPPPPP\n"); 
    6364           List_GlobParamModuleUsed_Var = ReaddependParameterList 
    6465                      (tmplistmodule->u_usemodule,List_GlobParamModuleUsed_Var); 
    … …  
    7576/******************************************************************************/ 
    7677/******************************************************************************/ 
    77 void RecordUseModulesUseModulesVariables() 
    78 { 
    79     listusemodule *tmplistmodule; 
    80     listusemodule *save_list; 
    81  
    82     if ( ! List_NameOfModuleUsed )  return; 
    83  
    84     /* we should record all variables defined in modules used in this file      */ 
    85     /* and we should read the .depend of the module used by the module used  */ 
    86     tmplistmodule = List_NameOfModuleUsed; 
    87     while ( tmplistmodule ) 
    88     { 
     78void  RecordUseModulesUseModulesVariables() 
     79{ 
     80  listusemodule *tmplistmodule; 
     81  listusemodule *tmplistmodule1; 
     82 
     83  /* we should record all variables defined in modules used in this file      */ 
     84  if ( List_NameOfModuleUsed ) 
     85  { 
     86     /* and we should read the .depend of the module used by the module used  */ 
     87     tmplistmodule = List_NameOfModuleUsed; 
     88     while ( tmplistmodule ) 
     89     { 
    8990        Readthedependlistofmoduleused(tmplistmodule->u_usemodule); 
    9091        while( tmpuselocallist ) 
    9192        { 
    92             Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
    93             save_list = tmpuselocallist->suiv; 
    94             free(tmpuselocallist); 
    95             tmpuselocallist = save_list; 
     93           Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
     94           tmplistmodule1 = tmpuselocallist->suiv; 
     95           free(tmpuselocallist); 
     96           tmpuselocallist = tmplistmodule1; 
    9697        } 
    9798        tmplistmodule = tmplistmodule->suiv; 
    98     } 
    99     tmplistmodule = listofmoduletmp; 
    100     while ( tmplistmodule ) 
    101     { 
     99     } 
     100 
     101     tmplistmodule = listofmoduletmp; 
     102     while ( tmplistmodule ) 
     103     { 
    102104        Readthedependlistofmoduleused(tmplistmodule->u_usemodule); 
    103105        while( tmpuselocallist ) 
    104106        { 
    105             Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
    106             save_list = tmpuselocallist->suiv; 
    107             free(tmpuselocallist); 
    108             tmpuselocallist = save_list; 
     107           Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
     108           tmplistmodule1 = tmpuselocallist->suiv; 
     109           free(tmpuselocallist); 
     110           tmpuselocallist = tmplistmodule1; 
    109111        } 
    110112        tmplistmodule = tmplistmodule->suiv; 
    111     } 
    112     tmplistmodule = listofmoduletmp; 
    113     while ( tmplistmodule ) 
    114     { 
    115         // check if the file .depend<u_usemodule> exists 
    116         List_ModuleUsedInModuleUsed_Var = 
    117             Readthedependfile(tmplistmodule->u_usemodule,List_ModuleUsedInModuleUsed_Var); 
    118  
    119         List_GlobParamModuleUsedInModuleUsed_Var = 
    120             ReaddependParameterList(tmplistmodule->u_usemodule,List_GlobParamModuleUsedInModuleUsed_Var); 
     113     } 
     114 
     115 
     116 
     117     tmplistmodule = listofmoduletmp; 
     118     while ( tmplistmodule ) 
     119     { 
     120        /* check if the file .depend<u_usemodule> exist                       */ 
     121        List_ModuleUsedInModuleUsed_Var = Readthedependfile 
     122                   (tmplistmodule->u_usemodule,List_ModuleUsedInModuleUsed_Var); 
     123 
     124        List_GlobParamModuleUsedInModuleUsed_Var = ReaddependParameterList 
     125          (tmplistmodule->u_usemodule,List_GlobParamModuleUsedInModuleUsed_Var); 
    121126        tmplistmodule = tmplistmodule->suiv; 
    122     } 
     127     } 
     128  } 
    123129} 
    124130 
    … …  
    141147void Add_NameOfModuleUsed_1(char *name) 
    142148{ 
    143     listusemodule *newmodule; 
    144     listusemodule *parcours; 
    145     int out; 
    146  
    147     newmodule = (listusemodule*) calloc(1, sizeof(listusemodule)); 
    148     strcpy(newmodule->u_usemodule, name); 
    149     strcpy(newmodule->u_charusemodule, charusemodule); 
    150     strcpy(newmodule->u_modulename, curmodulename); 
    151     strcpy(newmodule->u_cursubroutine, subroutinename); 
    152     newmodule->u_firstuse = 1 ; 
    153     newmodule->suiv = NULL; 
    154  
    155     if ( List_NameOfModuleUsed == NULL ) 
    156     { 
    157         List_NameOfModuleUsed = newmodule ; 
    158     } 
    159     else 
    160     { 
    161         parcours = List_NameOfModuleUsed; 
    162         while ( parcours && newmodule->u_firstuse ) 
    163         { 
    164             if ( !strcasecmp(name,parcours->u_usemodule) ) 
    165             { 
    166                 newmodule->u_firstuse = 0 ; 
    167             } 
    168             parcours = parcours->suiv; 
    169         } 
    170         /* we can not add the same module twice for the same subroutine           */ 
    171         parcours = List_NameOfModuleUsed; 
    172         out = 0 ; 
    173         while ( parcours && out == 0 ) 
    174         { 
    175             if ( !strcasecmp(name,parcours->u_usemodule) && 
    176                  !strcasecmp(subroutinename,parcours->u_cursubroutine) ) 
    177             { 
    178                 out = 1 ; 
    179                 free(newmodule); 
    180             } 
    181             else 
    182                 parcours = parcours->suiv; 
    183         } 
    184         if ( out == 0 ) 
    185         { 
    186             newmodule->suiv = List_NameOfModuleUsed; 
    187             List_NameOfModuleUsed = newmodule; 
    188         } 
    189     } 
    190 } 
     149  listusemodule *newmodule; 
     150  listusemodule *parcours; 
     151  int out; 
     152 
     153  if ( firstpass == 1 ) 
     154  { 
     155     newmodule =(listusemodule *)malloc(sizeof(listusemodule)); 
     156     strcpy(newmodule->u_usemodule,name); 
     157     Save_Length(name,16); 
     158     strcpy(newmodule->u_charusemodule,charusemodule); 
     159     Save_Length(charusemodule,17); 
     160     strcpy(newmodule->u_modulename,curmodulename); 
     161     Save_Length(curmodulename,19); 
     162     strcpy(newmodule->u_cursubroutine,subroutinename); 
     163     Save_Length(subroutinename,18); 
     164     newmodule->u_firstuse = 1 ; 
     165     newmodule->suiv = NULL; 
     166 
     167     if ( !List_NameOfModuleUsed) 
     168     { 
     169         List_NameOfModuleUsed = newmodule ; 
     170     } 
     171     else 
     172     { 
     173    parcours = List_NameOfModuleUsed; 
     174    while ( parcours && newmodule->u_firstuse == 1 ) 
     175    { 
     176       if ( !strcasecmp(name,parcours->u_usemodule) ) 
     177       { 
     178          newmodule->u_firstuse = 0 ; 
     179       } 
     180       parcours=parcours->suiv; 
     181    } 
     182    /* we can not add the same module twice for the same subroutine           */ 
     183    parcours = List_NameOfModuleUsed; 
     184    out = 0 ; 
     185    while ( parcours && out == 0 ) 
     186    { 
     187       if ( !strcasecmp(name,parcours->u_usemodule) && 
     188            !strcasecmp(subroutinename,parcours->u_cursubroutine) 
     189           ) 
     190       { 
     191          out = 1 ; 
     192          free(newmodule); 
     193       } 
     194       else parcours=parcours->suiv; 
     195    } 
     196    if ( out == 0 ) 
     197    { 
     198       newmodule->suiv = List_NameOfModuleUsed; 
     199       List_NameOfModuleUsed = newmodule; 
     200    } 
     201  } 
     202  } 
     203} 
     204 
    191205 
    192206/******************************************************************************/ 
    … …  
    206220/*                                                                            */ 
    207221/******************************************************************************/ 
    208 void Addmoduletothelist(const char *name) 
    209 { 
    210     listusemodule *newmodule; 
    211     listusemodule *parcours; 
    212     int out; 
    213  
    214     newmodule = (listusemodule*) calloc(1,sizeof(listusemodule)); 
    215     strcpy(newmodule->u_usemodule, name); 
    216     strcpy(newmodule->u_charusemodule, charusemodule); 
    217     strcpy(newmodule->u_cursubroutine, subroutinename); 
    218     newmodule->u_firstuse = 1 ; 
    219     newmodule->suiv = NULL; 
    220  
    221     if ( !List_NameOfModuleUsed ) 
    222     { 
    223         List_NameOfModuleUsed = newmodule ; 
    224     } 
    225     else 
    226     { 
    227         parcours = List_NameOfModuleUsed; 
    228         while ( parcours && newmodule->u_firstuse == 1 ) 
    229         { 
    230             if ( !strcasecmp(name,parcours->u_usemodule) ) 
    231             { 
    232                 newmodule->u_firstuse = 0 ; 
    233             } 
    234             parcours=parcours->suiv; 
    235         } 
    236         /* we can not add the same module twice for the same subroutine           */ 
    237         parcours = List_NameOfModuleUsed; 
    238         out = 0 ; 
    239         while ( parcours && out == 0 ) 
    240         { 
    241             if ( !strcasecmp(name,parcours->u_usemodule) && 
    242                  !strcasecmp(subroutinename,parcours->u_cursubroutine) ) 
    243             { 
    244                 out = 1 ; 
    245                 free(newmodule); 
    246             } 
    247             else 
    248                 parcours=parcours->suiv; 
    249         } 
    250         if ( out == 0 ) 
    251         { 
    252             newmodule->suiv = List_NameOfModuleUsed; 
    253             List_NameOfModuleUsed = newmodule; 
    254         } 
    255     } 
     222void Addmoduletothelist(char *name) 
     223{ 
     224  listusemodule *newmodule; 
     225  listusemodule *parcours; 
     226  int out; 
     227 
     228     newmodule =(listusemodule *)malloc(sizeof(listusemodule)); 
     229     strcpy(newmodule->u_usemodule,name); 
     230     Save_Length(name,16); 
     231     strcpy(newmodule->u_charusemodule,charusemodule); 
     232     Save_Length(charusemodule,17); 
     233     strcpy(newmodule->u_cursubroutine,subroutinename); 
     234     Save_Length(subroutinename,18); 
     235     newmodule->u_firstuse = 1 ; 
     236     newmodule->suiv = NULL; 
     237 
     238     if ( !List_NameOfModuleUsed) 
     239     { 
     240         List_NameOfModuleUsed = newmodule ; 
     241     } 
     242     else 
     243     { 
     244    parcours = List_NameOfModuleUsed; 
     245    while ( parcours && newmodule->u_firstuse == 1 ) 
     246    { 
     247       if ( !strcasecmp(name,parcours->u_usemodule) ) 
     248       { 
     249          newmodule->u_firstuse = 0 ; 
     250       } 
     251       parcours=parcours->suiv; 
     252    } 
     253    /* we can not add the same module twice for the same subroutine           */ 
     254    parcours = List_NameOfModuleUsed; 
     255    out = 0 ; 
     256    while ( parcours && out == 0 ) 
     257    { 
     258       if ( !strcasecmp(name,parcours->u_usemodule) && 
     259            !strcasecmp(subroutinename,parcours->u_cursubroutine) 
     260           ) 
     261       { 
     262          out = 1 ; 
     263          free(newmodule); 
     264       } 
     265       else parcours=parcours->suiv; 
     266    } 
     267    if ( out == 0 ) 
     268    { 
     269       newmodule->suiv = List_NameOfModuleUsed; 
     270       List_NameOfModuleUsed = newmodule; 
     271    } 
     272  } 
    256273} 
    257274 
    … …  
    264281/*                                                                            */ 
    265282/******************************************************************************/ 
    266 void WriteUsemoduleDeclaration(const char *cursubroutinename) 
    267 { 
    268     listusemodule     *newmodule; 
    269     listvarpointtovar *pointtmp; 
    270     long int          fictifpos; 
    271     int               findcoupled; 
    272  
    273     fprintf(fortran_out,"\n"); 
    274     newmodule = List_NameOfModuleUsed; 
    275  
    276     while ( newmodule ) 
    277     { 
    278         if ( !strcasecmp(newmodule->u_cursubroutine, cursubroutinename) ) 
    279         { 
    280             if (strcmp(newmodule->u_charusemodule,"")) 
    281             { 
    282 /* 
    283                 findcoupled = 0; 
    284                 pointtmp = List_CouplePointed_Var; 
    285                 while(pointtmp) 
    286                 { 
    287                     if ((!strcasecmp(pointtmp->t_usemodule, newmodule->u_charusemodule)) && \ 
    288                         (!strcasecmp(pointtmp->t_cursubroutine, cursubroutinename))) 
    289                     { 
    290                         fictifpos = setposcur(); 
    291                         variableisglobalinmodule(pointtmp->t_couple,newmodule->u_charusemodule,fortran_out,fictifpos); 
    292                         findcoupled = 1; 
    293                     } 
    294                     pointtmp=pointtmp->suiv; 
    295                 } 
    296                 if (findcoupled == 0)   fprintf(fortran_out,"      use %s\n",newmodule->u_charusemodule); 
    297 */ 
    298                 fprintf(fortran_out,"      use %s\n", newmodule->u_charusemodule); 
    299             } 
    300         } 
     283void WriteUsemoduleDeclaration(char *cursubroutinename) 
     284{ 
     285  listusemodule *newmodule; 
     286   
     287 
     288  newmodule = List_NameOfModuleUsed; 
     289  fprintf(fortranout,"\n"); 
     290 
     291  while ( newmodule ) 
     292  { 
     293     if ( !strcasecmp(newmodule->u_cursubroutine,cursubroutinename) ) 
     294     { 
     295     if (strcmp(newmodule->u_charusemodule,"")) 
     296     { 
     297             fprintf(fortranout,"      USE %s \n" 
     298                                                   ,newmodule->u_charusemodule); 
     299     } 
     300     } 
    301301        newmodule = newmodule ->suiv; 
    302     } 
    303 } 
     302  } 
     303} 
Note: See TracChangeset for help on using the changeset viewer.