tagmanager/ctags/args.c

   1 /*
   2 *
   3 *   Copyright (c) 1999-2001, Darren Hiebert
   4 *
   5 *   This source code is released for free distribution under the terms of the
   6 *   GNU General Public License.
   7 *
   8 *   This module contains functions for reading command line arguments.
   9 */
  10
  11 /*
  12 *   INCLUDE FILES
  13 */
  14 #include "general.h"    /* must always come first */
  15
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <ctype.h>
  19
  20 #include "args.h"
  21 #include "main.h"
  22
  23 /*
  24 *   FUNCTION DEFINITIONS
  25 */
  26
  27 static char *nextStringArg (const char** const next)
  28 {
  29     char* result = NULL;
  30     const char* start;
  31
  32     Assert (*next != NULL);
  33     for (start = *next  ;  isspace ((int) *start)  ;  ++start)
  34         ;
  35     if (*start == '\0')
  36         *next = start;
  37     else
  38     {
  39         size_t length;
  40         const char* end;
  41
  42         for (end = start ;  *end != '\0'  &&  ! isspace ((int) *end)  ;  ++end)
  43             ;
  44         length = end - start;
  45         Assert (length > 0);
  46         result = xMalloc (length + 1, char);
  47         strncpy (result, start, length);
  48         result [length] = '\0';
  49         *next = end;
  50     }
  51     return result;
  52 }
  53
  54 static char* nextStringLine (const char** const next)
  55 {
  56     char* result = NULL;
  57     size_t length;
  58     const char* end;
  59
  60     Assert (*next != NULL);
  61     for (end = *next ;  *end != '\n'  &&  *end != '\0' ;  ++end)
  62         ;
  63     length = end - *next;
  64     if (length > 0)
  65     {
  66         result = xMalloc (length + 1, char);
  67         strncpy (result, *next, length);
  68         result [length] = '\0';
  69     }
  70     if (*end == '\n')
  71         ++end;
  72     *next = end;
  73     return result;
  74 }
  75
  76 static char* nextString (const Arguments* const current, const char** const next)
  77 {
  78     char* result;
  79     if (current->lineMode)
  80         result = nextStringLine (next);
  81     else
  82         result = nextStringArg (next);
  83     return result;
  84 }
  85
  86 static char* nextFileArg (FILE* const fp)
  87 {
  88     char* result = NULL;
  89     Assert (fp != NULL);
  90     if (! feof (fp))
  91     {
  92         vString* vs = vStringNew ();
  93         int c;
  94         do
  95             c = fgetc (fp);
  96         while (isspace (c));
  97
  98         if (c != EOF)
  99         {
 100             do
 101             {
 102                 vStringPut (vs, c);
 103                 c = fgetc (fp);
 104             } while (c != EOF  &&  ! isspace (c));
 105             vStringTerminate (vs);
 106             Assert (vStringLength (vs) > 0);
 107             result = xMalloc (vStringLength (vs) + 1, char);
 108             strcpy (result, vStringValue (vs));
 109         }
 110         vStringDelete (vs);
 111     }
 112     return result;
 113 }
 114
 115 static char* nextFileLine (FILE* const fp)
 116 {
 117     char* result = NULL;
 118     Assert (fp != NULL);
 119     if (! feof (fp))
 120     {
 121         vString* vs = vStringNew ();
 122         int c;
 123
 124         c = fgetc (fp);
 125         while (c != EOF  &&  c != '\n')
 126         {
 127             vStringPut (vs, c);
 128             c = fgetc (fp);
 129         }
 130         vStringTerminate (vs);
 131         if (vStringLength (vs) > 0)
 132         {
 133             result = xMalloc (vStringLength (vs) + 1, char);
 134             strcpy (result, vStringValue (vs));
 135         }
 136         vStringDelete (vs);
 137     }
 138     return result;
 139 }
 140
 141 static char* nextFileString (const Arguments* const current, FILE* const fp)
 142 {
 143     char* result;
 144     if (current->lineMode)
 145         result = nextFileLine (fp);
 146     else
 147         result = nextFileArg (fp);
 148     return result;
 149 }
 150
 151 extern Arguments* argNewFromString (const char* const string)
 152 {
 153     Arguments* result = xMalloc (1, Arguments);
 154     memset (result, 0, sizeof (Arguments));
 155     result->type = ARG_STRING;
 156     result->u.stringArgs.string = string;
 157     result->u.stringArgs.item = string;
 158     result->u.stringArgs.next = string;
 159     result->item = nextString (result, &result->u.stringArgs.next);
 160     return result;
 161 }
 162
 163 extern Arguments* argNewFromArgv (char* const* const argv)
 164 {
 165     Arguments* result = xMalloc (1, Arguments);
 166     memset (result, 0, sizeof (Arguments));
 167     result->type = ARG_ARGV;
 168     result->u.argvArgs.argv = argv;
 169     result->u.argvArgs.item = result->u.argvArgs.argv;
 170     result->item = *result->u.argvArgs.item;
 171     return result;
 172 }
 173
 174 extern Arguments* argNewFromFile (FILE* const fp)
 175 {
 176     Arguments* result = xMalloc (1, Arguments);
 177     memset (result, 0, sizeof (Arguments));
 178     result->type = ARG_FILE;
 179     result->u.fileArgs.fp = fp;
 180     result->item = nextFileString (result, result->u.fileArgs.fp);
 181     return result;
 182 }
 183
 184 extern Arguments* argNewFromLineFile (FILE* const fp)
 185 {
 186     Arguments* result = xMalloc (1, Arguments);
 187     memset (result, 0, sizeof (Arguments));
 188     result->type = ARG_FILE;
 189     result->lineMode = TRUE;
 190     result->u.fileArgs.fp = fp;
 191     result->item = nextFileString (result, result->u.fileArgs.fp);
 192     return result;
 193 }
 194
 195 extern char *argItem (const Arguments* const current)
 196 {
 197     Assert (current != NULL);
 198     Assert (! argOff (current));
 199     return current->item;
 200 }
 201
 202 extern boolean argOff (const Arguments* const current)
 203 {
 204     Assert (current != NULL);
 205     return (boolean) (current->item == NULL);
 206 }
 207
 208 extern void argSetWordMode (Arguments* const current)
 209 {
 210     Assert (current != NULL);
 211     current->lineMode = FALSE;
 212 }
 213
 214 extern void argSetLineMode (Arguments* const current)
 215 {
 216     Assert (current != NULL);
 217     current->lineMode = TRUE;
 218 }
 219
 220 extern void argForth (Arguments* const current)
 221 {
 222     Assert (current != NULL);
 223     Assert (! argOff (current));
 224     switch (current->type)
 225     {
 226         case ARG_STRING:
 227             if (current->item != NULL)
 228                 eFree (current->item);
 229             current->u.stringArgs.item = current->u.stringArgs.next;
 230             current->item = nextString (current, &current->u.stringArgs.next);
 231             break;
 232         case ARG_ARGV:
 233             ++current->u.argvArgs.item;
 234             current->item = *current->u.argvArgs.item;
 235             break;
 236         case ARG_FILE:
 237             if (current->item != NULL)
 238                 eFree (current->item);
 239             current->item = nextFileString (current, current->u.fileArgs.fp);
 240             break;
 241         default:
 242             Assert ("Invalid argument type" == NULL);
 243             break;
 244     }
 245 }
 246
 247 extern void argDelete (Arguments* const current)
 248 {
 249     Assert (current != NULL);
 250     if (current->type ==  ARG_STRING  &&  current->item != NULL)
 251         eFree (current->item);
 252     memset (current, 0, sizeof (Arguments));
 253     eFree (current);
 254 }
 255
 256 /* vi:set tabstop=8 shiftwidth=4: */