Annotation of gpl/axl/knife/exarg.c, revision 1.1.1.1
1.1 misho 1: /**
2: * LibExploreArguments: a library to parse command line options
3: * Copyright (C) 2005 Advanced Software Production Line, S.L.
4: *
5: * This program is free software; you can redistribute it and/or
6: * modify it under the terms of the GNU Lesser General Public License
7: * as published by the Free Software Foundation; either version 2.1 of
8: * the License, or (at your option) any later version.
9: *
10: * This program is distributed in the hope that it will be useful,
11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: * GNU Lesser General Public License for more details.
14: *
15: * You should have received a copy of the GNU Lesser General Public
16: * License along with this program; if not, write to the Free
17: * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18: * 02111-1307 USA
19: *
20: * You may find a copy of the license under this software is released
21: * at COPYING file. This is LGPL software: you are wellcome to
22: * develop propietary applications using this library withtout any
23: * royalty or fee but returning back any change, improvement or
24: * addition in the form of source code, project image, documentation
25: * patches, etc.
26: *
27: * Contact us at:
28: *
29: * Postal address:
30: * Advanced Software Production Line, S.L.
31: * C/ Dr. Michavila Nº 14
32: * Coslada 28820 Madrid
33: * Spain
34: *
35: * Email address:
36: * info@aspl.es - http://fact.aspl.es
37: *
38: */
39: #include <exarg.h>
40:
41: #if defined(__GNUC__)
42: # ifndef _GNU_SOURCE
43: # define _GNU_SOURCE
44: # endif
45: #endif
46:
47: /* local includes */
48: #include <stdio.h>
49: #include <string.h>
50: #include <stdarg.h>
51: #include <stdlib.h>
52:
53: #define LOG_DOMAIN "exarg"
54:
55: typedef struct _ExArgNodeOption ExArgNodeOption;
56:
57: /**
58: * @internal Definition for the void *.
59: */
60: typedef void * epointer;
61:
62: /**
63: * @brief First argument option supported (this is the head of the
64: * list of arguments supported).
65: */
66: ExArgNodeOption * argument_options = NULL;
67: ExArgument * params = NULL;
68: const char * exarg_exec_name = NULL;
69: char * __exarg_usage_header = NULL;
70: char * __exarg_help_header = NULL;
71: char * __exarg_post_usage_header = NULL;
72: char * __exarg_post_help_header = NULL;
73: int __exarg_disable_free_args = 0;
74:
75: typedef enum {
76: /**
77: * @internal Parse mode not defined.
78: */
79: PARSE_MODE_NOT_DEF,
80: /**
81: * @internal Parse mode unix defined.
82: */
83: PARSE_MODE_UNIX,
84: /**
85: * @internal Parse module windows defined.
86: */
87: PARSE_MODE_WINDOWS
88: } ExArgParseMode;
89:
90: /**
91: * @internal This allows to know the parse mode used by exarg. Parse
92: * mode allows to differenciate arguments that are file path under
93: * unix by options under windows. This option is automatic, being the
94: * first option parse to configure the parse mode. This means that the
95: * user can't mix options provided using the windows and unix mode at
96: * the same time.
97: */
98: ExArgParseMode parse_mode = PARSE_MODE_NOT_DEF;
99:
100: /**
101: * @internal Function used by the exarg library to drop a message.
102: *
103: * @param format The message to print using a printf format.
104: */
105: void exarg_msg (char * format, ...)
106: {
107: va_list args;
108:
109: /* print the message */
110: va_start (args, format);
111: vprintf (format, args);
112: va_end (args);
113:
114: /* flush */
115: fflush (stdout);
116:
117: /* exit from the library */
118: exit (-1);
119:
120: return;
121: }
122:
123: /**
124: * @brief Allows to check current parse mode, return ok if the parse
125: * mode isn't defined or the current parse mode is the one provided.
126: *
127: * @param mode The parse mode to check.
128: *
129: * @return 1 if the parse mode is ok or 0 if current parse mode is
130: * incompatible.
131: */
132: #define CHECK_PARSE_MODE(mode) ((parse_mode == PARSE_MODE_NOT_DEF) || (parse_mode == mode))
133:
134: /**
135: * @brief Allows to update current parse mode.
136: *
137: * @param mode The parse mode to configure.
138: *
139: */
140: #define UPDATE_PARSE_MODE(mode)\
141: if (parse_mode == PARSE_MODE_NOT_DEF)\
142: parse_mode = mode;
143:
144: /**
145: * \mainpage LibExArg (Explore Arguments Library) Manual
146: * \section Introduction
147: *
148: * LibExArg library is a small, easy to use with a consistent API
149: * which allows you to parse command line argument for your program.
150: *
151: * It doesn't require any external dependency for its function, it
152: * really portable and at this point is running on <b>GNU/Linux</b>
153: * platforms and <b>Microsoft Windows</b> platforms.
154: *
155: * For details on how to starting to use LibExarg, you can find the
156: * \ref exarg "module documentation for LibExArg here". You can find
157: * \ref exarg_example "here an example about using LibExArg".
158: *
159: * \section licence Library License
160: *
161: * The library is released under the terms of the GNU LGPL (The GNU
162: * Lesser General Public License) licence. You can get a copy of the
163: * license http://www.gnu.org/licenses/licenses.html#LGPL.
164: *
165: * This license allows you to write applications using LibExArg which
166: * are using some GPL compatible license or commercial applications.
167: *
168: */
169:
170: /**
171: * \page exarg_example A simple example on using LibExarg
172: *
173: * \section Introduction
174: *
175: * You may find interesting the following example which makes use of
176: * LibExArg. This example install 3 arguments to be accepted as valid
177: * command line options and the write down to the terminal the result
178: * of those command used by the user.
179: *
180: * Once the arguments are installed, the user can execute
181: *
182: *
183: * \include "test-exarg.c"
184: *
185: */
186:
187: /** \defgroup exarg ExArg module: functions to parse command line argument in your program
188: *
189: */
190:
191: /**
192: * @brief Argument dependency (a list of nodes that each argument has
193: * to define for its dependencies and its mutual exclusions).
194: */
195: typedef struct _ExArgDependency ExArgDependency;
196:
197: struct _ExArgDependency {
198: ExArgNodeOption * node;
199: ExArgDependency * next;
200: };
201:
202:
203: /**
204: * \addtogroup exarg
205: * @{
206: */
207:
208: struct _ExArgNodeOption {
209: /**
210: * @brief Holds the argument name (long value recognized by
211: * --long-option and /long-option).
212: */
213: const char * arg_name;
214: /**
215: * @brief Holds the optional short argument option.
216: */
217: const char * arg_short_name;
218: /**
219: * @brief Argument type.
220: */
221: ExArgType type;
222: /**
223: * @brief Argument description.
224: */
225: const char * description;
226: /**
227: * @brief If the argument is \ref EXARG_STRING, this holds the
228: * string value associated if defined.
229: */
230: char * string_value;
231: /**
232: * @brief If the argument is \ref EXARG_INT, this holds the
233: * int value associated if defined.
234: */
235: int int_value;
236: /**
237: * @brief Boolean value that allows to know if the argument
238: * option was defined
239: */
240: int is_defined;
241:
242: /**
243: * @brief Allows to configure if the provided argument is
244: * optional.
245: */
246: int is_optional;
247:
248: /**
249: * @brief Pointer to the next argument option stored.
250: */
251: ExArgNodeOption * next;
252:
253: /* a reference to the first dependecy argument */
254: ExArgDependency * depends;
255:
256: ExArgDependency * excludes;
257: };
258:
259: struct _ExArgument {
260: /**
261: * @brief The string value that is encapsulated by the
262: * argument.
263: */
264: char * string;
265:
266: /**
267: * @brief A reference to the next argument in the list.
268: */
269: ExArgument * next;
270: };
271:
272:
273: /**
274: * @internal Definition to allocate memory.
275: *
276: * @param type The type to allocate
277: * @param count The amount of memory to allocate.
278: *
279: * @return Returns a newly allocated memory.
280: */
281: #define exarg_new(type, count) (type *) calloc (count, sizeof (type))
282:
283: /**
284: * @internal Definition to dealloc an object.
285: *
286: * @param ref The reference to dealloc.
287: */
288: void exarg_free (epointer ref)
289: {
290: if (ref == NULL)
291: return;
292: free (ref);
293:
294: return;
295: }
296:
297: /**
298: * @internal Allows to get the basename for the file path provided.
299: *
300: * @param file_path The file path that is requested to return the
301: * basename value.
302: *
303: * @return A reference to the basename (the return must not be
304: * dealloc).
305: */
306: const char * exarg_basename (char * file_path)
307: {
308: int iterator = strlen (file_path);
309:
310: while ((iterator != 0) &&
311: (file_path [iterator - 1] != '/') &&
312: (file_path [iterator - 1] != '\\')) {
313: /* decrease iterator */
314: iterator--;
315: }
316:
317: /* return the base name */
318: return file_path + iterator;
319: }
320:
321: /**
322: * @internal Allows to split the provided string using the provided
323: * separators.
324: *
325: * @param chunk The chunk to split.
326: * @param separator_num The number of separators.
327: *
328: * @return A newly allocated set of strings.
329: */
330: char ** exarg_split (const char * chunk, int separator_num, ...)
331: {
332: va_list args;
333: char ** separators;
334: char ** result;
335: int iterator;
336: int index;
337: int previous_index;
338: int count = 0;
339: int length = 0;
340:
341: /* check received values */
342: if (chunk == NULL)
343: return NULL;
344: if (separator_num < 1)
345: return NULL;
346:
347: separators = exarg_new (char *, separator_num + 1);
348: iterator = 0;
349: va_start (args, separator_num);
350:
351: /* get all separators to be used */
352: while (iterator < separator_num) {
353: separators[iterator] = va_arg (args, char *);
354: iterator++;
355: }
356:
357: va_end (args);
358:
359: /* now, count the number of strings that we will get by
360: * separating the string into several pieces */
361: index = 0;
362: while (*(chunk + index) != 0) {
363:
364: /* reset the iterator */
365: iterator = 0;
366: while (iterator < separator_num) {
367:
368: /* compare the current index with the current
369: * separator */
370: length = strlen (separators[iterator]);
371: if (! memcmp (chunk + index, separators[iterator], length)) {
372:
373: /* update items found */
374: count++;
375:
376: /* update index to skip the item found */
377: index += length - 1; /* make the last index to be captured the the -1 */
378:
379: /* break the loop */
380: break;
381: }
382: iterator++;
383: }
384:
385: /* update the index to the next item */
386: index++;
387: }
388:
389: /* create the result that will hold items separated */
390: result = exarg_new (char *, count + 2);
391:
392: /* now copy items found */
393: count = 0;
394: index = 0;
395:
396: /* remember previous_index */
397: previous_index = index;
398: while (*(chunk + index) != 0) {
399:
400: /* reset the iterator */
401: iterator = 0;
402: while (iterator < separator_num) {
403:
404: /* compare the current index with the current
405: * separator */
406: length = strlen (separators[iterator]);
407: if (! memcmp (chunk + index, separators[iterator], length)) {
408:
409: /* copy the chunk found */
410: result[count] = exarg_new (char, index - previous_index + 1);
411: memcpy (result[count], chunk + previous_index, index - previous_index);
412:
413: /* update items found */
414: count++;
415:
416: /* update index to skip the item found */
417: if (*(chunk + index + length) == 0) {
418: /* in the case no more elements to read will be found */
419: /* put an empty space at the end */
420: result [count] = exarg_new (char, 1);
421:
422: exarg_free (separators);
423: return result;
424: }
425:
426: /* remember previous_index */
427: index += length;
428: previous_index = index;
429: index--; /* make the last index to be captured the the -1 */
430: break;
431: }
432: iterator++;
433: }
434:
435: /* update the index to the next item */
436: index++;
437: }
438:
439: /* check for a last chunk */
440: if (index != previous_index) {
441: /* copy the chunk found */
442: result[count] = exarg_new (char, index - previous_index + 1);
443: memcpy (result[count], chunk + previous_index, index - previous_index);
444: }
445:
446:
447: /* release memory */
448: exarg_free (separators);
449:
450: return result;
451: }
452:
453: /**
454: * @internal Proto-type declaration to avoid gcc complaining.
455: */
456: int vsnprintf(char *str, size_t size, const char *format, va_list ap);
457:
458: /**
459: * @internal Allows to calculate the amount of memory required to
460: * store the string that will representing the construction provided
461: * by the printf-like format received and its arguments.
462: *
463: * @param format The printf-like format to be printed.
464: *
465: * @param args The set of arguments that the printf applies to.
466: *
467: * <i><b>NOTE:</b> not all printf specification is supported. Generally, the
468: * following is supported: %s, %d, %f, %g, %ld, %lg and all
469: * combinations that provides precision, number of items inside the
470: * integer part, etc: %6.2f, %+2d, etc. An especial case not supported
471: * is %lld, %llu and %llg.</i>
472: *
473: * @return Return the number of bytes that must be allocated to hold
474: * the string (including the string terminator \0). If the format is
475: * not correct or it is not properly formated according to the value
476: * found at the argument set, the function will return -1.
477: */
478: int exarg_vprintf_len (const char * format, va_list args)
479: {
480: /** IMPLEMENTATION NOTE: in the case this code is update,
481: * update axl_stream_vprintf_len **/
482:
483: # if defined (OS_WIN32) && ! defined (__GNUC__)
484: # if HAVE_VSCPRINTF
485: if (format == NULL)
486: return 0;
487: return _vscprintf (format, args) + 1;
488: # else
489: char buffer[8192];
490: if (format == NULL)
491: return 0;
492: return _vsnprintf (buffer, 8191, format, args) + 1;
493: # endif
494: #else
495: /* gnu gcc case */
496: if (format == NULL)
497: return 0;
498: return vsnprintf (NULL, 0, format, args) + 1;
499:
500: #endif
501: }
502:
503:
504:
505: /**
506: * @internal Allows to produce an string representing the message hold by
507: * chunk with the parameters provided.
508: *
509: * @param chunk The message chunk to print.
510: * @param args The arguments for the chunk.
511: *
512: * @return A newly allocated string.
513: */
514: char * exarg_strdup_printfv (char * chunk, va_list args)
515: {
516: /** IMPLEMENTATION NOTE: place update axl_stream_printf_buffer
517: * code in the case this code is updated **/
518:
519: #ifndef HAVE_VASPRINTF
520: int size;
521: #endif
522: char * result = NULL;
523: int new_size = -1;
524:
525: if (chunk == NULL)
526: return NULL;
527:
528: #ifdef HAVE_VASPRINTF
529: /* do the operation using the GNU extension */
530: new_size = vasprintf (&result, chunk, args);
531: #else
532: /* get the amount of memory to be allocated */
533: size = exarg_vprintf_len (chunk, args);
534:
535: /* check result */
536: if (size == -1) {
537: printf ("error: unable to calculate the amount of memory for the strdup_printf operation");
538: return NULL;
539: } /* end if */
540:
541: /* allocate memory */
542: result = exarg_new (char, size + 2);
543:
544: /* copy current size */
545: #if defined(OS_WIN32) && ! defined (__GNUC__)
546: new_size = _vsnprintf_s (result, size + 1, size, chunk, args);
547: #else
548: new_size = vsnprintf (result, size + 1, chunk, args);
549: #endif
550: #endif
551: /* return the result */
552: return result;
553: }
554:
555: /**
556: * @internal Implementation that allows to produce dinamically
557: * allocated strings using printf-like format.
558: *
559: * @param chunk The chunk representing the format.
560: *
561: * @return An dynamically allocated string.
562: */
563: char * exarg_strdup_printf (char * chunk, ...)
564: {
565: char * result = NULL;
566: va_list args;
567:
568: /* return a null value if null chunk is received */
569: if (chunk == NULL)
570: return NULL;
571:
572: /* open std args */
573: va_start (args, chunk);
574:
575: /* get the string */
576: result = exarg_strdup_printfv (chunk, args);
577:
578: /* close std args */
579: va_end (args);
580:
581: return result;
582: }
583:
584: /**
585: * @internal Allows to copy the given chunk, supposing that is a
586: * properly format C string that ends with a '\\0' value.
587: *
588: * This function allows to perform a copy for the given string. If a
589: * copy limited by a size is required, use \ref axl_stream_strdup_n.
590: *
591: * @param chunk The chunk to copy
592: *
593: * @return A newly allocated string or NULL if fails.
594: */
595: char * exarg_strdup (char * chunk)
596: {
597: char * result;
598: int length;
599:
600: /* do not copy if null reference is received */
601: if (chunk == NULL)
602: return NULL;
603:
604: length = strlen (chunk);
605: result = exarg_new (char, length + 1);
606:
607: memcpy (result, chunk, length);
608:
609: return result;
610: }
611:
612: /**
613: * @internal Internal function that allows to dealloc the provided array of chunks.
614: *
615: * @param chunks An array containing pointers to chunks.
616: */
617: void exarg_freev (char ** chunks)
618: {
619: int iterator = 0;
620:
621: /* return if the received reference is null */
622: if (chunks == NULL)
623: return;
624:
625: /* release memory used by all elements inside the chunk */
626: while (chunks[iterator] != 0) {
627: exarg_free (chunks[iterator]);
628: iterator++;
629: }
630:
631: /* now release the chunk inside */
632: exarg_free (chunks);
633:
634: /* nothing more to do */
635: return;
636: }
637:
638:
639: /**
640: * @internal Adds the argument to the current argument list.
641: *
642: * @param argument The argument to add.
643: */
644: void __exarg_add_argument (char * argument)
645: {
646: ExArgument * arg;
647: ExArgument * arg2;
648:
649: /* creates the node */
650: arg = exarg_new (ExArgument, 1);
651: arg->string = argument;
652:
653: if (params == NULL) {
654: /* basic case, only one argument */
655: params = arg;
656:
657: return;
658: } /* end if */
659:
660: /* complex case, lookup for the last node */
661: arg2 = params;
662: while (arg2->next != NULL)
663: arg2 = arg2->next;
664:
665: /* set the argument on the last position */
666: arg2->next = arg;
667:
668: return;
669: }
670:
671: /**
672: * @internal
673: * @brief Perfom a look up inside the argument option installed.
674: *
675: * This function tries to return the ExArgNodeOption using the given
676: * value as index key.
677: *
678: * The given value can represent the long key option or the short
679: * form.
680: *
681: * @param arg_name the key to use on lookup process
682: *
683: * @return the function retuns the argument option if found or NULL if
684: * not.
685: */
686: ExArgNodeOption * exarg_lookup_node (const char * arg_name)
687: {
688: ExArgNodeOption * result = NULL;
689: int arg_name_len;
690:
691: /* check for null value */
692: if (arg_name == NULL)
693: return NULL;
694:
695: /* get length */
696: arg_name_len = strlen (arg_name);
697:
698: /* look up the item on the current argument option */
699: result = argument_options;
700: while (result != NULL) {
701:
702: /* check value with long argument form */
703: if (arg_name_len == strlen (result->arg_name) &&
704: !memcmp (arg_name, result->arg_name, strlen (arg_name))) {
705:
706: /* return found node */
707: return result;
708: }
709:
710: /* check value with short argument form */
711: if ((result->arg_short_name != NULL) &&
712: (arg_name_len == strlen (result->arg_short_name)) &&
713: !memcmp (arg_name, result->arg_short_name, strlen (arg_name))) {
714:
715: /* return node found */
716: return result;
717: }
718:
719: /* update to the next item */
720: result = result->next;
721:
722: } /* end while */
723:
724: /* return that we didn't found an item */
725: return result;
726:
727: } /* end exarg_lookup_node */
728:
729:
730:
731:
732: int exarg_is_argument (char * argument)
733: {
734:
735: int iterator = 1;
736:
737: /* support standard unix format definition */
738: if (CHECK_PARSE_MODE (PARSE_MODE_UNIX) && !memcmp (argument, "--", 2)) {
739:
740: /* update parse mode */
741: UPDATE_PARSE_MODE (PARSE_MODE_UNIX);
742: return 1;
743: }
744:
745: /* support sort argument format definition */
746: if (CHECK_PARSE_MODE (PARSE_MODE_UNIX) && (strlen (argument) == 2) && (argument[0] == '-')) {
747:
748: /* update parse mode */
749: UPDATE_PARSE_MODE (PARSE_MODE_UNIX);
750:
751: return 1;
752: }
753:
754: /* support windows argument format */
755: if (CHECK_PARSE_MODE (PARSE_MODE_WINDOWS) && (strlen (argument) > 2) && (argument[0] == '/')) {
756:
757: /* now check if the argument doesn't have more bars */
758: while (argument[iterator] != 0) {
759: /* check value */
760: if (argument[iterator] == '/')
761: return 0;
762:
763: /* update iterator */
764: iterator++;
765:
766: } /* end while */
767:
768: /* update parse mode */
769: UPDATE_PARSE_MODE (PARSE_MODE_WINDOWS);
770:
771: return 1;
772: }
773:
774: return 0;
775: }
776:
777: char * exarg_get_argument (char * argument)
778: {
779: /* support getting the argument value for unix standard
780: * argument */
781: if (!memcmp (argument, "--", 2))
782: return &(argument[2]);
783:
784: /* support getting the argument value for short def */
785: if ((strlen (argument) == 2) && (argument[0] == '-'))
786: return &(argument[1]);
787:
788: /* support getting the argument value for windows def */
789: if ((strlen (argument) > 2) && (argument[0] == '/'))
790: return &(argument[1]);
791:
792: return NULL;
793: }
794:
795: int exarg_check_help_argument (char * argument)
796: {
797: if (!memcmp (argument, "help", 4) || !memcmp (argument, "?", 1))
798: return 1;
799: return 0;
800: }
801:
802: void exarg_wrap_and_print (const char * text, int size_to_wrap, const char * fill_text)
803: {
804: char ** stringv = NULL;
805: int i = 0;
806: int sum = 0;
807: char * working_line = NULL;
808: char * aux_string = NULL;
809: int first_line = 1;
810:
811: /* do not print anything if a null value is received */
812: if (text == NULL)
813: return;
814:
815: if (strlen (text) <= size_to_wrap) {
816: printf ("%s\n", text);
817: return;
818: }
819:
820: stringv = exarg_split (text, 1, " ");
821: for (i = 0; stringv[i]; i++) {
822: if (working_line) {
823: aux_string = working_line;
824: working_line = exarg_strdup_printf ("%s %s", working_line, stringv[i]);
825: exarg_free (aux_string);
826: }else
827: working_line = exarg_strdup (stringv[i]);
828: sum = sum + strlen (stringv[i]) + 1;
829:
830: if (sum >= size_to_wrap) {
831: sum = 0;
832: if (first_line) {
833: first_line = 0;
834: printf ("%s\n", working_line);
835: }else
836: printf ("%s%s\n", fill_text, working_line);
837: exarg_free (working_line);
838: working_line = NULL;
839: }
840:
841: }
842: if (sum) {
843: printf ("%s%s\n", fill_text, working_line);
844: exarg_free (working_line);
845: }
846: exarg_freev (stringv);
847:
848:
849: return;
850: }
851:
852: void __exarg_show_usage_foreach (epointer key, epointer value, epointer user_data)
853: {
854: char ** string_aux = (char **) user_data;
855: char * str = (* string_aux);
856: char * aux = NULL;
857: ExArgNodeOption * node = (ExArgNodeOption *) value;
858:
859: switch (node->type) {
860: case EXARG_NONE:
861: if (node->arg_short_name)
862: (*string_aux) = exarg_strdup_printf (" [-%s|--%s]", node->arg_short_name, node->arg_name);
863: else
864: (*string_aux) = exarg_strdup_printf (" [--%s]", node->arg_name);
865: break;
866: case EXARG_INT:
867: if (node->arg_short_name)
868: (*string_aux) = exarg_strdup_printf (" [-%s <number>|--%s <number>]", node->arg_short_name, node->arg_name);
869: else
870: (*string_aux) = exarg_strdup_printf (" [--%s <number>]", node->arg_name);
871: break;
872: case EXARG_STRING:
873: if (node->arg_short_name)
874: (*string_aux) = exarg_strdup_printf (" [-%s <string>|--%s <string>]", node->arg_short_name, node->arg_name);
875: else
876: (*string_aux) = exarg_strdup_printf (" [--%s <string>]", node->arg_name);
877: break;
878: } /* end switch */
879:
880: if (str != NULL) {
881: /* get a reference to previous content */
882: aux = (* string_aux);
883: (*string_aux) = exarg_strdup_printf ("%s%s", str, (*string_aux));
884:
885: /* dealloc both pieces that joined are the result */
886: exarg_free (str);
887: exarg_free (aux);
888: }
889: return;
890: }
891:
892: void exarg_show_usage (int show_header)
893: {
894: char * string_aux = NULL;
895: ExArgNodeOption * node;
896:
897: if (show_header && (__exarg_usage_header && (* __exarg_usage_header)))
898: printf (__exarg_usage_header);
899:
900: printf ("Usage: %s ", exarg_exec_name);
901:
902: /* get the first node */
903: node = argument_options;
904: while (node != NULL) {
905: /* call to the foreach function */
906: __exarg_show_usage_foreach ((epointer) node->arg_name, node, &string_aux);
907:
908: /* update to the next */
909: node = node->next;
910:
911: } /* end while */
912:
913: exarg_wrap_and_print (string_aux, 55, " ");
914: printf ("\n");
915:
916: /* free string created */
917: exarg_free (string_aux);
918:
919: if (show_header && (__exarg_post_usage_header && (* __exarg_post_usage_header)))
920: printf (__exarg_post_usage_header);
921:
922: return;
923: }
924:
925: char * __exarg_build_dep_string (ExArgNodeOption * node, int exclude)
926: {
927: char * result;
928: char * aux;
929: ExArgDependency * dep;
930:
931: /* check node dependency */
932: if (!exclude && ! node->depends)
933: return NULL;
934: if (exclude && ! node->excludes)
935: return NULL;
936:
937: if (exclude)
938: result = exarg_strdup ("[excludes: ");
939: else
940: result = exarg_strdup ("[depends on: ");
941:
942: /* foreach each dependency configured */
943: if (exclude)
944: dep = node->excludes;
945: else
946: dep = node->depends;
947: while (dep != NULL) {
948:
949: aux = result;
950: if (dep->next != NULL)
951: result = exarg_strdup_printf ("%s --%s", result, dep->node->arg_name);
952: else
953: result = exarg_strdup_printf ("%s --%s]", result, dep->node->arg_name);
954: exarg_free (aux);
955:
956: /* get next dependency */
957: dep = dep->next;
958:
959: } /* end while */
960:
961: /* return string created */
962: return result;
963: }
964:
965: void __exarg_show_help_foreach (epointer key, epointer value, epointer user_data)
966: {
967: ExArgNodeOption * node = (ExArgNodeOption *) value;
968: char * dep;
969: int chars = 35;
970: int iterator = 0;
971:
972: /* print argument help */
973: if (node->arg_short_name) {
974: printf (" -%s, --%-18s ",
975: node->arg_short_name, node->arg_name);
976: exarg_wrap_and_print (node->description, 40, " ");
977:
978: }else {
979: printf (" --%-22s ", node->arg_name);
980: exarg_wrap_and_print (node->description, 40, " ");
981: }
982:
983: /* print argument dependency */
984: dep = __exarg_build_dep_string (node, 0);
985: if (dep != NULL) {
986: /* write spaces */
987: while (iterator < chars) {
988: printf (" ");
989: iterator++;
990: }
991: exarg_wrap_and_print (dep, 40, " ");
992: }
993: exarg_free (dep);
994:
995: /* print argument exclusion */
996: iterator = 0;
997: dep = __exarg_build_dep_string (node, 1);
998: if (dep != NULL) {
999: /* write spaces */
1000: while (iterator < chars) {
1001: printf (" ");
1002: iterator++;
1003: }
1004: exarg_wrap_and_print (dep, 40, " ");
1005: }
1006: exarg_free (dep);
1007: return;
1008: }
1009:
1010: void exarg_show_help ()
1011: {
1012: ExArgNodeOption * node;
1013:
1014: if (__exarg_help_header && (* __exarg_help_header))
1015: printf (__exarg_help_header);
1016:
1017: exarg_show_usage (0);
1018:
1019: printf ("\nCommand options:\n");
1020:
1021: /* get first node */
1022: node = argument_options;
1023: while (node != NULL) {
1024: /* call to show the node information */
1025: __exarg_show_help_foreach ((epointer) node->arg_name, node, NULL);
1026:
1027: /* update to the next node */
1028: node = node->next;
1029: } /* end while */
1030:
1031: printf ("\nHelp options:\n");
1032: printf (" -?, --help Show this help message.\n");
1033: printf (" --usage Display brief usage message.\n");
1034:
1035: if (__exarg_post_help_header && (* __exarg_post_help_header))
1036: printf (__exarg_post_help_header);
1037:
1038: return;
1039: }
1040:
1041: void exarg_check_argument_value (char ** argv, int iterator)
1042: {
1043:
1044: if (argv[iterator] == NULL) {
1045: printf ("error: not defined value for argument: %s, exiting..",
1046: argv[iterator - 1]);
1047: fflush (stdout);
1048: exit (-1);
1049: }
1050:
1051: if (exarg_is_argument (argv[iterator])) {
1052: printf ("error: not defined value for argument: %s, instead found another argument: %s, exiting..",
1053: argv[iterator - 1],
1054: argv[iterator]);
1055: fflush (stdout);
1056: exit (-1);
1057: }
1058:
1059: return;
1060: }
1061:
1062:
1063: void __exarg_parse_check_non_optional ()
1064: {
1065: ExArgNodeOption * node = argument_options;
1066:
1067: /* for each node */
1068: while (node != NULL) {
1069: /* check the node */
1070: if (! node->is_optional && ! node->is_defined) {
1071: exarg_msg ("error: argument '%s' is not defined, but it is required for a proper function..\n",
1072: node->arg_name);
1073: } /* end if */
1074:
1075: /* get the next */
1076: node = node->next;
1077:
1078: } /* end while */
1079:
1080: return;
1081: }
1082:
1083: void __exarg_parse_check_depends ()
1084: {
1085: /* first argument */
1086: ExArgNodeOption * node = argument_options;
1087: ExArgDependency * dep;
1088:
1089: /* for each argument defined */
1090: while (node != NULL) {
1091:
1092: /* check if the argument was defined, and hence
1093: * activates its dependencies */
1094: if (! node->is_defined) {
1095: node = node->next;
1096: continue;
1097: }
1098:
1099: /* check depends */
1100: dep = node->depends;
1101: while (dep != NULL) {
1102:
1103: /* check that the dependency is defined */
1104: if (! dep->node->is_defined) {
1105: exarg_msg ("You must define argument (--%s) if used (--%s). Try %s --help.",
1106: dep->node->arg_name, node->arg_name, exarg_exec_name);
1107: return;
1108: } /* end if */
1109:
1110: /* get next dependency */
1111: dep = dep->next;
1112:
1113: } /* end while */
1114:
1115: /* check depends */
1116: dep = node->excludes;
1117: while (dep != NULL) {
1118:
1119: /* check that the dependency is defined */
1120: if (dep->node->is_defined) {
1121: printf ("You can't define argument (--%s) if used (--%s). Try %s --help.\n",
1122: node->arg_name, dep->node->arg_name, exarg_exec_name);
1123: fflush (stdout);
1124: return;
1125: } /* end if */
1126:
1127: /* get next dependency */
1128: dep = dep->next;
1129:
1130: } /* end while */
1131:
1132: /* get next node */
1133: node = node->next;
1134:
1135: } /* end whle */
1136:
1137: /* nothing more to check */
1138: return;
1139: }
1140:
1141:
1142: /**
1143: * \brief Makes exarg to start parsing argument options.
1144: *
1145: * Makes LibExArg to start command line parsing by using arguments
1146: * installed.
1147: *
1148: * Once this functions is called it is posible to call the set of
1149: * function which returns data obtained: \ref exarg_is_defined,
1150: * \ref exarg_get_int, \ref exarg_get_string and \ref exarg_get_params.
1151: *
1152: * The advantage is that LibExArg allows you to get access to command
1153: * line data from any point of your program.
1154: *
1155: * @param argc the argc value the current application have received.
1156: * @param argv the argv value the current application have received.
1157: */
1158: void exarg_parse (int argc,
1159: char ** argv)
1160: {
1161: int iterator = 1;
1162: ExArgNodeOption * node;
1163: char * argument;
1164:
1165: /* check how many argument have been defined */
1166: if (iterator == argc) {
1167: /* once terminated, check if the non optional options
1168: * were defined */
1169:
1170: __exarg_parse_check_non_optional ();
1171: return;
1172: }
1173:
1174: exarg_exec_name = exarg_basename (argv[0]);
1175:
1176: /* iterate over all arguments */
1177: while (iterator < argc) {
1178:
1179: if (!exarg_is_argument (argv[iterator])) {
1180: /* check free argument configuration */
1181: if (__exarg_disable_free_args) {
1182: exarg_msg ("error: provided a free argument='%s', not listed in the accept command line option", argv[iterator]);
1183:
1184: } /* end if */
1185:
1186: /* save and increase iterator */
1187: __exarg_add_argument (argv[iterator]);
1188: iterator++;
1189: continue;
1190: }
1191:
1192: /* get clean argument */
1193: argument = exarg_get_argument (argv[iterator]);
1194:
1195: /* check for help argument */
1196: if (exarg_check_help_argument (argument)){
1197: exarg_show_help ();
1198: exarg_end ();
1199: exit (0);
1200: }
1201:
1202: /* check for usage argument */
1203: if (!memcmp (argument, "usage", 5)) {
1204: exarg_show_usage (1);
1205: exarg_end ();
1206: exit (0);
1207: }
1208:
1209: /* get node argument */
1210: node = exarg_lookup_node (argument);
1211: if (node == NULL) {
1212: exarg_msg ("%s error: argument not found: %s, try: %s --help\n",
1213: exarg_exec_name, argv[iterator], exarg_exec_name);
1214: }
1215:
1216: /* check if node is defined */
1217: if (node->is_defined) {
1218: exarg_msg ("%s error: argument %s already defined, exiting..\n",
1219: exarg_exec_name, argv[iterator]);
1220: }
1221:
1222:
1223: /* set this argument to be defined */
1224: node->is_defined = 1;
1225: switch (node->type) {
1226: case EXARG_NONE:
1227: /* nothing to do */
1228: break;
1229: case EXARG_INT:
1230: /* save int value */
1231: iterator++;
1232:
1233: exarg_check_argument_value (argv, iterator);
1234:
1235: node->int_value = atoi (argv[iterator]);
1236: break;
1237: case EXARG_STRING:
1238: iterator++;
1239:
1240: exarg_check_argument_value (argv, iterator);
1241:
1242: node->string_value = argv[iterator];
1243:
1244: break;
1245: }
1246:
1247: /* update iterator */
1248: iterator++;
1249: }
1250:
1251: /* once terminated, check if the non optional options were
1252: * defined */
1253: __exarg_parse_check_non_optional ();
1254:
1255: /* check argument dependency and argument mutual exclusion. */
1256: __exarg_parse_check_depends ();
1257:
1258: return;
1259: }
1260:
1261: void __exarg_end_free_dep (ExArgDependency * dep)
1262: {
1263: ExArgDependency * next;
1264:
1265: /* foreach dependency established */
1266: while (dep != NULL) {
1267:
1268: /* free the dep node */
1269: next = dep->next;
1270: exarg_free (dep);
1271: dep = next;
1272: } /* end while */
1273:
1274: return;
1275: }
1276:
1277: /**
1278: * \brief Ends exarg library execution.
1279: *
1280: * Terminates the exarg function. This function will free all
1281: * resources allocated so the library cannot be used any more for the
1282: * current execution.
1283: *
1284: * This function is reatrant. Several threads can actually call this
1285: * function. It will take care about making only one thread to
1286: * actually free resources.
1287: **/
1288: void exarg_end ()
1289: {
1290: ExArgNodeOption * node;
1291: ExArgNodeOption * node2;
1292:
1293: ExArgument * params2;
1294:
1295:
1296: if (argument_options != NULL) {
1297: /* get a reference to the table, and dealloc it */
1298: node = argument_options;
1299: argument_options = NULL;
1300:
1301: while (node != NULL) {
1302: /* get a reference to the next */
1303: node2 = node->next;
1304:
1305: /* free node arguments dependencies and mutual
1306: * exclusions */
1307: __exarg_end_free_dep (node->depends);
1308: __exarg_end_free_dep (node->excludes);
1309:
1310: /* free current node */
1311: exarg_free (node);
1312:
1313: /* update the node ref */
1314: node = node2;
1315: } /* end while */
1316:
1317: } /* end if */
1318:
1319: if (params != NULL) {
1320: while (params != NULL) {
1321: /* get a reference to the next node */
1322: params2 = params->next;
1323:
1324: /* free params node */
1325: exarg_free (params);
1326:
1327: /* configure the next argument to dealloc */
1328: params = params2;
1329: } /* end while */
1330: } /* end if */
1331:
1332: return;
1333: }
1334:
1335: /**
1336: * \brief Disable autohelp.
1337: *
1338: * Allows to disable auto help and --help and -? option
1339: * recognition. This is useful if you don't want your program to
1340: * accept --help and --usage options.
1341: **/
1342: void exarg_disable_help ()
1343: {
1344: return;
1345: }
1346:
1347: /**
1348: * \brief Adds user defined header to automatic usage command generated.
1349: *
1350: * Once a program is linked to libexarg is able to produce a usage
1351: * help by accepting the --usage command line option. But that usage
1352: * help is showed as is. This function allows you to define a header
1353: * to be showed preceding the usage info. You can use this, for
1354: * example, to introduce your copyright.
1355: *
1356: * This function doesn't make a copy of the given string so you
1357: * must not free the header provided or use an static string.
1358: **/
1359: void exarg_add_usage_header (char * header)
1360: {
1361: __exarg_usage_header = header;
1362: }
1363:
1364: /**
1365: * \brief Adds user defined header to automatic help command generated.
1366: *
1367: * Once a program is linked to libexarg is able to produce a help by
1368: * accepting the --help or -? command line option. But that help is
1369: * showed as is. This function allows you to define a header to be
1370: * showed preceding the help info. You can use this, for example, to
1371: * introduce your copyright.
1372: *
1373: * This function doesn't make a copy of the given string so you
1374: * must not free the header provided or use an static string.
1375: **/
1376: void exarg_add_help_header (char * header)
1377: {
1378: __exarg_help_header = header;
1379: }
1380:
1381: /**
1382: * \brief Adds user defined post header for usage command.
1383: *
1384: * This function works pretty much like \ref exarg_add_usage_header but
1385: * adding the header provided to be appended at the end of the usage
1386: * automatically generated.
1387: **/
1388: void exarg_post_usage_header (char * post_header)
1389: {
1390: __exarg_post_usage_header = post_header;
1391: }
1392:
1393: /**
1394: * \brief Adds user defined post header for help command.
1395: *
1396: * This function works pretty much like \ref exarg_add_help_header but
1397: * adding the header provided to be appended at the end of the help
1398: * automatically generated.
1399: **/
1400: void exarg_post_help_header (char * post_header)
1401: {
1402: __exarg_post_help_header = post_header;
1403: }
1404:
1405: /**
1406: * \internal
1407: * Internal ExArg function. This function allows \ref exarg_install_arg to
1408: * check if there are already installed an short argument as the one
1409: * been installed.
1410: **/
1411: void __exarg_check_short_arg (epointer key, epointer value, epointer user_data)
1412: {
1413: ExArgNodeOption * node = (ExArgNodeOption *) value;
1414: char * arg_to_check = (char *) user_data;
1415:
1416: if (node->arg_short_name != NULL) {
1417: if (!memcmp (node->arg_short_name, arg_to_check, strlen (arg_to_check))) {
1418: exarg_msg ("error: found that short arg installed is already found: %s\n", arg_to_check);
1419: } /* end if */
1420: } /* end if */
1421:
1422: return;
1423: }
1424:
1425: /**
1426: * \brief Installs a new command line to be accepted.
1427: *
1428: * This functions allows you to install new arguments to be
1429: * accepted. Every argument passed in to the program which is not
1430: * installed throught this function will no be accepted and will
1431: * generate a non recognized command line error.
1432: *
1433: * Let's see an example on how to use exarg to install the --version
1434: * argument. You should call exarg as follows:
1435: *
1436: * \code
1437: * exarg_install_arg ("version", "v", EXARG_NONE,
1438: * "show program version");
1439: *
1440: * \endcode
1441: *
1442: * Previous line have installed a argument called "version" which will
1443: * be invoked by the user as --version. The short alias
1444: * in this case is "v" which as we have see will allow user to invoke
1445: * your program as -v.
1446: *
1447: * Because you could install arguments which may conflict, this
1448: * function will abort the program execution on that case. This will
1449: * ensure you, as programer, to have a binary compiled with no
1450: * problems due to exarg.
1451: *
1452: * Later on, you can use \ref exarg_is_defined to check the status of
1453: * installed arguments. Once you install an argument the user may
1454: * invoke it and you could check that status using previous
1455: * function. Because the "version" argument type is \ref EXARG_NONE you can
1456: * only use \ref exarg_is_defined. But, for other argument types as
1457: * \ref EXARG_STRING, you can also use \ref exarg_get_string function to get the
1458: * value defined by user. Let's see an example.
1459: *
1460: * \code
1461: * exarg_install_arg ("load-library", "l", EXARG_STRING,
1462: * "loads the library defined as argument");
1463: * \endcode
1464: *
1465: * This previous line will allow user to invoke your program as
1466: * --load-library path/to/lib. Then you can use \ref exarg_get_string to get
1467: * the path/to/lib value by using:
1468: *
1469: * \code
1470: * // check user have defined this argument
1471: * if (exarg_is_defined ("load-library")) {
1472: *
1473: * arg_value = exarg_get_string ("load-library");
1474: *
1475: * printf ("The library defined by user was: %s\n",
1476: * arg_value);
1477: * }
1478: *
1479: * \endcode
1480: *
1481: * You must install all argument before calling \ref exarg_parse. That function
1482: * will parse argument options by using installed arguments. Check the info
1483: * about that function.
1484: *
1485: * ExArg is not thread-safe which doesn't means anything wrong but you
1486: * must call all exarg function from the same thread to get the right
1487: * results.
1488: *
1489: * This function will not do a copy from arg_name, arg_short_name or
1490: * description. This means you should not free that values while
1491: * using exarg. To end exarg using check \ref exarg_end. It is recomended to use
1492: * static values and shows on previous examples.
1493: **/
1494: void exarg_install_arg (const char * arg_name,
1495: const char * arg_short_name,
1496: ExArgType type,
1497: const char * description)
1498: {
1499: ExArgNodeOption * node;
1500: ExArgNodeOption * node2;
1501:
1502: /* init hash table */
1503: if (argument_options != NULL) {
1504: /* check if there are an argument with the same name */
1505: if (exarg_lookup_node (arg_name)) {
1506: exarg_end ();
1507: exarg_msg ("error: argument being installed is already defined: %s..",
1508: arg_name);
1509: }
1510:
1511: /* check if there are an shor argument with the same
1512: * name */
1513: if (arg_short_name != NULL) {
1514: node = argument_options;
1515:
1516: /* while there are options to process */
1517: while (node != NULL) {
1518: /* call to check */
1519: __exarg_check_short_arg ((epointer) node->arg_name, node, (epointer) arg_short_name);
1520:
1521: /* update to the next */
1522: node = node->next;
1523: } /* end while */
1524: } /* end if */
1525: } /* end if */
1526:
1527: /* create node option */
1528: node = exarg_new (ExArgNodeOption, 1);
1529: node->arg_name = arg_name;
1530: node->arg_short_name = arg_short_name;
1531: node->type = type;
1532: node->description = description;
1533: node->is_optional = 1;
1534:
1535: /* lookup for the last position */
1536: if (argument_options == NULL)
1537: argument_options = node;
1538: else {
1539: /* lookup for the last */
1540: node2 = argument_options;
1541: while (node2->next != NULL)
1542: node2 = node2->next;
1543:
1544: /* set it */
1545: node2->next = node;
1546: } /* end if */
1547:
1548: return;
1549: }
1550:
1551: /**
1552: * \brief Installs several command lines to be accepted.
1553: *
1554: * This function does the same that \ref exarg_install_arg but making
1555: * group of argument to be installed in one step.
1556: *
1557: * Think about installing two argument. To install them we have to do
1558: * the following:
1559: *
1560: * \code
1561: * exarg_install_arg ("version", "v",
1562: * EXARG_NONE, "show argument version");
1563: * exarg_install_arg ("load-library", "l",
1564: * EXARG_STRING, "load my library");
1565: * \endcode
1566: *
1567: * Because some people doesn't like to perform several calls to the
1568: * same funcion the previous code can be done by using one step as:
1569: *
1570: * \code
1571: * exarg_install_argv (2, "version", "v", EXARG_NONE,
1572: * "show argument version",
1573: * "load-library", "l",
1574: * EXARG_STRING, "load my library");
1575: * \endcode
1576: *
1577: * When you install argument this way you have to specify how many
1578: * argument is going to be installed. In this case that number is
1579: * 2. This allows exarg to know how many arguments needs to search
1580: * inside the argv. If something is wrong while specifying the number
1581: * or argument or the argument information itself you'll get a
1582: * segmentation fault or something similar.
1583: *
1584: * While calling to \ref exarg_install_arg the short_name argument can be
1585: * optional. This is *NOT* applied to this function. If you don't want
1586: * to define a short argument name you must use NULL as value.
1587: *
1588: * @param num_arg Must be at least 1 or error will happen and library will abort
1589: * application execution.
1590: **/
1591: void exarg_install_argv (int num_arg, ...)
1592: {
1593: va_list args;
1594: int iterator;
1595: char * arg_name;
1596: char * arg_short_name;
1597: ExArgType type;
1598: char * description;
1599:
1600: if (num_arg <= 0) {
1601: exarg_end ();
1602: exarg_msg ("error: calling to exarg_install_argv with num_arg equal or less to 0..");
1603: }
1604:
1605: va_start (args, num_arg);
1606:
1607: for (iterator = 0; iterator < num_arg; iterator++) {
1608:
1609: /* get the argument info */
1610: arg_name = va_arg (args, char *);
1611: arg_short_name = va_arg (args, char *);
1612: type = va_arg (args, ExArgType);
1613: description = va_arg (args, char *);
1614:
1615: exarg_install_arg (arg_name, arg_short_name, type, description);
1616: }
1617: va_end (args);
1618: return;
1619: }
1620:
1621: /**
1622: * @brief Allows to define a parameter dependency between the to
1623: * arguments defined. The kind of dependency has direction. This means
1624: * that the first argument will depend on the second argument, forcing
1625: * the user to define the second argument if the first one is defined.
1626: *
1627: * You can call to this function several times making the first
1628: * argument to depend on any number of argument defined. You must not
1629: * call to establish a dependency to the argument itself.
1630: *
1631: * @param arg_name The argument that will be configured with an
1632: * argument dependency.
1633: *
1634: * @param arg_dependency The argument that will receive the
1635: * dependency.
1636: *
1637: *
1638: */
1639: void exarg_add_dependency (const char * arg_name,
1640: const char * arg_dependency)
1641: {
1642: ExArgNodeOption * node;
1643: ExArgNodeOption * node2;
1644: ExArgDependency * dep;
1645: /* check arguments received */
1646: if (arg_name == NULL)
1647: return;
1648: if (arg_dependency == NULL)
1649: return;
1650:
1651: /* check that both arguments aren't equal */
1652: if (strlen (arg_name) == strlen (arg_dependency) &&
1653: !memcmp (arg_name, arg_dependency, strlen (arg_name))) {
1654: exarg_msg ("error: defined argument dependency with an argument itself.");
1655: return;
1656: }
1657:
1658: /* locates the argument node */
1659: node = exarg_lookup_node (arg_name);
1660: if (node == NULL) {
1661: exarg_msg ("error: you did especify an argument that doesn't exists (%s)", arg_name);
1662: return;
1663: }
1664:
1665: /* locates dependecy argument node */
1666: node2 = exarg_lookup_node (arg_dependency);
1667: if (node2 == NULL) {
1668: exarg_msg ("error: you did especify an argument that doesn't exists (%s)", arg_dependency);
1669: return;
1670: }
1671:
1672: /* make the first argument to depend on the second */
1673: dep = node->depends;
1674:
1675: /* create the new dependency node */
1676: node->depends = exarg_new (ExArgDependency, 1);
1677: node->depends->node = node2;
1678: node->depends->next = dep;
1679:
1680: return;
1681: }
1682:
1683: /**
1684: * @brief Allows to configure arguments that are mutually
1685: * excluyents. This function will take the first arguments to be
1686: * muatually excluyen with the second one without direction as it
1687: * happens with \ref exarg_add_dependency function.
1688: *
1689: * Once defined both arguments provided can't be defined at the same
1690: * time at the command line options.
1691: *
1692: * @param arg_name The first argument to make mutual exclusion with
1693: * the second argument.
1694: *
1695: * @param arg_excluded Second argument to make mutual exclusion with
1696: * the first argument.
1697: */
1698: void exarg_add_exclusion (const char * arg_name,
1699: const char * arg_excluded)
1700: {
1701: ExArgNodeOption * node;
1702: ExArgNodeOption * node2;
1703: ExArgDependency * dep;
1704:
1705: /* check arguments received */
1706: if (arg_name == NULL)
1707: return;
1708:
1709: if (arg_excluded == NULL)
1710: return;
1711:
1712: /* check that both arguments aren't equal */
1713: if (strlen (arg_name) == strlen (arg_excluded) &&
1714: !memcmp (arg_name, arg_excluded, strlen (arg_name))) {
1715: exarg_msg ("error: defined argument dependency with an argument itself.");
1716: return;
1717: }
1718:
1719: /* locates the argument node */
1720: node = exarg_lookup_node (arg_name);
1721: if (node == NULL) {
1722: exarg_msg ("error: you did especify an argument that doesn't exists (%s)", arg_name);
1723: return;
1724: }
1725:
1726: /* locates dependecy argument node */
1727: node2 = exarg_lookup_node (arg_excluded);
1728: if (node2 == NULL) {
1729: exarg_msg ("error: you did especify an argument that doesn't exists (%s)", arg_excluded);
1730: return;
1731: }
1732:
1733: /* make the first argument to depend on the second */
1734: dep = node->excludes;
1735:
1736: /* create the new dependency node */
1737: node->excludes = exarg_new (ExArgDependency, 1);
1738: node->excludes->node = node2;
1739: node->excludes->next = dep;
1740:
1741: return;
1742: }
1743:
1744:
1745: /**
1746: * @brief Makes an argument installed to be obligatory (not optional
1747: * at the user command line input).
1748: *
1749: * Once called \ref exarg_install_arg, you can use this function to
1750: * make the program to make the option obligatory.
1751: *
1752: * @param arg_name The argument to make it obligatory.
1753: */
1754: void exarg_set_obligatory (char * arg_name)
1755: {
1756: ExArgNodeOption * node;
1757:
1758: /* perform some environment checks */
1759: if (arg_name == NULL)
1760: return;
1761:
1762: node = exarg_lookup_node (arg_name);
1763: if (node == NULL) {
1764: return;
1765: }
1766:
1767: /* make it to be defined */
1768: node->is_optional = 0;
1769:
1770: return;
1771: }
1772:
1773:
1774: /**
1775: * @brief Allows to configure exarg library to accept or not free
1776: * arguments.
1777: *
1778: * Free arguments are optional parameters provided to the application,
1779: * such files, which aren't associated to a particular option.
1780: *
1781: * If your command line application do not uses free arguments, you
1782: * can use this function to enable exarg library to show an error
1783: * message to the user:
1784: *
1785: * \code
1786: * // disable free arguments
1787: * exarg_accept_free_args (0);
1788: * \endcode
1789: *
1790: * @param accept 1 to accept free arguments. It is the default value,
1791: * so it is not required to enable it. 0 to disable free arguments.
1792: */
1793: void exarg_accept_free_args (int accept)
1794: {
1795: /* configure free arguments */
1796: __exarg_disable_free_args = (accept == 0);
1797:
1798: return;
1799: }
1800:
1801: /**
1802: * @brief Allows to simulate user defined command line options alread
1803: * installed by \ref exarg_install_arg, without requiring the user to
1804: * set those values.
1805: *
1806: * This function allows to install values received or to just define
1807: * the argument to be supported by the program, without requiring the
1808: * user to provide such option. This is a convenient to make some
1809: * options to be default, writting your application relying on
1810: * arguments defined by command line.
1811: *
1812: * The function won't define the argument if not installed
1813: * previously. If the argument isn't found, the function takes no
1814: * action.
1815: *
1816: * @param arg_name The argument o define as provided by the user.
1817: * @param value The value to be associated to the argument. Some
1818: * arguments doesn't require this paremeters (\ref EXARG_NONE), so,
1819: * you can provide NULL to this parameter.
1820: */
1821: void exarg_define (char * arg_name,
1822: char * value)
1823: {
1824: ExArgNodeOption * node;
1825:
1826: /* perform some environment checks */
1827: if (arg_name == NULL)
1828: return;
1829:
1830: node = exarg_lookup_node (arg_name);
1831: if (node == NULL) {
1832: return;
1833: }
1834: /* make it to be defined */
1835: node->is_defined = 1;
1836:
1837: /* check argument value */
1838: if (value != NULL) {
1839: switch (node->type) {
1840: case EXARG_NONE:
1841: /* nothing to set */
1842: break;
1843: case EXARG_INT:
1844: /* integer value */
1845: node->int_value = strtol (value, NULL, 10);
1846: break;
1847: case EXARG_STRING:
1848: /* string value */
1849: node->string_value = value;
1850: break;
1851: }
1852: } /* end if */
1853:
1854: /* nothing to do over here */
1855: return;
1856: }
1857:
1858: /**
1859: * \brief Allows to check if a user have defined a command.
1860: *
1861: * Once an argument is installed the user may or may not define it. To
1862: * define it simply means to use this argument as command line
1863: * option. This function allows to check if an argument was used for
1864: * the current command line option.
1865: *
1866: * This function is expecting to receive the argument name to lookup
1867: * not the short name. User may be using the short name to invoke the
1868: * argument but the lookup is allways done by using the argument name.
1869: *
1870: * \return TRUE if argument was defined or FALSE if not.
1871: **/
1872: int exarg_is_defined (char * arg_name)
1873: {
1874: ExArgNodeOption * node;
1875:
1876: /* perform some environment checks */
1877: if (arg_name == NULL)
1878: return 0;
1879:
1880: if (argument_options == NULL)
1881: return 0;
1882:
1883: node = exarg_lookup_node (arg_name);
1884: if (node == NULL) {
1885: return 0;
1886: }
1887: return node->is_defined;
1888: }
1889:
1890: /**
1891: * @brief Allows to check several values to be defined at the same time.
1892: *
1893: * This allows to check if several command line options have been
1894: * defined at the same time.
1895: * Example:
1896: * \code
1897: * if (exarg_is_definedv ("param1", "param2", NULL)) {
1898: * //param1 and param2 have been defined by the user
1899: * }
1900: * \endcode
1901: *
1902: * This is a short way for actually doing:
1903: * \code
1904: * if (exarg_is_defined ("param1") && exarg_is_defined ("param2")) {
1905: * // param1 and para2 have been defined by the user
1906: * }
1907: * \endcode
1908: *
1909: * Do not forget to pass a NULL value for the last item.
1910: *
1911: * @return TRUE if all values are defined, otherwise FALSE.
1912: */
1913: int exarg_is_definedv (char * first_value, ...)
1914: {
1915: int result = 1;
1916: char * string_value;
1917: va_list args;
1918:
1919: if (first_value == NULL)
1920: return 0;
1921:
1922: /* check first value */
1923: if (!exarg_is_defined (first_value))
1924: return 0;
1925:
1926: /* open stdargs */
1927: va_start (args, first_value);
1928: string_value = va_arg (args, char *);
1929:
1930: /* check for last NULL value */
1931: while ((string_value != NULL) && (* string_value)) {
1932: /* check next value */
1933: result = result && exarg_is_defined (string_value);
1934:
1935: /* get next value */
1936: string_value = va_arg (args, char *);
1937: }
1938:
1939: /* return current value */
1940: va_end (args);
1941: return result;
1942: }
1943:
1944: /**
1945: * \brief Allows to get defined string for a given command line.
1946: *
1947: * Returns the value associated with the argument name. The returned
1948: * value must not be deallocated. If it is needed a string copy use
1949: * \ref exarg_get_string_alloc.
1950: *
1951: * \return The value associated with the param or NULL if fail.
1952: **/
1953: char * exarg_get_string (char * arg_name)
1954: {
1955: ExArgNodeOption * node;
1956:
1957: if (arg_name == NULL)
1958: return NULL;
1959:
1960: if (argument_options == NULL)
1961: return NULL;
1962:
1963: node = exarg_lookup_node (arg_name);
1964: if (node == NULL) {
1965: exarg_msg ("error: calling to get string value for: %s, but this argument isn't defined..",
1966: arg_name);
1967: }
1968: if (node->type != EXARG_STRING) {
1969: exarg_msg ("error: calling to get string value for: %s, but the argument wasn't defined as EXARG_STRING..",
1970: arg_name);
1971: }
1972:
1973: return node->string_value;
1974: }
1975:
1976: /**
1977: * \brief Allows to get defined string for a given command line allocating the result.
1978: *
1979: * Returns the value associated with the argument name. The returned
1980: * value must be <b>deallocated</b> using g_free. You can also use
1981: * \ref exarg_get_string to get a value that doesn't need to be
1982: * unrefered.
1983: *
1984: * \return The value associated with the param or NULL if fail.
1985: **/
1986: char * exarg_get_string_alloc (char * arg_name)
1987: {
1988: char * string_value;
1989:
1990: string_value = exarg_get_string (arg_name);
1991: if (string_value == NULL)
1992: return NULL;
1993: return exarg_strdup (string_value);
1994: }
1995:
1996: /**
1997: * \brief Allows to get int value for a given command line argument.
1998: *
1999: * Returns the value associated with the argument name. The returned
2000: * may be 0 which means the user may not defined that argument or may
2001: * defined it by using the 0 as value. To avoid confusing cases you
2002: * should use \ref exarg_is_defined to know if the user have used that
2003: * argument and then call this function.
2004: *
2005: * \return the value defined for this argument. If the argument
2006: * is null or the exarg is not initialized the function will return -1.
2007: **/
2008: int exarg_get_int (char * arg_name)
2009: {
2010: ExArgNodeOption * node;
2011:
2012: if (arg_name == NULL)
2013: return -1;
2014: if (argument_options == NULL)
2015: return -1;
2016:
2017: node = exarg_lookup_node (arg_name);
2018: if (node == NULL) {
2019: exarg_msg ("error: calling to get int value for: %s, but this argument isn't defined..",
2020: arg_name);
2021: }
2022:
2023: if (node->type != EXARG_INT) {
2024: exarg_msg ("error: calling to get int value for: %s, but the argument wasn't defined as EXARG_INT..",
2025: arg_name);
2026: }
2027:
2028: return node->int_value;
2029: }
2030:
2031: /**
2032: * \brief Returns free params defined at command line.
2033: *
2034: * Every value which is not an argument is considered to be a
2035: * parameter. All of them are stored and retrieved by using this
2036: * function and the following functions:
2037: *
2038: * - \ref exarg_param_get
2039: * - \ref exarg_param_next
2040: *
2041: * An example about using this function could be the next. A program
2042: * have defined several arguments using the function \ref
2043: * exarg_install_arg but that program also needs to receive several
2044: * file path.
2045: *
2046: * Once the \ref exarg_parse have detected all argument, all
2047: * parameters are stored, and this function provides access to the
2048: * first argument *found. Then a call to \ref exarg_param_get is
2049: * required to get the *argument value and a call to \ref
2050: * exarg_param_next to get a *reference to the next argument.
2051: *
2052: *
2053: * A program which may receive the argument --save-all but also several
2054: * files:
2055: *
2056: * \code
2057: * a_program --save-all file1 file2 file3
2058: * \endcode
2059: *
2060: * Will need to call this function to get the list: file1 file2 and
2061: * file3.
2062: *
2063: * \return The first param provided to the program. The returned value
2064: * must not be deallocated.
2065: */
2066: ExArgument * exarg_get_params ()
2067: {
2068: return params;
2069: }
2070:
2071: /**
2072: * @brief Allows to get the string value that is represeting the argument received.
2073: *
2074: * @param arg The argument that was received by the program.
2075: *
2076: * @return An string reference that must not be deallocated.
2077: */
2078: const char * exarg_param_get (ExArgument * arg)
2079: {
2080: /* check for null value received */
2081: if (arg == NULL)
2082: return NULL;
2083:
2084: /* return the string value inside */
2085: return arg->string;
2086: }
2087:
2088: /**
2089: * @brief Allows to get the next parameters defined at the command
2090: * line option that is following the argument provided.
2091: *
2092: * @param arg The argument which is previous to the argument to be
2093: * returned.
2094: *
2095: * @return An argument reference to the next or NULL if there are no
2096: * more arguments.
2097: */
2098: ExArgument * exarg_param_next (ExArgument * arg)
2099: {
2100: /* check for null value received */
2101: if (arg == NULL)
2102: return NULL;
2103:
2104: /* return the next argument */
2105: return arg->next;
2106: }
2107:
2108:
2109: /**
2110: * @brief Allows to get the number of parameters that were defined by
2111: * the user.
2112: *
2113: * Check also the following function \ref exarg_get_params_num.
2114: *
2115: * @return The number of parameters starting from 0.
2116: */
2117: int exarg_get_params_num ()
2118: {
2119: ExArgument * arg = NULL;
2120: int result = 0;
2121:
2122: if (params == NULL)
2123: return 0;
2124:
2125: /* count the number of params */
2126: arg = params;
2127: while (arg != NULL) {
2128: /* update the count */
2129: result++;
2130:
2131: /* update to the next */
2132: arg = arg->next;
2133:
2134: } /* end while */
2135:
2136: /* return current count */
2137: return result;
2138: }
2139:
2140: /* @} */
2141:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to exarg.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / gpl / axl / knife