Date: 2016-07-24T16:48:07+00:00

Actual source code: str.c
petsc-3.7.3 2016-07-24
Report Typos and Errors

      2: /*
      3:     We define the string operations here. The reason we just do not use
      4:   the standard string routines in the PETSc code is that on some machines
      5:   they are broken or have the wrong prototypes.

      7: */
      8: #include <petscsys.h>                   /*I  "petscsys.h"   I*/
      9: #if defined(PETSC_HAVE_STRING_H)
     10: #include <string.h>             /* strstr */
     11: #endif
     12: #if defined(PETSC_HAVE_STRINGS_H)
     13: #  include <strings.h>          /* strcasecmp */
     14: #endif

     18: /*@C
     19:    PetscStrToArray - Separates a string by a charactor (for example ' ' or '\n') and creates an array of strings

     21:    Not Collective

     23:    Input Parameters:
     24: +  s - pointer to string
     25: -  sp - separator charactor

     27:    Output Parameter:
     28: +   argc - the number of entries in the array
     29: -   args - an array of the entries with a null at the end

     31:    Level: intermediate

     33:    Notes: this may be called before PetscInitialize() or after PetscFinalize()

     35:    Not for use in Fortran

     37:    Developer Notes: Using raw malloc() and does not call error handlers since this may be used before PETSc is initialized. Used
     38:      to generate argc, args arguments passed to MPI_Init()

     40: .seealso: PetscStrToArrayDestroy(), PetscToken, PetscTokenCreate()

     42: @*/
     43: PetscErrorCode  PetscStrToArray(const char s[],char sp,int *argc,char ***args)
     44: {
     45:   int       i,j,n,*lens,cnt = 0;
     46:   PetscBool flg = PETSC_FALSE;

     48:   if (!s) n = 0;
     49:   else    n = strlen(s);
     50:   *argc = 0;
     51:   *args = NULL;
     52:   if (!n) {
     53:     return(0);
     54:   }
     55:   for (i=0; i<n; i++) {
     56:     if (s[i] != sp) break;
     57:   }
     58:   for (;i<n+1; i++) {
     59:     if ((s[i] == sp || s[i] == 0) && !flg) {flg = PETSC_TRUE; (*argc)++;}
     60:     else if (s[i] != sp) {flg = PETSC_FALSE;}
     61:   }
     62:   if (!*argc) { /* string only has separator characters */
     63:     return(0);
     64:   }
     65:   (*args) = (char**) malloc(((*argc)+1)*sizeof(char*)); if (!*args) return PETSC_ERR_MEM;
     66:   lens    = (int*) malloc((*argc)*sizeof(int)); if (!lens) return PETSC_ERR_MEM;
     67:   for (i=0; i<*argc; i++) lens[i] = 0;

     69:   *argc = 0;
     70:   for (i=0; i<n; i++) {
     71:     if (s[i] != sp) break;
     72:   }
     73:   for (;i<n+1; i++) {
     74:     if ((s[i] == sp || s[i] == 0) && !flg) {flg = PETSC_TRUE; (*argc)++;}
     75:     else if (s[i] != sp) {lens[*argc]++;flg = PETSC_FALSE;}
     76:   }

     78:   for (i=0; i<*argc; i++) {
     79:     (*args)[i] = (char*) malloc((lens[i]+1)*sizeof(char));
     80:     if (!(*args)[i]) {
     81:       free(lens);
     82:       for (j=0; j<i; j++) free((*args)[j]);
     83:       free(*args);
     84:       return PETSC_ERR_MEM;
     85:     }
     86:   }
     87:   free(lens);
     88:   (*args)[*argc] = 0;

     90:   *argc = 0;
     91:   for (i=0; i<n; i++) {
     92:     if (s[i] != sp) break;
     93:   }
     94:   for (;i<n+1; i++) {
     95:     if ((s[i] == sp || s[i] == 0) && !flg) {flg = PETSC_TRUE; (*args)[*argc][cnt++] = 0; (*argc)++; cnt = 0;}
     96:     else if (s[i] != sp && s[i] != 0) {(*args)[*argc][cnt++] = s[i]; flg = PETSC_FALSE;}
     97:   }
     98:   return 0;
     99: }

    103: /*@C
    104:    PetscStrToArrayDestroy - Frees array created with PetscStrToArray().

    106:    Not Collective

    108:    Output Parameters:
    109: +  argc - the number of arguments
    110: -  args - the array of arguments

    112:    Level: intermediate

    114:    Concepts: command line arguments

    116:    Notes: This may be called before PetscInitialize() or after PetscFinalize()

    118:    Not for use in Fortran

    120: .seealso: PetscStrToArray()

    122: @*/
    123: PetscErrorCode  PetscStrToArrayDestroy(int argc,char **args)
    124: {
    125:   PetscInt i;

    127:   for (i=0; i<argc; i++) free(args[i]);
    128:   if (args) free(args);
    129:   return 0;
    130: }

    134: /*@C
    135:    PetscStrlen - Gets length of a string

    137:    Not Collective

    139:    Input Parameters:
    140: .  s - pointer to string

    142:    Output Parameter:
    143: .  len - length in bytes

    145:    Level: intermediate

    147:    Note:
    148:    This routine is analogous to strlen().

    150:    Null string returns a length of zero

    152:    Not for use in Fortran

    154:   Concepts: string length

    156: @*/
    157: PetscErrorCode  PetscStrlen(const char s[],size_t *len)
    158: {
    160:   if (!s) *len = 0;
    161:   else    *len = strlen(s);
    162:   return(0);
    163: }

    167: /*@C
    168:    PetscStrallocpy - Allocates space to hold a copy of a string then copies the string

    170:    Not Collective

    172:    Input Parameters:
    173: .  s - pointer to string

    175:    Output Parameter:
    176: .  t - the copied string

    178:    Level: intermediate

    180:    Note:
    181:       Null string returns a new null string

    183:       Not for use in Fortran

    185:   Concepts: string copy

    187: @*/
    188: PetscErrorCode  PetscStrallocpy(const char s[],char *t[])
    189: {
    191:   size_t         len;
    192:   char           *tmp = 0;

    195:   if (s) {
    196:     PetscStrlen(s,&len);
    197:     PetscMalloc1(1+len,&tmp);
    198:     PetscStrcpy(tmp,s);
    199:   }
    200:   *t = tmp;
    201:   return(0);
    202: }

    206: /*@C
    207:    PetscStrArrayallocpy - Allocates space to hold a copy of an array of strings then copies the strings

    209:    Not Collective

    211:    Input Parameters:
    212: .  s - pointer to array of strings (final string is a null)

    214:    Output Parameter:
    215: .  t - the copied array string

    217:    Level: intermediate

    219:    Note:
    220:       Not for use in Fortran

    222:   Concepts: string copy

    224: .seealso: PetscStrallocpy() PetscStrArrayDestroy()

    226: @*/
    227: PetscErrorCode  PetscStrArrayallocpy(const char *const *list,char ***t)
    228: {
    230:   PetscInt       i,n = 0;

    233:   while (list[n++]) ;
    234:   PetscMalloc1(n+1,t);
    235:   for (i=0; i<n; i++) {
    236:     PetscStrallocpy(list[i],(*t)+i);
    237:   }
    238:   (*t)[n] = NULL;
    239:   return(0);
    240: }

    244: /*@C
    245:    PetscStrArrayDestroy - Frees array of strings created with PetscStrArrayallocpy().

    247:    Not Collective

    249:    Output Parameters:
    250: .   list - array of strings

    252:    Level: intermediate

    254:    Concepts: command line arguments

    256:    Notes: Not for use in Fortran

    258: .seealso: PetscStrArrayallocpy()

    260: @*/
    261: PetscErrorCode PetscStrArrayDestroy(char ***list)
    262: {
    263:   PetscInt       n = 0;

    267:   if (!*list) return(0);
    268:   while ((*list)[n]) {
    269:     PetscFree((*list)[n]);
    270:     n++;
    271:   }
    272:   PetscFree(*list);
    273:   return(0);
    274: }

    278: /*@C
    279:    PetscStrNArrayallocpy - Allocates space to hold a copy of an array of strings then copies the strings

    281:    Not Collective

    283:    Input Parameters:
    284: +  n - the number of string entries
    285: -  s - pointer to array of strings

    287:    Output Parameter:
    288: .  t - the copied array string

    290:    Level: intermediate

    292:    Note:
    293:       Not for use in Fortran

    295:   Concepts: string copy

    297: .seealso: PetscStrallocpy() PetscStrArrayDestroy()

    299: @*/
    300: PetscErrorCode  PetscStrNArrayallocpy(PetscInt n,const char *const *list,char ***t)
    301: {
    303:   PetscInt       i;

    306:   PetscMalloc1(n,t);
    307:   for (i=0; i<n; i++) {
    308:     PetscStrallocpy(list[i],(*t)+i);
    309:   }
    310:   return(0);
    311: }

    315: /*@C
    316:    PetscStrNArrayDestroy - Frees array of strings created with PetscStrArrayallocpy().

    318:    Not Collective

    320:    Output Parameters:
    321: +   n - number of string entries
    322: -   list - array of strings

    324:    Level: intermediate

    326:    Notes: Not for use in Fortran

    328: .seealso: PetscStrArrayallocpy()

    330: @*/
    331: PetscErrorCode PetscStrNArrayDestroy(PetscInt n,char ***list)
    332: {
    334:   PetscInt       i;

    337:   if (!*list) return(0);
    338:   for (i=0; i<n; i++){
    339:     PetscFree((*list)[i]);
    340:   }
    341:   PetscFree(*list);
    342:   return(0);
    343: }

    347: /*@C
    348:    PetscStrcpy - Copies a string

    350:    Not Collective

    352:    Input Parameters:
    353: .  t - pointer to string

    355:    Output Parameter:
    356: .  s - the copied string

    358:    Level: intermediate

    360:    Notes:
    361:      Null string returns a string starting with zero

    363:      Not for use in Fortran

    365:   Concepts: string copy

    367: .seealso: PetscStrncpy(), PetscStrcat(), PetscStrncat()

    369: @*/

    371: PetscErrorCode  PetscStrcpy(char s[],const char t[])
    372: {
    374:   if (t && !s) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Trying to copy string into null pointer");
    375:   if (t) strcpy(s,t);
    376:   else if (s) s[0] = 0;
    377:   return(0);
    378: }

    382: /*@C
    383:    PetscStrncpy - Copies a string up to a certain length

    385:    Not Collective

    387:    Input Parameters:
    388: +  t - pointer to string
    389: -  n - the length to copy

    391:    Output Parameter:
    392: .  s - the copied string

    394:    Level: intermediate

    396:    Note:
    397:      Null string returns a string starting with zero

    399:      If the string that is being copied is of length n or larger then the entire string is not
    400:      copied and the file location of s is set to NULL. This is different then the behavior of
    401:      strncpy() which leaves s non-terminated.

    403:   Concepts: string copy

    405: .seealso: PetscStrcpy(), PetscStrcat(), PetscStrncat()

    407: @*/
    408: PetscErrorCode  PetscStrncpy(char s[],const char t[],size_t n)
    409: {
    411:   if (t && !s) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"Trying to copy string into null pointer");
    412:   if (t) {
    413:     if (n > 1) {
    414:       strncpy(s,t,n-1);
    415:       s[n-1] = '\0';
    416:     } else {
    417:       s[0] = '\0';
    418:     }
    419:   } else if (s) s[0] = 0;
    420:   return(0);
    421: }

    425: /*@C
    426:    PetscStrcat - Concatenates a string onto a given string

    428:    Not Collective

    430:    Input Parameters:
    431: +  s - string to be added to
    432: -  t - pointer to string to be added to end

    434:    Level: intermediate

    436:    Notes: Not for use in Fortran

    438:   Concepts: string copy

    440: .seealso: PetscStrcpy(), PetscStrncpy(), PetscStrncat()

    442: @*/
    443: PetscErrorCode  PetscStrcat(char s[],const char t[])
    444: {
    446:   if (!t) return(0);
    447:   strcat(s,t);
    448:   return(0);
    449: }

    453: /*@C
    454:    PetscStrncat - Concatenates a string onto a given string, up to a given length

    456:    Not Collective

    458:    Input Parameters:
    459: +  s - pointer to string to be added to end
    460: .  t - string to be added to
    461: .  n - maximum length to copy

    463:    Level: intermediate

    465:   Notes:    Not for use in Fortran

    467:   Concepts: string copy

    469: .seealso: PetscStrcpy(), PetscStrncpy(), PetscStrcat()

    471: @*/
    472: PetscErrorCode  PetscStrncat(char s[],const char t[],size_t n)
    473: {
    475:   strncat(s,t,n);
    476:   return(0);
    477: }

    481: /*

    484:    Will be removed once we eliminate the __FUNCT__ paradigm
    485: */
    486: void  PetscStrcmpNoError(const char a[],const char b[],PetscBool  *flg)
    487: {
    488:   int c;

    490:   if (!a && !b)      *flg = PETSC_TRUE;
    491:   else if (!a || !b) *flg = PETSC_FALSE;
    492:   else {
    493:     c = strcmp(a,b);
    494:     if (c) *flg = PETSC_FALSE;
    495:     else   *flg = PETSC_TRUE;
    496:   }
    497: }

    501: /*@C
    502:    PetscStrcmp - Compares two strings,

    504:    Not Collective

    506:    Input Parameters:
    507: +  a - pointer to string first string
    508: -  b - pointer to second string

    510:    Output Parameter:
    511: .  flg - PETSC_TRUE if the two strings are equal

    513:    Level: intermediate

    515:    Notes:    Not for use in Fortran

    517: .seealso: PetscStrgrt(), PetscStrncmp(), PetscStrcasecmp()

    519: @*/
    520: PetscErrorCode  PetscStrcmp(const char a[],const char b[],PetscBool  *flg)
    521: {
    522:   int c;

    525:   if (!a && !b)      *flg = PETSC_TRUE;
    526:   else if (!a || !b) *flg = PETSC_FALSE;
    527:   else {
    528:     c = strcmp(a,b);
    529:     if (c) *flg = PETSC_FALSE;
    530:     else   *flg = PETSC_TRUE;
    531:   }
    532:   return(0);
    533: }

    537: /*@C
    538:    PetscStrgrt - If first string is greater than the second

    540:    Not Collective

    542:    Input Parameters:
    543: +  a - pointer to first string
    544: -  b - pointer to second string

    546:    Output Parameter:
    547: .  flg - if the first string is greater

    549:    Notes:
    550:     Null arguments are ok, a null string is considered smaller than
    551:     all others

    553:    Not for use in Fortran

    555:    Level: intermediate

    557: .seealso: PetscStrcmp(), PetscStrncmp(), PetscStrcasecmp()

    559: @*/
    560: PetscErrorCode  PetscStrgrt(const char a[],const char b[],PetscBool  *t)
    561: {
    562:   int c;

    565:   if (!a && !b) *t = PETSC_FALSE;
    566:   else if (a && !b) *t = PETSC_TRUE;
    567:   else if (!a && b) *t = PETSC_FALSE;
    568:   else {
    569:     c = strcmp(a,b);
    570:     if (c > 0) *t = PETSC_TRUE;
    571:     else       *t = PETSC_FALSE;
    572:   }
    573:   return(0);
    574: }

    578: /*@C
    579:    PetscStrcasecmp - Returns true if the two strings are the same
    580:      except possibly for case.

    582:    Not Collective

    584:    Input Parameters:
    585: +  a - pointer to first string
    586: -  b - pointer to second string

    588:    Output Parameter:
    589: .  flg - if the two strings are the same

    591:    Notes:
    592:     Null arguments are ok

    594:    Not for use in Fortran

    596:    Level: intermediate

    598: .seealso: PetscStrcmp(), PetscStrncmp(), PetscStrgrt()

    600: @*/
    601: PetscErrorCode  PetscStrcasecmp(const char a[],const char b[],PetscBool  *t)
    602: {
    603:   int c;

    606:   if (!a && !b) c = 0;
    607:   else if (!a || !b) c = 1;
    608: #if defined(PETSC_HAVE_STRCASECMP)
    609:   else c = strcasecmp(a,b);
    610: #elif defined(PETSC_HAVE_STRICMP)
    611:   else c = stricmp(a,b);
    612: #else
    613:   else {
    614:     char           *aa,*bb;
    616:     PetscStrallocpy(a,&aa);
    617:     PetscStrallocpy(b,&bb);
    618:     PetscStrtolower(aa);
    619:     PetscStrtolower(bb);
    620:     PetscStrcmp(aa,bb,t);
    621:     PetscFree(aa);
    622:     PetscFree(bb);
    623:     return(0);
    624:   }
    625: #endif
    626:   if (!c) *t = PETSC_TRUE;
    627:   else    *t = PETSC_FALSE;
    628:   return(0);
    629: }

    635: /*@C
    636:    PetscStrncmp - Compares two strings, up to a certain length

    638:    Not Collective

    640:    Input Parameters:
    641: +  a - pointer to first string
    642: .  b - pointer to second string
    643: -  n - length to compare up to

    645:    Output Parameter:
    646: .  t - if the two strings are equal

    648:    Level: intermediate

    650:    Notes:    Not for use in Fortran

    652: .seealso: PetscStrgrt(), PetscStrcmp(), PetscStrcasecmp()

    654: @*/
    655: PetscErrorCode  PetscStrncmp(const char a[],const char b[],size_t n,PetscBool  *t)
    656: {
    657:   int c;

    660:   c = strncmp(a,b,n);
    661:   if (!c) *t = PETSC_TRUE;
    662:   else    *t = PETSC_FALSE;
    663:   return(0);
    664: }

    668: /*@C
    669:    PetscStrchr - Locates first occurance of a character in a string

    671:    Not Collective

    673:    Input Parameters:
    674: +  a - pointer to string
    675: -  b - character

    677:    Output Parameter:
    678: .  c - location of occurance, NULL if not found

    680:    Level: intermediate

    682:    Notes:    Not for use in Fortran

    684: @*/
    685: PetscErrorCode  PetscStrchr(const char a[],char b,char *c[])
    686: {
    688:   *c = (char*)strchr(a,b);
    689:   return(0);
    690: }

    694: /*@C
    695:    PetscStrrchr - Locates one location past the last occurance of a character in a string,
    696:       if the character is not found then returns entire string

    698:    Not Collective

    700:    Input Parameters:
    701: +  a - pointer to string
    702: -  b - character

    704:    Output Parameter:
    705: .  tmp - location of occurance, a if not found

    707:    Level: intermediate

    709:    Notes:    Not for use in Fortran

    711: @*/
    712: PetscErrorCode  PetscStrrchr(const char a[],char b,char *tmp[])
    713: {
    715:   *tmp = (char*)strrchr(a,b);
    716:   if (!*tmp) *tmp = (char*)a;
    717:   else *tmp = *tmp + 1;
    718:   return(0);
    719: }

    723: /*@C
    724:    PetscStrtolower - Converts string to lower case

    726:    Not Collective

    728:    Input Parameters:
    729: .  a - pointer to string

    731:    Level: intermediate

    733:    Notes:    Not for use in Fortran

    735: @*/
    736: PetscErrorCode  PetscStrtolower(char a[])
    737: {
    739:   while (*a) {
    740:     if (*a >= 'A' && *a <= 'Z') *a += 'a' - 'A';
    741:     a++;
    742:   }
    743:   return(0);
    744: }

    748: /*@C
    749:    PetscStrtolower - Converts string to upper case

    751:    Not Collective

    753:    Input Parameters:
    754: .  a - pointer to string

    756:    Level: intermediate

    758:    Notes:    Not for use in Fortran

    760: @*/
    761: PetscErrorCode  PetscStrtoupper(char a[])
    762: {
    764:   while (*a) {
    765:     if (*a >= 'a' && *a <= 'z') *a += 'A' - 'a';
    766:     a++;
    767:   }
    768:   return(0);
    769: }

    773: /*@C
    774:    PetscStrendswith - Determines if a string ends with a certain string

    776:    Not Collective

    778:    Input Parameters:
    779: +  a - pointer to string
    780: -  b - string to endwith

    782:    Output Parameter:
    783: .  flg - PETSC_TRUE or PETSC_FALSE

    785:    Notes:     Not for use in Fortran

    787:    Level: intermediate

    789: @*/
    790: PetscErrorCode  PetscStrendswith(const char a[],const char b[],PetscBool *flg)
    791: {
    792:   char           *test;
    794:   size_t         na,nb;

    797:   *flg = PETSC_FALSE;
    798:   PetscStrrstr(a,b,&test);
    799:   if (test) {
    800:     PetscStrlen(a,&na);
    801:     PetscStrlen(b,&nb);
    802:     if (a+na-nb == test) *flg = PETSC_TRUE;
    803:   }
    804:   return(0);
    805: }

    809: /*@C
    810:    PetscStrbeginswith - Determines if a string begins with a certain string

    812:    Not Collective

    814:    Input Parameters:
    815: +  a - pointer to string
    816: -  b - string to beginwith

    818:    Output Parameter:
    819: .  flg - PETSC_TRUE or PETSC_FALSE

    821:    Notes:     Not for use in Fortran

    823:    Level: intermediate

    825: @*/
    826: PetscErrorCode  PetscStrbeginswith(const char a[],const char b[],PetscBool *flg)
    827: {
    828:   char           *test;

    832:   *flg = PETSC_FALSE;
    833:   PetscStrrstr(a,b,&test);
    834:   if (test && (test == a)) *flg = PETSC_TRUE;
    835:   return(0);
    836: }

    841: /*@C
    842:    PetscStrendswithwhich - Determines if a string ends with one of several possible strings

    844:    Not Collective

    846:    Input Parameters:
    847: +  a - pointer to string
    848: -  bs - strings to endwith (last entry must be null)

    850:    Output Parameter:
    851: .  cnt - the index of the string it ends with or 1+the last possible index

    853:    Notes:     Not for use in Fortran

    855:    Level: intermediate

    857: @*/
    858: PetscErrorCode  PetscStrendswithwhich(const char a[],const char *const *bs,PetscInt *cnt)
    859: {
    860:   PetscBool      flg;

    864:   *cnt = 0;
    865:   while (bs[*cnt]) {
    866:     PetscStrendswith(a,bs[*cnt],&flg);
    867:     if (flg) return(0);
    868:     *cnt += 1;
    869:   }
    870:   return(0);
    871: }

    875: /*@C
    876:    PetscStrrstr - Locates last occurance of string in another string

    878:    Not Collective

    880:    Input Parameters:
    881: +  a - pointer to string
    882: -  b - string to find

    884:    Output Parameter:
    885: .  tmp - location of occurance

    887:    Notes:     Not for use in Fortran

    889:    Level: intermediate

    891: @*/
    892: PetscErrorCode  PetscStrrstr(const char a[],const char b[],char *tmp[])
    893: {
    894:   const char *stmp = a, *ltmp = 0;

    897:   while (stmp) {
    898:     stmp = (char*)strstr(stmp,b);
    899:     if (stmp) {ltmp = stmp;stmp++;}
    900:   }
    901:   *tmp = (char*)ltmp;
    902:   return(0);
    903: }

    907: /*@C
    908:    PetscStrstr - Locates first occurance of string in another string

    910:    Not Collective

    912:    Input Parameters:
    913: +  haystack - string to search
    914: -  needle - string to find

    916:    Output Parameter:
    917: .  tmp - location of occurance, is a NULL if the string is not found

    919:    Notes: Not for use in Fortran

    921:    Level: intermediate

    923: @*/
    924: PetscErrorCode  PetscStrstr(const char haystack[],const char needle[],char *tmp[])
    925: {
    927:   *tmp = (char*)strstr(haystack,needle);
    928:   return(0);
    929: }

    931: struct _p_PetscToken {char token;char *array;char *current;};

    935: /*@C
    936:    PetscTokenFind - Locates next "token" in a string

    938:    Not Collective

    940:    Input Parameters:
    941: .  a - pointer to token

    943:    Output Parameter:
    944: .  result - location of occurance, NULL if not found

    946:    Notes:

    948:      This version is different from the system version in that
    949:   it allows you to pass a read-only string into the function.

    951:      This version also treats all characters etc. inside a double quote "
    952:    as a single token.

    954:      For example if the separator character is + and the string is xxxx+y then the first fine will return a pointer to a null terminated xxxx and the
    955:    second will return a null terminated y

    957:      If the separator character is + and the string is xxxx then the first and only token found will be a pointer to a null terminated xxxx

    959:     Not for use in Fortran

    961:    Level: intermediate

    964: .seealso: PetscTokenCreate(), PetscTokenDestroy()
    965: @*/
    966: PetscErrorCode  PetscTokenFind(PetscToken a,char *result[])
    967: {
    968:   char *ptr = a->current,token;

    971:   *result = a->current;
    972:   if (ptr && !*ptr) {*result = 0;return(0);}
    973:   token = a->token;
    974:   if (ptr && (*ptr == '"')) {token = '"';(*result)++;ptr++;}
    975:   while (ptr) {
    976:     if (*ptr == token) {
    977:       *ptr++ = 0;
    978:       while (*ptr == a->token) ptr++;
    979:       a->current = ptr;
    980:       break;
    981:     }
    982:     if (!*ptr) {
    983:       a->current = 0;
    984:       break;
    985:     }
    986:     ptr++;
    987:   }
    988:   return(0);
    989: }

    993: /*@C
    994:    PetscTokenCreate - Creates a PetscToken used to find tokens in a string

    996:    Not Collective

    998:    Input Parameters:
    999: +  string - the string to look in
    1000: -  b - the separator character

    1002:    Output Parameter:
    1003: .  t- the token object

    1005:    Notes:

    1007:      This version is different from the system version in that
    1008:   it allows you to pass a read-only string into the function.

    1010:     Not for use in Fortran

    1012:    Level: intermediate

    1014: .seealso: PetscTokenFind(), PetscTokenDestroy()
    1015: @*/
    1016: PetscErrorCode  PetscTokenCreate(const char a[],const char b,PetscToken *t)
    1017: {

    1021:   PetscNew(t);
    1022:   PetscStrallocpy(a,&(*t)->array);

    1024:   (*t)->current = (*t)->array;
    1025:   (*t)->token   = b;
    1026:   return(0);
    1027: }

    1031: /*@C
    1032:    PetscTokenDestroy - Destroys a PetscToken

    1034:    Not Collective

    1036:    Input Parameters:
    1037: .  a - pointer to token

    1039:    Level: intermediate

    1041:    Notes:     Not for use in Fortran

    1043: .seealso: PetscTokenCreate(), PetscTokenFind()
    1044: @*/
    1045: PetscErrorCode  PetscTokenDestroy(PetscToken *a)
    1046: {

    1050:   if (!*a) return(0);
    1051:   PetscFree((*a)->array);
    1052:   PetscFree(*a);
    1053:   return(0);
    1054: }

    1059: /*@C
    1060:    PetscGetPetscDir - Gets the directory PETSc is installed in

    1062:    Not Collective

    1064:    Output Parameter:
    1065: .  dir - the directory

    1067:    Level: developer

    1069:    Notes: Not for use in Fortran

    1071: @*/
    1072: PetscErrorCode  PetscGetPetscDir(const char *dir[])
    1073: {
    1075:   *dir = PETSC_DIR;
    1076:   return(0);
    1077: }

    1081: /*@C
    1082:    PetscStrreplace - Replaces substrings in string with other substrings

    1084:    Not Collective

    1086:    Input Parameters:
    1087: +   comm - MPI_Comm of processors that are processing the string
    1088: .   aa - the string to look in
    1089: .   b - the resulting copy of a with replaced strings (b can be the same as a)
    1090: -   len - the length of b

    1092:    Notes:
    1093:       Replaces   ${PETSC_ARCH},${PETSC_DIR},${PETSC_LIB_DIR},${DISPLAY},
    1094:       ${HOMEDIRECTORY},${WORKINGDIRECTORY},${USERNAME}, ${HOSTNAME} with appropriate values
    1095:       as well as any environmental variables.

    1097:       PETSC_LIB_DIR uses the environmental variable if it exists. PETSC_ARCH and PETSC_DIR use what
    1098:       PETSc was built with and do not use environmental variables.

    1100:       Not for use in Fortran

    1102:    Level: intermediate

    1104: @*/
    1105: PetscErrorCode  PetscStrreplace(MPI_Comm comm,const char aa[],char b[],size_t len)
    1106: {
    1108:   int            i = 0;
    1109:   size_t         l,l1,l2,l3;
    1110:   char           *work,*par,*epar,env[1024],*tfree,*a = (char*)aa;
    1111:   const char     *s[] = {"${PETSC_ARCH}","${PETSC_DIR}","${PETSC_LIB_DIR}","${DISPLAY}","${HOMEDIRECTORY}","${WORKINGDIRECTORY}","${USERNAME}","${HOSTNAME}",0};
    1112:   const char     *r[] = {0,0,0,0,0,0,0,0,0};
    1113:   PetscBool      flag;

    1116:   if (!a || !b) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_NULL,"a and b strings must be nonnull");
    1117:   if (aa == b) {
    1118:     PetscStrallocpy(aa,(char**)&a);
    1119:   }
    1120:   PetscMalloc1(len,&work);

    1122:   /* get values for replaced variables */
    1123:   PetscStrallocpy(PETSC_ARCH,(char**)&r[0]);
    1124:   PetscStrallocpy(PETSC_DIR,(char**)&r[1]);
    1125:   PetscStrallocpy(PETSC_LIB_DIR,(char**)&r[2]);
    1126:   PetscMalloc1(256,&r[3]);
    1127:   PetscMalloc1(PETSC_MAX_PATH_LEN,&r[4]);
    1128:   PetscMalloc1(PETSC_MAX_PATH_LEN,&r[5]);
    1129:   PetscMalloc1(256,&r[6]);
    1130:   PetscMalloc1(256,&r[7]);
    1131:   PetscGetDisplay((char*)r[3],256);
    1132:   PetscGetHomeDirectory((char*)r[4],PETSC_MAX_PATH_LEN);
    1133:   PetscGetWorkingDirectory((char*)r[5],PETSC_MAX_PATH_LEN);
    1134:   PetscGetUserName((char*)r[6],256);
    1135:   PetscGetHostName((char*)r[7],256);

    1137:   /* replace that are in environment */
    1138:   PetscOptionsGetenv(comm,"PETSC_LIB_DIR",env,1024,&flag);
    1139:   if (flag) {
    1140:     PetscFree(r[2]);
    1141:     PetscStrallocpy(env,(char**)&r[2]);
    1142:   }

    1144:   /* replace the requested strings */
    1145:   PetscStrncpy(b,a,len);
    1146:   while (s[i]) {
    1147:     PetscStrlen(s[i],&l);
    1148:     PetscStrstr(b,s[i],&par);
    1149:     while (par) {
    1150:       *par =  0;
    1151:       par += l;

    1153:       PetscStrlen(b,&l1);
    1154:       PetscStrlen(r[i],&l2);
    1155:       PetscStrlen(par,&l3);
    1156:       if (l1 + l2 + l3 >= len) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"b len is not long enough to hold new values");
    1157:       PetscStrcpy(work,b);
    1158:       PetscStrcat(work,r[i]);
    1159:       PetscStrcat(work,par);
    1160:       PetscStrncpy(b,work,len);
    1161:       PetscStrstr(b,s[i],&par);
    1162:     }
    1163:     i++;
    1164:   }
    1165:   i = 0;
    1166:   while (r[i]) {
    1167:     tfree = (char*)r[i];
    1168:     PetscFree(tfree);
    1169:     i++;
    1170:   }

    1172:   /* look for any other ${xxx} strings to replace from environmental variables */
    1173:   PetscStrstr(b,"${",&par);
    1174:   while (par) {
    1175:     *par  = 0;
    1176:     par  += 2;
    1177:     PetscStrcpy(work,b);
    1178:     PetscStrstr(par,"}",&epar);
    1179:     *epar = 0;
    1180:     epar += 1;
    1181:     PetscOptionsGetenv(comm,par,env,256,&flag);
    1182:     if (!flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Substitution string ${%s} not found as environmental variable",par);
    1183:     PetscStrcat(work,env);
    1184:     PetscStrcat(work,epar);
    1185:     PetscStrcpy(b,work);
    1186:     PetscStrstr(b,"${",&par);
    1187:   }
    1188:   PetscFree(work);
    1189:   if (aa == b) {
    1190:     PetscFree(a);
    1191:   }
    1192:   return(0);
    1193: }

    1197: /*@C
    1198:    PetscEListFind - searches list of strings for given string, using case insensitive matching

    1200:    Not Collective

    1202:    Input Parameters:
    1203: +  n - number of strings in
    1204: .  list - list of strings to search
    1205: -  str - string to look for, empty string "" accepts default (first entry in list)

    1207:    Output Parameters:
    1208: +  value - index of matching string (if found)
    1209: -  found - boolean indicating whether string was found (can be NULL)

    1211:    Notes:
    1212:    Not for use in Fortran

    1214:    Level: advanced
    1215: @*/
    1216: PetscErrorCode PetscEListFind(PetscInt n,const char *const *list,const char *str,PetscInt *value,PetscBool *found)
    1217: {
    1219:   PetscBool matched;
    1220:   PetscInt i;

    1223:   if (found) *found = PETSC_FALSE;
    1224:   for (i=0; i<n; i++) {
    1225:     PetscStrcasecmp(str,list[i],&matched);
    1226:     if (matched || !str[0]) {
    1227:       if (found) *found = PETSC_TRUE;
    1228:       *value = i;
    1229:       break;
    1230:     }
    1231:   }
    1232:   return(0);
    1233: }

    1237: /*@C
    1238:    PetscEListFind - searches enum list of strings for given string, using case insensitive matching

    1240:    Not Collective

    1242:    Input Parameters:
    1243: +  enumlist - list of strings to search, followed by enum name, then enum prefix, then NUL
    1244: -  str - string to look for

    1246:    Output Parameters:
    1247: +  value - index of matching string (if found)
    1248: -  found - boolean indicating whether string was found (can be NULL)

    1250:    Notes:
    1251:    Not for use in Fortran

    1253:    Level: advanced
    1254: @*/
    1255: PetscErrorCode PetscEnumFind(const char *const *enumlist,const char *str,PetscEnum *value,PetscBool *found)
    1256: {
    1258:   PetscInt n = 0,evalue;
    1259:   PetscBool efound;

    1262:   while (enumlist[n++]) if (n > 50) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"List argument appears to be wrong or have more than 50 entries");
    1263:   if (n < 3) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"List argument must have at least two entries: typename and type prefix");
    1264:   n -= 3; /* drop enum name, prefix, and null termination */
    1265:   PetscEListFind(n,enumlist,str,&evalue,&efound);
    1266:   if (efound) *value = (PetscEnum)evalue;
    1267:   if (found) *found = efound;
    1268:   return(0);
    1269: }