ctags/main/args.c

   1 /*
   2 *   Copyright (c) 1999-2002, Darren Hiebert
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License version 2 or (at your option) any later version.
   6 *
   7 *   This module contains functions for reading command line arguments.
   8 */
   9
  10 /*
  11 *   INCLUDE FILES
  12 */
  13 #include "general.h"  /* must always come first */
  14
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18
  19 #include "args.h"
  20 #include "debug.h"
  21 #include "routines.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         else if (*end == '\r')
  73         {
  74                 ++end;
  75                 if (*end == '\n')
  76                         ++end;
  77         }
  78         *next = end;
  79         return result;
  80 }
  81
  82 static char* nextString (const Arguments* const current, const char** const next)
  83 {
  84         char* result;
  85         if (current->lineMode)
  86                 result = nextStringLine (next);
  87         else
  88                 result = nextStringArg (next);
  89         return result;
  90 }
  91
  92 static char* nextFileArg (FILE* const fp)
  93 {
  94         char* result = NULL;
  95         Assert (fp != NULL);
  96         if (! feof (fp))
  97         {
  98                 vString* vs = vStringNew ();
  99                 int c;
 100                 do
 101                         c = fgetc (fp);
 102                 while (isspace (c));
 103
 104                 if (c != EOF)
 105                 {
 106                         do
 107                         {
 108                                 vStringPut (vs, c);
 109                                 c = fgetc (fp);
 110                         } while (c != EOF  &&  ! isspace (c));
 111                         Assert (vStringLength (vs) > 0);
 112                         result = xMalloc (vStringLength (vs) + 1, char);
 113                         strcpy (result, vStringValue (vs));
 114                 }
 115                 vStringDelete (vs);
 116         }
 117         return result;
 118 }
 119
 120 static char* nextFileLine (FILE* const fp)
 121 {
 122         char* result = NULL;
 123         Assert (fp != NULL);
 124         if (! feof (fp))
 125         {
 126                 vString* vs = vStringNew ();
 127                 int c;
 128
 129                 c = fgetc (fp);
 130                 while (c != EOF)
 131                 {
 132                         if (c != '\n'  &&  c != '\r')
 133                                 vStringPut (vs, c);
 134                         else if (vStringLength (vs) > 0)
 135                                 break;
 136                         c = fgetc (fp);
 137                 }
 138                 if (c != EOF  ||  vStringLength (vs) > 0)
 139                 {
 140                         if (c == '\r')
 141                         {
 142                                 c = fgetc (fp);
 143                                 if (c != '\n')
 144                                         c = ungetc (c, fp);
 145                         }
 146                         vStringStripTrailing (vs);
 147                         result = xMalloc (vStringLength (vs) + 1, char);
 148                         vStringStripLeading (vs);
 149                         strcpy (result, vStringValue (vs));
 150                 }
 151                 vStringDelete (vs);
 152         }
 153         return result;
 154 }
 155
 156 static bool isCommentLine (char* line)
 157 {
 158         while (isspace(*line))
 159                 ++line;
 160         return (*line == '#');
 161 }
 162
 163 static char* nextFileLineSkippingComments (FILE* const fp)
 164 {
 165         char* result;
 166         bool comment;
 167
 168         do
 169         {
 170                 result = nextFileLine (fp);
 171                 comment = (result && isCommentLine (result));
 172                 if (comment)
 173                         eFree (result);
 174         } while (comment);
 175         return result;
 176 }
 177
 178 static char* nextFileString (const Arguments* const current, FILE* const fp)
 179 {
 180         char* result;
 181         if (current->lineMode)
 182                 result = nextFileLineSkippingComments (fp);
 183         else
 184                 result = nextFileArg (fp);
 185         return result;
 186 }
 187
 188 extern Arguments* argNewFromString (const char* const string)
 189 {
 190         Arguments* result = xMalloc (1, Arguments);
 191         memset (result, 0, sizeof (Arguments));
 192         result->type = ARG_STRING;
 193         result->u.stringArgs.next = string;
 194         result->item = nextString (result, &result->u.stringArgs.next);
 195         return result;
 196 }
 197
 198 extern Arguments* argNewFromArgv (char* const* const argv)
 199 {
 200         Arguments* result = xMalloc (1, Arguments);
 201         memset (result, 0, sizeof (Arguments));
 202         result->type = ARG_ARGV;
 203         result->u.argvArgs.argv = argv;
 204         result->u.argvArgs.item = result->u.argvArgs.argv;
 205         result->item = *result->u.argvArgs.item;
 206         return result;
 207 }
 208
 209 extern Arguments* argNewFromFile (FILE* const fp)
 210 {
 211         Arguments* result = xMalloc (1, Arguments);
 212         memset (result, 0, sizeof (Arguments));
 213         result->type = ARG_FILE;
 214         result->u.fileArgs.fp = fp;
 215         result->item = nextFileString (result, result->u.fileArgs.fp);
 216         return result;
 217 }
 218
 219 extern Arguments* argNewFromLineFile (FILE* const fp)
 220 {
 221         Arguments* result = xMalloc (1, Arguments);
 222         memset (result, 0, sizeof (Arguments));
 223         result->type = ARG_FILE;
 224         result->lineMode = true;
 225         result->u.fileArgs.fp = fp;
 226         result->item = nextFileString (result, result->u.fileArgs.fp);
 227         return result;
 228 }
 229
 230 extern char *argItem (const Arguments* const current)
 231 {
 232         Assert (current != NULL);
 233         Assert (! argOff (current));
 234         return current->item;
 235 }
 236
 237 extern bool argOff (const Arguments* const current)
 238 {
 239         Assert (current != NULL);
 240         return (bool) (current->item == NULL);
 241 }
 242
 243 extern void argSetWordMode (Arguments* const current)
 244 {
 245         Assert (current != NULL);
 246         current->lineMode = false;
 247 }
 248
 249 extern void argSetLineMode (Arguments* const current)
 250 {
 251         Assert (current != NULL);
 252         current->lineMode = true;
 253 }
 254
 255 extern void argForth (Arguments* const current)
 256 {
 257         Assert (current != NULL);
 258         Assert (! argOff (current));
 259         switch (current->type)
 260         {
 261                 case ARG_STRING:
 262                         if (current->item != NULL)
 263                                 eFree (current->item);
 264                         current->item = nextString (current, &current->u.stringArgs.next);
 265                         break;
 266                 case ARG_ARGV:
 267                         ++current->u.argvArgs.item;
 268                         current->item = *current->u.argvArgs.item;
 269                         break;
 270                 case ARG_FILE:
 271                         if (current->item != NULL)
 272                                 eFree (current->item);
 273                         current->item = nextFileString (current, current->u.fileArgs.fp);
 274                         break;
 275                 default:
 276                         Assert ("Invalid argument type" == NULL);
 277                         break;
 278         }
 279 }
 280
 281 extern void argDelete (Arguments* const current)
 282 {
 283         Assert (current != NULL);
 284         if (current->type ==  ARG_STRING  &&  current->item != NULL)
 285                 eFree (current->item);
 286         memset (current, 0, sizeof (Arguments));
 287         eFree (current);
 288 }