src/misc/arg.c

   1
   2 /*
   3  * libneuro, a light weight abstraction of high or lower libraries
   4  * and toolkit for applications.
   5  * Copyright (C) 2005-2006  Nicholas Niro, Robert Lemay
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #include <string.h>
  23
  24 #include <other.h>
  25
  26 #include <ebuf.h>
  27 #include <debug.h>
  28
  29 typedef struct DATA
  30 {
  31         char *data;
  32 }DATA;
  33
  34 /* the struct type that contains the list of options used
  35  * by this application.
  36  * TODO find a better name
  37  */
  38 typedef struct LOPTIONS
  39 {
  40         char *string;
  41         int options;
  42         void (*action)(char *data);
  43         u32 present;
  44         char *data;
  45         EBUF *datas;
  46 }LOPTIONS;
  47
  48 /* struct buffer to keep the input arguments */
  49 typedef struct BUFINPUT
  50 {
  51         char *string;
  52         u8 type; /* 0 is unknown, 1 is option, 2 is data and 3 is a nest of options */
  53         u8 used; /* if this is 0 it will do an error, with a nest of options, at least
  54         one option needs to be invalid to make an error. */
  55 }BUFINPUT;
  56
  57 /* input types */
  58 enum
  59 {
  60         TYPE_UNKNOWN, /* 0 */
  61         TYPE_OPTION,
  62         TYPE_DATA,
  63         TYPE_NEST /* 3 */
  64 };
  65
  66 static EBUF *bufinput; /* buffer of argv */
  67 static EBUF *loptions; /* Buffer of the list of options */
  68
  69 static void
  70 clean_loptions(void *src)
  71 {
  72         LOPTIONS *buf;
  73
  74         buf = (LOPTIONS*)src;
  75
  76         if (!Neuro_EBufIsEmpty(buf->datas))
  77                 Neuro_CleanEBuf(&buf->datas);
  78
  79         if (buf->string)
  80         {
  81                 /* printf("cleaning %s\n", buf->string); */
  82                 free(buf->string);
  83         }
  84 }
  85
  86 /* finds a data option and diminish its presence by 1 */
  87 /*
  88 static void
  89 Find_DATA_And_Revoke()
  90 {
  91         LOPTIONS *option;
  92         u32 ototal;
  93
  94         ototal = Neuro_GiveEBufCount(loptions) + 1;
  95
  96         while (ototal-- > 0)
  97         {
  98                 option = Neuro_GiveEBuf(loptions, ototal);
  99
 100                 if (option->string == NULL)
 101                 {
 102                         option->present--;
 103                 }
 104         }
 105 }
 106 */
 107
 108 static void
 109 Push_Data(LOPTIONS *option, char *string)
 110 {
 111         DATA *dta;
 112
 113         if (!option->datas)
 114         {
 115                 Neuro_CreateEBuf(&option->datas);
 116         }
 117
 118         Neuro_AllocEBuf(option->datas, sizeof(DATA*), sizeof(DATA));
 119
 120         dta = Neuro_GiveCurEBuf(option->datas);
 121
 122         dta->data = string;
 123
 124 }
 125
 126 static int
 127 Handle_Option_Argument(LOPTIONS *option, u32 i, char *input_string)
 128 {
 129         BUFINPUT *input;
 130         char *temp;
 131         int _err = 0;
 132
 133         /* completely useless because the caller of this function filters the strings
 134          * and only matches those in loptions (meaning none can in theory have a '='
 135          * character in them)
 136          */
 137         if ((temp = memchr(input_string, '=', strlen(input_string))))
 138         {
 139                 if (temp[1] == '\0')
 140                         _err = 1;
 141                 else
 142                 {
 143                         /* option->data = &temp[1]; */
 144                         Push_Data(option, &temp[1]);
 145                 }
 146
 147         }
 148         else
 149         {
 150                 input = Neuro_GiveEBuf(bufinput, i + 1);
 151                 if (input)
 152                 {
 153                         if (input->type == TYPE_DATA)
 154                         {
 155                                 /* option->data = input->string; */
 156                                 Push_Data(option, input->string);
 157                                 input->used = 1;
 158                                 /* Find_DATA_And_Revoke(); */
 159                         }
 160                         else
 161                                 _err = 1;
 162                 }
 163                 else
 164                         _err = 1;
 165
 166                 input = Neuro_GiveEBuf(bufinput, i);
 167         }
 168
 169         if (_err == 1)
 170         {
 171                 Debug_Val(0, "Missing a DATA argument to the option %s\n", option->string);
 172         }
 173         /*else
 174         {
 175                 Debug_Val(2, " includes data \"%s\" ", option->data);
 176         }*/
 177
 178         return _err;
 179 }
 180
 181 static int
 182 Handle_Options_nest(BUFINPUT *input, LOPTIONS *option, char *input_string,
 183                 char *sep_string, u32 current)
 184 {
 185         int _err = 0;
 186
 187
 188         Debug_Val(4, " N %s -%c", sep_string, input_string[0]);
 189
 190         /* we drop any checks with long options (--) */
 191         if (strlen(sep_string) > 2)
 192                 return 0;
 193
 194         if (input_string[0] == sep_string[1])
 195         {
 196                 option->present++;
 197
 198                 Debug_Val(4, " <- found %c ", input->used);
 199
 200                 if (option->options & OPTION_NESTED)
 201                 {
 202                         input->used++;
 203
 204                         _err = 3;
 205
 206                         if (option->options & OPTION_ARGUMENT)
 207                                 _err = Handle_Option_Argument(option, current, input->string);
 208                 }
 209                 else
 210                 {
 211                         _err = 1;
 212                         Debug_Val(0, "Invalid option in a nest of options %d \n", input->used);
 213                 }
 214
 215         }
 216
 217         return _err;
 218 }
 219
 220 /* TODO find a better name eheh */
 221 static int
 222 Handle_Options(BUFINPUT *input, LOPTIONS *option, char *sep_string, u32 current)
 223 {
 224         char *sep; /* will contain the - or -- prefix plus the option */
 225         int len; /* sep_string len */
 226         int _err = 0;
 227
 228         len = strlen(sep_string);
 229
 230         sep = calloc(1, len + 4);
 231
 232         if (len > 1 /* && sep_string[0] != '-'*/)
 233         {
 234                 /* could be either a long option (ie email) or a
 235                  * short option ( ie -e ) but with extra options in
 236                  * it ( ie -eau ). An error would be that the
 237                  * extra option contains invalid nested options, a
 238                  * '=' character when a small option.
 239                  */
 240                 sep[0] = '-';
 241                 sep[1] = '-';
 242                 strncpy(&sep[2], sep_string, len);
 243         }
 244         else
 245         {
 246
 247                 sep[0] = '-';
 248                 sep[1] = sep_string[0];
 249                 /*
 250                 if (len == 1)
 251                 {
 252                         sep[2] = '\0';
 253                         _err = Handle_Options(input, option, sep, current);
 254                 }
 255                 else
 256                 {
 257                         sep[2] = sep_string[1];
 258                         sep[3] = '\0';
 259                 }
 260                 */
 261         }
 262
 263         Debug_Val(4, "%s %s", sep, input->string);
 264
 265         /*
 266         tmp = strchr(input->string, '=');
 267
 268         if (tmp)
 269         {
 270                 tmp = '\0';
 271                 printf(" <- data included ");
 272         }
 273         */
 274
 275         /* check if we have an element in bufinput that is a nest of options
 276          * ie -au
 277          */
 278         if (input->type == TYPE_NEST)
 279         {
 280                 int i = 1;
 281                 int ilen = strlen(input->string);
 282
 283                 Debug_Val(4, " <- nested options \n");
 284
 285                 /* input->used = 0; */
 286
 287                 while (i < ilen)
 288                 {
 289
 290                         _err = Handle_Options_nest(input, option, &input->string[i], sep, current);
 291                         if (i + 1 < ilen)
 292                                 Debug_Val(4, "\n");
 293                         i++;
 294                 }
 295
 296         }
 297         else
 298         {
 299                 if (!strncmp(input->string, sep, strlen(sep)))
 300                 {
 301                         option->present++;
 302
 303                         Debug_Val(4, " <- found ");
 304
 305                         input->used = 1;
 306
 307                         _err = 3;
 308
 309                         if (option->options & OPTION_ARGUMENT)
 310                                 _err = Handle_Option_Argument(option, current, input->string);
 311                 }
 312                 /*else
 313                 {
 314                         if (input->used != 1)
 315                                 input->used = 0;
 316                 }
 317                 */
 318         }
 319
 320         Debug_Val(4, "\n");
 321         free(sep);
 322
 323         return _err;
 324 }
 325
 326 int
 327 Neuro_ArgInit(int argc, char **argv)
 328 {
 329         int i = 0;
 330         BUFINPUT *buf;
 331
 332         if (loptions)
 333                 return 1;
 334         if (argc == 0)
 335                 return 1;
 336         if (argv == NULL)
 337                 return 1;
 338
 339         Neuro_CreateEBuf(&bufinput);
 340         Neuro_CreateEBuf(&loptions);
 341
 342         if (!bufinput || !loptions)
 343                 return 1;
 344
 345         Neuro_SetcallbEBuf(loptions, clean_loptions);
 346
 347         /* since 0 is the name of the executed command */
 348         i = 1;
 349         while (i < argc)
 350         {
 351                 Neuro_AllocEBuf(bufinput, sizeof(BUFINPUT*), sizeof(BUFINPUT));
 352                 buf = Neuro_GiveCurEBuf(bufinput);
 353
 354                 buf->string = argv[i];
 355                 i++;
 356         }
 357
 358 #if init_test
 359         /* a test to see if everything works */
 360         i = Neuro_GiveEBufCount(bufinput) + 1;
 361         while (i-- > 0)
 362         {
 363                 buf = Neuro_GiveEBuf(bufinput, i);
 364                 Debug_Val(10, "arg output %s\n", buf->string);
 365         }
 366 #endif /* init_test */
 367
 368         return 0;
 369 }
 370
 371 void
 372 Neuro_ArgOption(char *string, int options, void (*action)(char *data))
 373 {
 374         LOPTIONS *buf;
 375
 376         if (!bufinput)
 377                 return;
 378         if (!loptions)
 379                 return;
 380
 381         Neuro_AllocEBuf(loptions, sizeof(LOPTIONS*), sizeof(LOPTIONS));
 382         buf = Neuro_GiveCurEBuf(loptions);
 383
 384         buf->string = NULL;
 385         if (string)
 386         {
 387                 buf->string = calloc(1, strlen(string) + 1);
 388                 strncpy(buf->string, string, strlen(string));
 389         }
 390
 391         buf->options = options;
 392
 393         if (action)
 394                 buf->action = action;
 395 }
 396
 397 int
 398 Neuro_ArgProcess()
 399 {
 400         /* interesting notes :
 401          * - options can contain more than one option in it
 402          * options only with the OPTION_NESTED flag can go in it.
 403          * - options with the flag OPTION_ARGUMENT can't contain a
 404          * = character in it, the next input argument is read to see
 405          * if it is a DATA type, if it is not, it will do an error.
 406          *
 407          * -- options can only contain a single option but the string
 408          *  of the option can be of any lenght (unlike - ). In presence
 409          *  of OPTION_ARGUMENT, the algorithm doesn't loop for the next
 410          *  input argument like for -, it will look for the -- option and
 411          *  try to find a '=' character which should follow a string that
 412          *  is the argument or else it will do an error.
 413          */
 414
 415         BUFINPUT *input;
 416         u32 itotal;
 417         LOPTIONS *option;
 418         u32 ototal;
 419         u32 i = 0, i2 = 0, i3 = 0;
 420         SepChr_Data *sep;
 421         EBUF *sepchr;
 422         int _err = 0;
 423
 424         ototal = Neuro_GiveEBufCount(loptions) + 1;
 425
 426         /* in case there is no arguments inputed
 427          * we search the loptions to see if an
 428          * option contains the OPTION_VOID tag
 429          * so we can run it. Normally, only one
 430          * option should have this tag so we
 431          * will only run the first we find.
 432          */
 433         if (Neuro_EBufIsEmpty(bufinput))
 434         {
 435                 while (i < ototal)
 436                 {
 437                         option = Neuro_GiveEBuf(loptions, i);
 438
 439                         if (option->options & OPTION_VOID)
 440                         {
 441                                 if (option->action)
 442                                         (option->action)(NULL);
 443                                 return 1;
 444                         }
 445                         i++;
 446                 }
 447                 return 0;
 448         }
 449
 450
 451         itotal = Neuro_GiveEBufCount(bufinput) + 1;
 452
 453         /* printf("TOTAL %d\n", itotal); */
 454         Debug_Val(3, "TOTAL %d\n", itotal);
 455
 456
 457         i = 0;
 458         /* flag the input arguments with their types */
 459         while (i < itotal)
 460         {
 461                 input = Neuro_GiveEBuf(bufinput, i);
 462
 463                 Debug_Val(6, "input %s", input->string);
 464
 465                 if (input->string[0] == '-')
 466                 {
 467                         if (input->string[1] != '-' && strlen(input->string) > 2)
 468                         {
 469                                 if (strchr(input->string, '='))
 470                                 {
 471                                         _err = 2;
 472                                         Debug_Val(0, "Invalid use of the option character \'-\', it may only be used alone or with other options, \n");
 473                                         Debug_Val(0, "to pass an argument to it, please use either the long version of the option (ie --foo=bar)\n");
 474                                         Debug_Val(0, "or have a space between the option and the argument (ie -f bar).\n");
 475                                 }
 476                                 else
 477                                 {
 478                                         input->type = TYPE_NEST;
 479
 480                                         Debug_Val(6, " nest\n");
 481                                 }
 482                         }
 483                         else
 484                         {
 485                                 input->type = TYPE_OPTION;
 486
 487                                 Debug_Val(6, " option\n");
 488                         }
 489                 }
 490                 else
 491                 {
 492                         input->type = TYPE_DATA;
 493
 494                         Debug_Val(6, " data\n");
 495                 }
 496                 i++;
 497         }
 498
 499         i = 0;
 500         /* loop the options & arguments and process(change flags only except
 501          * some exceptions like arguments to options which it will handle) the
 502          * normal, <done>
 503          * argument, <done>
 504          * nested(-au), <done>
 505          * multi <done>
 506          * and required <done>
 507          * type of options.
 508          */
 509         while (i < itotal && !_err)
 510         {
 511                 input = Neuro_GiveEBuf(bufinput, i);
 512                 i2 = 0;
 513                 while (i2 < ototal && !_err)
 514                 {
 515                         option = Neuro_GiveEBuf(loptions, i2);
 516
 517                         if (option->string)
 518                         {
 519                                 sepchr = Neuro_SepChr2(',', option->string);
 520
 521                                 i3 = Neuro_GiveEBufCount(sepchr) + 1;
 522                                 while (i3-- > 0 && !_err)
 523                                 {
 524                                         sep = Neuro_GiveEBuf(sepchr, i3);
 525
 526                                         /* TODO find a better name eheh */
 527                                         _err = Handle_Options(input, option, sep->string, i);
 528
 529                                         if (_err == 1)
 530                                         {
 531                                                 /* an error occured */
 532                                                 _err = 2;
 533                                         }
 534                                         else
 535                                         {
 536                                                 /* 3 means the current option
 537                                                  * and input concords
 538                                                  */
 539                                                 if (_err == 3)
 540                                                 {
 541                                                         if (option->options & OPTION_QUIT)
 542                                                                 _err = 1;
 543                                                         else
 544                                                                 _err = 0;
 545                                                 }
 546                                         }
 547                                 }
 548                                 Neuro_CleanEBuf(&sepchr);
 549                         }
 550                         else
 551                         {
 552
 553                                 Debug_Val(4, "DATA %s", input->string);
 554
 555                                 if (input->type == TYPE_DATA && input->used == 0)
 556                                 {
 557                                         input->used = 1;
 558                                         option->present++;
 559                                         /* option->data = input->string; */
 560                                         Push_Data(option, input->string);
 561
 562                                         Debug_Val(4, " <- found ");
 563                                 }
 564                                 Debug_Val(4, "\n");
 565                         }
 566
 567                         i2++;
 568                 }
 569                 i++;
 570         }
 571
 572         if (!_err)
 573         {
 574                 i = 0;
 575                 /* loop the options to see if all the required
 576                  * options are present and also check if options
 577                  * don't have more than one iteration of themselves
 578                  * unless they have the multi option.
 579                  */
 580                 while (i < ototal)
 581                 {
 582                         option = Neuro_GiveEBuf(loptions, i);
 583
 584                         if (option->options & OPTION_REQUIRED && option->present == 0)
 585                         {
 586                                 if (option->string)
 587                                         Debug_Val(0, "Required option %s is not present.\n", option->string);
 588                                 else
 589                                         Debug_Val(0, "Required option DATA is not present.\n");
 590
 591                                 _err = 2;
 592                         }
 593
 594                         if (!(option->options & OPTION_MULTI) && option->present > 1)
 595                         {
 596                                 if (option->string)
 597                                         Debug_Val(0, "Invalid use of more than one iteration of the option %s.\n", option->string);
 598                                 else
 599                                         Debug_Val(0, "Invalid use of more than one iteration of the option DATA.\n");
 600
 601                                 _err = 2;
 602
 603                         }
 604                         i++;
 605                 }
 606         }
 607
 608         if (!_err)
 609         {
 610                 i = 0;
 611                 /* loop the bufinput elements and check to see if theres
 612                  * invalid arguments and print the according errors.
 613                  */
 614                 while (i < itotal)
 615                 {
 616                         input = Neuro_GiveEBuf(bufinput, i);
 617
 618                         if (input->used == 0)
 619                         {
 620                                 Debug_Val(0, "Invalid option used %s\n", input->string);
 621                                 _err = 2;
 622                         }
 623                         else
 624                         {
 625                                 if (input->type == TYPE_NEST)
 626                                 {
 627                                         if (input->used < strlen(input->string) - 1)
 628                                         {
 629                                                 Debug_Val(0, "One or more options in the option nest \"%s\" is invalid\n", input->string);
 630                                                 _err = 2;
 631                                         }
 632                                 }
 633                         }
 634
 635                         i++;
 636                 }
 637         }
 638
 639         if (_err <= 1)
 640         {
 641                 i = 0;
 642                 /* loop the options and call the callbacks if theres no errors */
 643                 while (i < ototal)
 644                 {
 645                         option = Neuro_GiveEBuf(loptions, i);
 646
 647                         if (option->present)
 648                         {
 649                                 if (option->action)
 650                                 {
 651                                         /*if (option->data)
 652                                                 (option->action)(option->data);
 653                                         */
 654                                         if (!Neuro_EBufIsEmpty(option->datas))
 655                                         {
 656                                                 DATA *dta;
 657                                                 int dtotal = 0;
 658
 659                                                 dtotal = Neuro_GiveEBufCount(option->datas);
 660                                                 dtotal++;
 661                                                 while (dtotal-- > 0)
 662                                                 {
 663                                                         dta = Neuro_GiveEBuf(option->datas, dtotal);
 664                                                         (option->action)(dta->data);
 665                                                 }
 666                                         }
 667                                         else
 668                                                 (option->action)(NULL);
 669
 670                                         if (option->options & OPTION_QUIT)
 671                                         {
 672                                                 _err = 1;
 673                                                 break;
 674                                         }
 675                                 }
 676                         }
 677                         i++;
 678                 }
 679         }
 680
 681         return _err;
 682 }
 683
 684 void
 685 Neuro_ArgClean()
 686 {
 687         Neuro_CleanEBuf(&bufinput);
 688         Neuro_CleanEBuf(&loptions);
 689 }