static char **argument_vector;
..............
argument_vector_size = 1;
argument_vector = (char **) malloc (argument_vector_size * sizeof
(char *));

Is there a compiler out there that has different storage size for
pointers and pointers to pointers?

On the other hand, I'd object to the form of the malloc()
invocation.  I don't recommend casting the return value of
malloc():

        * The cast is not required in ANSI C.

        * Casting its return value can mask a failure to #include
          <stdlib.h>, which leads to undefined behavior.

        * If you cast to the wrong type by accident, odd failures can
          result.

When calling malloc(), I recommend using the sizeof operator on
the object you are allocating, not on the type.  For instance,
*don't* write this:

        int *x = malloc (sizeof (int) * 128); /* Don't do this! */

Instead, write it this way:

        int *x = malloc (sizeof *x * 128);

There's a few reasons to do it this way:

        * If you ever change the type that `x' points to, it's not
          necessary to change the malloc() call as well.

          This is more of a problem in a large program, but it's still
          convenient in a small one.

        * Taking the size of an object makes writing the statement
          less error-prone.  You can verify that the sizeof syntax is
          correct without having to look at the declaration.

So I'd write the malloc call as
        argument_vector = malloc (argument_vector_size
                                  * sizeof *argument_vector);

(Oh, and obnit: it's not necessary to cast the result of malloc)

argument_vector = malloc (argument_vector_size * sizeof *
argument_vector);

Consider:

int *ip = malloc(num * sizeof *ip);
char *cp = malloc(num * sizeof *cp);
double *dp = malloc(num *sizeof *dp);

Note that given that argument_vector is a pointer to a pointer to
char, what it points to has sizeof(char *), which is exactly what the
code uses.