stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r428559 - /incubator/stdcxx/trunk/util/cmdopt.cpp
Date Thu, 03 Aug 2006 23:10:12 GMT
Author: sebor
Date: Thu Aug  3 16:10:12 2006
New Revision: 428559

URL: http://svn.apache.org/viewvc?rev=428559&view=rev
Log:
2006-08-03  Andrew Black  <ablack@roguewave.com>
	    Martin Sebor  <sebor@roguewave.com>

	* cmdopt.cpp (bad_value, missing_value): New helpers.
	(bad_option): Made pointer const, not the argument.
	(eval_options): Detected and diagnosed invalid or missing
	option arguments and failed calls to kill and sigaction.

Modified:
    incubator/stdcxx/trunk/util/cmdopt.cpp

Modified: incubator/stdcxx/trunk/util/cmdopt.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/util/cmdopt.cpp?rev=428559&r1=428558&r2=428559&view=diff
==============================================================================
--- incubator/stdcxx/trunk/util/cmdopt.cpp (original)
+++ incubator/stdcxx/trunk/util/cmdopt.cpp Thu Aug  3 16:10:12 2006
@@ -129,17 +129,44 @@
 }
 
 /**
-    Helper function to produce 'Unknown option' error message.
+    Helper function to produce 'Bad argument' error message.
+    
+    @param opt name of option encountered
+    @param val invalid value found
+*/
+static void
+bad_value (const char* opt, const char* val)
+{
+    assert (0 != opt);
+
+    terminate (1, "Bad argument for %s: %s\n", opt, val);
+}
+
+/**
+    Helper function to produce 'Missing argument' error message.
     
-    Terminates via show_usage.
+    @param opt name of option missing argument
+*/
+static void
+missing_value (const char* opt)
+{
+    assert (0 != opt);
+
+    terminate (1, "Missing argument for %s\n", opt);
+}
+
+/**
+    Helper function to produce 'Unknown option' error message.
     
     @param opt name of option encountered
 */
 static void
-bad_option (char* const opt)
+bad_option (const char* opt)
 {
     assert (0 != opt);
+
     warn ("Unknown option: %s\n", opt);
+
     show_usage (1);
 }
 
@@ -157,9 +184,17 @@
 int 
 eval_options (const int argc, char* const argv [])
 {
-    int i;
+    const char opt_timeout[]  = "-t";
+    const char opt_data_dir[] = "-d";
+    const char opt_t_flags[]  = "-x";
+    const char opt_compat[]   = "--compat";
+    const char opt_exit[]     = "--exit";
+    const char opt_ignore[]   = "--ignore";
+    const char opt_nocompat[] = "--nocompat";
+    const char opt_signal[]   = "--signal";
+    const char opt_sleep[]    = "--sleep";
 
-    char* val;
+    int i;
 
     assert (0 != argv);
 
@@ -168,6 +203,14 @@
 
     for (i = 1; i < argc && '-' == argv [i][0]; ++i) {
 
+        /* the name of the option being processed */
+        const char* optname = argv [i];
+
+        /* the option's argument, if any */
+        const char* optarg  = 0;
+
+        char* end = 0;
+
         switch (argv [i][1]) {
         case '?':
         case 'h':
@@ -176,16 +219,29 @@
             ++i; /* Ignore -r option (makefile compat) */
             break;
         case 't':
-            val = get_short_val (argv, &i);
-            timeout = strtol (val, &val, 10);
-            if (*val || errno)
-                terminate (1, "Unknown value for -t: %s\n", val);
+            optname = opt_timeout;
+            optarg  = get_short_val (argv, &i);
+            if (optarg) {
+                timeout = strtol (optarg, &end, 10);
+                if (*end || timeout < 0 || errno)
+                    bad_value (optname, optarg);
+            }
+            else
+                missing_value (optname);
+
             break;
+
         case 'd':
+            optname = opt_data_dir;
             in_root = get_short_val (argv, &i);
+            if (!in_root)
+                missing_value (optname);
             break;
         case 'x':
+            optname  = opt_t_flags;
             exe_opts = get_short_val (argv, &i);
+            if (!exe_opts)
+                missing_value (optname);
             break;
         case 'v':
             ++verbose;
@@ -193,6 +249,7 @@
         case 'q':
             verbose = 0;
             break;
+
         case '-':
         {
             const size_t arglen = strlen (argv [i]);
@@ -201,80 +258,85 @@
             if ('\0' == argv [i][2])
                 return i+1;
 
-            if (8 == arglen && 0 == memcmp ("--compat\0", argv [i], 9)) {
-                compat = 1;
+            if (   sizeof opt_compat - 1 == arglen
+                && !memcmp (opt_compat, argv [i], sizeof opt_compat)) {
+                compat  = 1;
                 break;
             }
-            else if (10 == arglen && 0 == memcmp ("--nocompat\0", argv [i], 
-                                                  11)) {
-                compat = 0;
+            else if (   sizeof opt_nocompat - 1 == arglen
+                     && !memcmp (opt_nocompat, argv [i], sizeof opt_nocompat)) {
+                compat  = 0;
                 break;
             }
-            else if (6 <= arglen && 0 == memcmp ("--exit", argv [i], 6)) {
-                val = get_long_val (argv, &i, 6);
-                if (val) {
-                    int code = strtol (val, &val, 10);
-                    if (*val || errno)
-                        terminate (1, "Unknown value for --exit: %s\n", val);
-                    exit (code);
+            else if (   sizeof opt_exit - 1 <= arglen
+                     && !memcmp (opt_exit, argv [i], sizeof opt_exit - 1)) {
+                optname = opt_exit;
+                optarg  = get_long_val (argv, &i, sizeof opt_exit - 1);
+                if (optarg && *optarg) {
+                    const long code = strtol (optarg, &end, 10);
+                    if ('\0' == *end && !errno)
+                        exit (code);
                 }
-                else
-                    bad_option (argv [i]);
             }
-            else if (7 <= arglen && 0 == memcmp ("--sleep", argv [i], 7)) {
-                val = get_long_val (argv, &i, 7);
-                if (val) {
-                    int duration = strtol (val, &val, 10);
-                    if (*val || errno)
-                        terminate (1, "Unknown value for --sleep: %s\n", val);
-                    sleep (duration);
-                    break;
+            else if (   sizeof opt_sleep - 1 <= arglen
+                     && !memcmp (opt_sleep, argv [i], sizeof opt_sleep - 1)) {
+                optname = opt_sleep;
+                optarg  = get_long_val (argv, &i, sizeof opt_sleep - 1);
+                if (optarg && *optarg) {
+                    const long nsec = strtol (optarg, &end, 10);
+                    if ('\0' == *end && 0 <= nsec && !errno) {
+                        sleep (nsec);
+                        break;
+                    }
                 }
-                else
-                    bad_option (argv [i]);
             }
-            else if (8 <= arglen && 0 == memcmp ("--signal", argv [i], 8)) {
-                val = get_long_val (argv, &i, 8);
-                if (val) {
-                    int sig = get_signo (val);
-                    if (0 > sig)
-                        terminate (1, "Unknown signal name for --signal: "
-                                   "%s\n", val);
-                    
-                    /* Ignore kill errors (what should we do with them?) */
-                    (void)kill (getpid (), sig);
-
-                    /* Not certain what we should do if we don't terminate by 
-                       signal */
-                    break;
+            else if (   sizeof opt_signal - 1 <= arglen
+                     && !memcmp (opt_signal, argv [i], sizeof opt_signal - 1)) {
+                optname = opt_signal;
+                optarg  = get_long_val (argv, &i, sizeof opt_signal - 1);
+                if (optarg && *optarg) {
+                    const long signo = get_signo (optarg);
+                    if (0 <= signo) {
+                        if (0 > kill (getpid (), signo))
+                            terminate (1, "kill(%d, %s) failed: %s\n",
+                                       getpid (), get_signame (signo),
+                                       strerror (errno));
+                        break;
+                    }
                 }
-                else
-                    bad_option (argv [i]);
             }
-            else if (8 <= arglen && 0 == memcmp ("--ignore", argv [i], 8)) {
-                val = get_long_val (argv, &i, 8);
-                if (val) {
-                    struct sigaction act;
-                    int sig = get_signo (val);
-                    if (0 > sig)
-                        terminate (1, "Unknown signal name for --ignore: "
-                                   "%s\n", val);
-                    
-                    memset (&act, 0, sizeof act);
-                    act.sa_handler = SIG_IGN;
-                    (void)sigaction (sig, &act, 0);
-                    /* Ignore sigaction errors (what should we do with them?) 
-                     */
-                    break;
+            else if (   sizeof opt_ignore <= arglen
+                     && !memcmp (opt_ignore, argv [i], sizeof opt_ignore - 1)) {
+                optname = opt_ignore;
+                optarg  = get_long_val (argv, &i, sizeof opt_ignore);
+                if (optarg && *optarg) {
+                    const long signo = get_signo (optarg);
+                    if (0 <= signo) {
+                        struct sigaction act;
+                        memset (&act, 0, sizeof act);
+                        act.sa_handler = SIG_IGN;
+                        if (0 > sigaction (signo, &act, 0))
+                            terminate (1, "sigaction(%s, ...) failed: %s\n",
+                                       get_signame (signo), strerror (errno));
+                        break;
+                    }
                 }
-                else
-                    bad_option (argv [i]);
             }
-            else
-                bad_option (argv [i]);
+
+            /* fall through */
         }
         default:
-            bad_option (argv [i]);
+            if (optarg) {
+                if (*optarg)
+                    bad_value (optname, optarg);
+                else
+                    missing_value (optname);
+            }
+
+            if (argv [i])
+                bad_option (argv [i]);
+            else
+                missing_value (optname);
         }
     }
 



Mime
View raw message