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 5989 for branches/2014/dev_r4650_UKMO10_Tidally_Meaned_Diagnostics/NEMOGCM/EXTERNAL/AGRIF/LIB/WorkWithlistofmodulebysubroutine.c – NEMO

Ignore:
Timestamp:
2015-12-03T09:10:32+01:00 (8 years ago)
Author:
deazer
Message:

Merging TMB and 25h diagnostics to head of trunk
added brief documentation

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/2014/dev_r4650_UKMO10_Tidally_Meaned_Diagnostics/NEMOGCM/EXTERNAL/AGRIF/LIB/WorkWithlistofmodulebysubroutine.c

    r2715 r5989  
    6161           List_ModuleUsed_Var = Readthedependfile 
    6262                               (tmplistmodule->u_usemodule,List_ModuleUsed_Var); 
    63          printf("PPPPPPPPPPPPPP\n"); 
    6463           List_GlobParamModuleUsed_Var = ReaddependParameterList 
    6564                      (tmplistmodule->u_usemodule,List_GlobParamModuleUsed_Var); 
    … …  
    7675/******************************************************************************/ 
    7776/******************************************************************************/ 
    78 void  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      { 
     77void 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    { 
    9089        Readthedependlistofmoduleused(tmplistmodule->u_usemodule); 
    9190        while( tmpuselocallist ) 
    9291        { 
    93            Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
    94            tmplistmodule1 = tmpuselocallist->suiv; 
    95            free(tmpuselocallist); 
    96            tmpuselocallist = tmplistmodule1; 
     92            Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
     93            save_list = tmpuselocallist->suiv; 
     94            free(tmpuselocallist); 
     95            tmpuselocallist = save_list; 
    9796        } 
    9897        tmplistmodule = tmplistmodule->suiv; 
    99      } 
    100  
    101      tmplistmodule = listofmoduletmp; 
    102      while ( tmplistmodule ) 
    103      { 
     98    } 
     99    tmplistmodule = listofmoduletmp; 
     100    while ( tmplistmodule ) 
     101    { 
    104102        Readthedependlistofmoduleused(tmplistmodule->u_usemodule); 
    105103        while( tmpuselocallist ) 
    106104        { 
    107            Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
    108            tmplistmodule1 = tmpuselocallist->suiv; 
    109            free(tmpuselocallist); 
    110            tmpuselocallist = tmplistmodule1; 
     105            Addmoduletothelisttmp(tmpuselocallist->u_usemodule); 
     106            save_list = tmpuselocallist->suiv; 
     107            free(tmpuselocallist); 
     108            tmpuselocallist = save_list; 
    111109        } 
    112110        tmplistmodule = tmplistmodule->suiv; 
    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); 
     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); 
    126121        tmplistmodule = tmplistmodule->suiv; 
    127      } 
    128   } 
     122    } 
    129123} 
    130124 
    … …  
    147141void Add_NameOfModuleUsed_1(char *name) 
    148142{ 
    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  
     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} 
    205191 
    206192/******************************************************************************/ 
    … …  
    220206/*                                                                            */ 
    221207/******************************************************************************/ 
    222 void 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   } 
     208void 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    } 
    273256} 
    274257 
    … …  
    281264/*                                                                            */ 
    282265/******************************************************************************/ 
    283 void 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      } 
     266void 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        } 
    301301        newmodule = newmodule ->suiv; 
    302   } 
    303 } 
     302    } 
     303} 
Note: See TracChangeset for help on using the changeset viewer.