/********************************************************************* This file is part of the argtable library. It contains the definitions of the argtable library functions as well as specially formatted comments that constitute the source text for the manual pages pertaining to those functions. Copyright (C) 1998,1999,2001 Stewart Heitmann (sheitmann@users.sourceforge.net) The argtable library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *********************************************************************/ #include #include #include #include #include #include "argtable.h" #define ARGSTRLEN 200 #define NAMESTRING(A) ((A.argname)?(A.argname):(arg_typestr[A.argtype])) #define NULLSAFE(S) ((S)?(S):("")) static const char whitespace[] = " \f\n\r\v\t"; static int arg_convertbool(const char *str) { /************************************************************ Returns 0 if *str satisfies a case-insensitive match on a leading substring of "FALSE", "NO", or "OFF". Leading whitespace is ignored. Returns 1 if *str matches "TRUE", "YES", or "ON". Returns -1 otherwise. Handles str==NULL safely. **************************************************************/ char buff[ARGSTRLEN]; int i,n; /*-- handle NULL str */ if (str==NULL) return -1; /*-- skip leading whitespace --*/ while (isspace((int)*str)) str++; /*-- handle empty string --*/ if (strcmp(str,"")==0) return -1; /*-- put an upper case copy of *str in buff[] --*/ n = strlen(str); strncpy(buff,str,ARGSTRLEN); for (i=0; i1) return 0; /*-- match on "TRUE", "YES", or "ON" --*/ if (strncmp(buff,"TRUE",n)==0) return 1; if (strncmp(buff,"YES",n)==0) return 1; if (strncmp(buff,"ON",n)==0 && n>1) return 1; /*-- no match --*/ return -1; } static int arg_set_defaults(arg_rec *argtable, int n, char* ErrMsg) { /*************************************************************************** Converts the default argument values from strings into the appropriate data type for that argument. Argument table entries with NULL default strings are ignored. Default values of arguments with NULL valueptrs are converted but then discarded. This is for consistent behaviour, rather than absolute necessity. Should a default value be invalid, then an error message is written into *ErrMsg and the function returns 0. Should ErrMsg==NULL then the error message is omitted. The funtion returns 1 upon success. ***************************************************************************/ int i; /*-- clear *ErrMsg --*/ if (ErrMsg) ErrMsg[0]='\0'; for (i=0; i0 || p==argtable[i].defaultstr) { if (ErrMsg) sprintf(ErrMsg,"arg[%d].defaultstr == \"%s\", invalid int", i,argtable[i].defaultstr); return 0; } if (argtable[i].valueptr!=NULL) *((int*)argtable[i].valueptr) = x; break; } case arg_dbl: { char *p; double x; x = strtod(argtable[i].defaultstr,&p); if (errno!=0 || strlen(p)>0 || p==argtable[i].defaultstr) { if (ErrMsg) sprintf(ErrMsg,"arg[%d].defaultstr == \"%s\", invalid double", i,argtable[i].defaultstr); return 0; } if (argtable[i].valueptr!=NULL) *((double*)argtable[i].valueptr) = x; break; } case arg_str: if (argtable[i].valueptr!=NULL) strcpy((char*)(argtable[i].valueptr), argtable[i].defaultstr); break; }; } return 1; } static int arg_scanf(const char* str, arg_rec* argrec) { /************************************************************* Scans *src for the argument specified in *argrec and writes the result into *(argrec->valueptr). The function returns the number of characters that were read. If (argrec->valueptr)==NULL then the scanned value is discarded. Should an error occur, the function returns -1 and leaves *(argrec->valueptr) unaltered. Note: Strings which are enclosed by single quotes are automatically stripped of the enclosing quotes. **************************************************************/ int length = 0; switch (argrec->argtype) { case arg_bool: { char boolstr[ARGSTRLEN]; int boolval; /*-- scan a boolean string value --*/ if ( sscanf(str,"%s%n",boolstr,&length) != 1 ) return -1; /*-- convert string to boolean int value --*/ boolval = arg_convertbool(boolstr); if (boolval==-1) return -1; /*-- write scanned value into *argrec --*/ if (argrec->valueptr) *((int*)argrec->valueptr) = boolval; break; } case arg_lit: { /*-- if arg has a tag then presume it was located just prior to --*/ /*-- this function. Thus we have found a literal tag. Set the arg --*/ /*-- value (presuming it also is non-NULL) to 1. --*/ if (argrec->tagstr && argrec->valueptr) *((int*)argrec->valueptr) = 1; /*-- if argname!=NULL then scan a literal from the command line. --*/ if (argrec->argname) { /*char fmtstr[ARGSTRLEN];*/ char litstr[ARGSTRLEN]; /*-- scan a literal string value --*/ if ( sscanf(str,"%s%n",litstr,&length) != 1 ) return -1; /*-- compare literal value to expected value --*/ /*-- (ignores possibility of leading whitespace in argname) --*/ if (strcmp(argrec->argname,litstr)!=0) return -1; /*-- scan succeeded --*/ if (argrec->valueptr) *((int*)argrec->valueptr) = 1; /*printf("...ok (%d)\n",length);*/ } break; } case arg_int: { int intval; /*-- scan an int value --*/ if (sscanf(str,"%i %n",&intval,&length) !=1) return -1; /*-- write scanned value into *argrec --*/ if (argrec->valueptr) *((int*)argrec->valueptr) = intval; break; } case arg_dbl: { double dblval; /*-- scan for double value --*/ if ( sscanf(str,"%lf%n",&dblval,&length) != 1) return -1; /*-- write scanned value into *argrec --*/ if (argrec->valueptr) *((double*)argrec->valueptr) = dblval; break; } case arg_str: { char strval[ARGSTRLEN]; /*-- scan for quoted string fist, if no good then try unquoted --*/ if (sscanf(str," '%[^']'%n",strval,&length) != 1) if (sscanf(str,"%s%n",strval,&length) != 1) return -1; /*-- write the string into *argrec --*/ if (argrec->valueptr) strcpy((char*)argrec->valueptr,strval); break; } } return length; } static char* arg_extract_tag(char* str, const char* tag) { /********************************************************************** Searches 'str' for the first occurrence of 'tag'. If found, the tag is erased from str by overwriting it with spaces. The function then returns a pointer to the next char in 'str' immediately after the tag. If the tag cannot be found in cmdline then NULL is returned. **********************************************************************/ char* p = strstr(str,tag); if (p) { int n = strlen(tag); memset(p,' ',n); p+=n; } return p; } static char* arg_extract_value(char* str, arg_rec* argrec) { /************************************************************ Scans the leading characters of str for an argument value as specified by 'argrec'. If successful, the scanned value is written into *(argrec->valueptr). The scanned characters are then erased from str by overwriting them with spaces. The function then returns a pointer to the next char in 'str' following the scanned chars. If argrec->valueptr==NULL then the scanned value is discarded. If the scan was unsuccessful, both 'str' and *(argrec-valueptr) remain unaltered and the function returns NULL. **************************************************************/ int nscan = arg_scanf(str, argrec); if (nscan==-1) return NULL; memset(str,' ',nscan); return (str+nscan); } static void arg_sprint_marker(int i, int n, char *ErrMark) { /************************************************************ Writes i leading spaces, followed by n carets '^' into *ErrMark. **************************************************************/ while (i-->0) *ErrMark++ = ' '; while (n-->0) *ErrMark++ = '^'; *ErrMark='\0'; } static int arg_extract_tagged_args(char* cmdline, arg_rec* argtable, int n, char* ErrMsg, char* ErrMark) { /**************************************************************** Steps thru each entry in the argument table. For each entry that has a non-NULL tag string, the string in *cmdline is scanned for a sequence of chars that match the tag. If found, the argument value that is associated with the tag is scanned from *cmdline and written into the memory location pointed to by the argument table entry. Having done so, the tag + value is then erased from *cmdline by overwriting them with spaces. If the valueptr field of the argument table entry is NULL then the scanned value is discarded. The function returns 1 upon success, 0 upon failure. If the tag is not found in *cmdline and there is no default argument value for that argument table entry then an error is returned. If the tag is found, but the argument value could not be scanned then an error is returned. If multiple occurrences of the tag are found then an error is returned. Error messages are written into a user supplied string buffer at *ErrMsg. A marker string that indicates the position of the error in *cmdline is written into a user supplied string buffer at *ErrMark. Both ErrMsg and ErrMark are optional. If they are given as NULL they are ignored. ****************************************************************/ int i; /*-- init ErrMsg and ErrMark if given non-NULL ptrs --*/ if (ErrMsg) *ErrMsg = '\0'; if (ErrMark) *ErrMark = '\0'; /*-- iterate thru the tagged entries in argtable[]--*/ for (i=0; i", "", "", "", "" };