«

If main is prototyped as:
int main(int argc, char *argv[]);

You will end up with a bunch of arguments in *argv, and the number in argc. Now
what I want to do is emulate that same action on a string. Say for example I have:

char *command = "./blah --arg1 --arg2 123 -x --arg2=w00t"

How do I acheive the same effect as in main()?


Jeff

Jeff Rodriguez <> writes:

> If main is prototyped as:
> int main(int argc, char *argv[]);
>
> You will end up with a bunch of arguments in *argv, and the number in
> argc. Now what I want to do is emulate that same action on a
> string. Say for example I have:
>
> char *command = "./blah --arg1 --arg2 123 -x --arg2=w00t"
>
> How do I acheive the same effect as in main()?

It depends on the operating system, shell, and other things. If
all you want to do is to break apart the string into words at
white space, I suggest you just write code to do it. It's not
too hard.
--
"Given that computing power increases exponentially with time,
algorithms with exponential or better O-notations
are actually linear with a large constant."
--Mike Lee

Ben Pfaff wrote:

> It depends on the operating system, shell, and other things. If
> all you want to do is to break apart the string into words at
> white space, I suggest you just write code to do it. It's not
> too hard.

Indeed: (crude code)
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
int i;
char *string = NULL;
char *str = NULL;
int size = 0;

for ( i = 1; i < argc; i++ )
{
if ( strlen(argv[i]) > size )
{
if ( (string = realloc(string, (size + strlen(argv[i])) * 2)) == NULL )
{
perror("Could not allocate memory");
exit(1);
}
}

string = strcat(string, argv[i]);
string = strcat(string, " ");
}

printf("%s %s\n", argv[0], string);

str = strtok(string, " \t\n");
printf("%s\n", str);
while ( (str = strtok(NULL, " \t\n")) != NULL )
{
printf("%s\n", str);
}
return 0;
}

However you run into problems like:
../a.out --search="Hello World!"

I would prefer not to have to reinvent the wheel on this since main() already
implements it! There must be /some/ way that it's a built-in function!

Jeff

On Fri, 12 Dec 2003 22:02:24 -0700, Jeff Rodriguez
<> wrote in comp.lang.c:

> Ben Pfaff wrote:
>
> > It depends on the operating system, shell, and other things. If
> > all you want to do is to break apart the string into words at
> > white space, I suggest you just write code to do it. It's not
> > too hard.
>
> Indeed: (crude code)
> #include <stdio.h>
> #include <string.h>
> #include <unistd.h>

The header above is both non-standard and unneeded in your program.

> #include <stdlib.h>
>
> int main(int argc, char *argv[])
> {
> int i;
> char *string = NULL;
> char *str = NULL;
> int size = 0;
>
> for ( i = 1; i < argc; i++ )
> {
> if ( strlen(argv[i]) > size )
> {
> if ( (string = realloc(string, (size + strlen(argv[i])) * 2)) == NULL )
> {
> perror("Could not allocate memory");
> exit(1);
> }
> }
>
> string = strcat(string, argv[i]);

This is quite likely to crash the first time, since the first block
that realloc returns is uninitialized and there's no telling if it
will contain a terminating '\0' at all, let alone in the first
element.

> string = strcat(string, " ");
> }
>
> printf("%s %s\n", argv[0], string);
>
> str = strtok(string, " \t\n");
> printf("%s\n", str);
> while ( (str = strtok(NULL, " \t\n")) != NULL )
> {
> printf("%s\n", str);
> }
> return 0;
> }
>
> However you run into problems like:
> ./a.out --search="Hello World!"
>
> I would prefer not to have to reinvent the wheel on this since main() already
> implements it! There must be /some/ way that it's a built-in function!
>
> Jeff

No, main() does not already implement it. Either the host operating
system or the implementation's start-up code does. There is no C
standard library function to do so.

If you want source code, try Google.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++ ftp://snurse-l.org/pub/acllc-c++/faq

Jeff Rodriguez <> writes:

> I would prefer not to have to reinvent the wheel on this since main()
> already implements it! There must be /some/ way that it's a built-in
> function!

main() doesn't implement this on any system I've used. For
example, under MS-DOS, the arguments are passed to the program as
a single string, and the C library startup routine carves it up
and passes it to main(). As another example, under UNIX-like
systems, the shell does the parsing into arguments and the
program receives them from the OS already in that form. In
neither case is there an easy way for the program to access the
functionality.
--
"I don't have C&V for that handy, but I've got Dan Pop."
--E. Gibbons

Jeff Rodriguez wrote:

> if ( (string = realloc(string, (size + strlen(argv[i])) * 2)) ==
> NULL )
> {
> perror("Could not allocate memory");
> exit(1);
> }

Aside from a few other errors that have already been pointed out, I
don't think you should be calling perror without first checking the
value of errno. I don't know off the top if my head whether realloc is
required to set errno, but my guess is that it is not. If it doesn't,
you may end up getting something like this:

Could not allocate memory: No error

Or something even more confusing, if errno has previously been set by a
different function.

This is also a guaranteed memory leak if realloc fails. The correct way
to use realloc is to store the result into a temporary pointer, and only
assign it to the destination pointer if it is non-null.

Finally, 1 is not a portable exit code. Consider using one of the
portable codes: 0, EXIT_SUCCESS, or EXIT_FAILURE.

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

Kevin Goodsell wrote:
> Jeff Rodriguez wrote:
>
>> if ( (string = realloc(string, (size + strlen(argv[i])) * 2)) ==
>> NULL )
>> {
>> perror("Could not allocate memory");
>> exit(1);
>> }
>
>
> Aside from a few other errors that have already been pointed out, I
> don't think you should be calling perror without first checking the
> value of errno. I don't know off the top if my head whether realloc is
> required to set errno, but my guess is that it is not. If it doesn't,
> you may end up getting something like this:
>
> Could not allocate memory: No error
>
> Or something even more confusing, if errno has previously been set by a
> different function.
>
> This is also a guaranteed memory leak if realloc fails. The correct way
> to use realloc is to store the result into a temporary pointer, and only
> assign it to the destination pointer if it is non-null.
>
> Finally, 1 is not a portable exit code. Consider using one of the
> portable codes: 0, EXIT_SUCCESS, or EXIT_FAILURE.
>
> -Kevin

Not that I typically do the above (note how I said crude code), but how would
this be a guaranteed memory leak? If realloc fails the program exits. I'm not
sure I understand how that would cause a memory leak.

Jeff

Jeff Rodriguez wrote:
> Ben Pfaff wrote:
>
> > It depends on the operating system, shell, and other things. If
> > all you want to do is to break apart the string into words at
> > white space, I suggest you just write code to do it. It's not
> > too hard.
>
> Indeed: (crude code)
> #include <stdio.h>
> #include <string.h>
> #include <unistd.h>

*** Non-existent standard include ***

> #include <stdlib.h>
>
> int main(int argc, char *argv[])
> {
> int i;
> char *string = NULL;

*** Invading the systems name space. Use another id ***

> char *str = NULL;
> int size = 0;
>
> for ( i = 1; i < argc; i++ )
> {
> if ( strlen(argv[i]) > size )
> {
> if ( (string = realloc(string, (size + strlen(argv[i])) * 2)) == NULL )

*** Harmless in this context, but an evil habit ***
Try something like:
if (tmp = realloc(old, (size + strlen(argv[i])) *
2))
old = tmp;
else {
/* failure */
}

> {
> perror("Could not allocate memory");
> exit(1);
> }
> }


--
Chuck F () ()
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

Jeff Rodriguez wrote:

> If main is prototyped as:
> int main(int argc, char *argv[]);
>
> You will end up with a bunch of arguments in *argv, and the number in
> argc. Now what I want to do is emulate that same action on a string. Say
> for example I have:
>
> char *command = "./blah --arg1 --arg2 123 -x --arg2=w00t"
>
> How do I acheive the same effect as in main()?
>
>
> Jeff

A simple hack is to use another C program that simply prints out its command
line arguments to a known file. Then invoke said program with the system
call:

/* assume that our argv printer is called cmdline
and is accessible through a "system" call */
char *command = "./cmdline ./blah --arg1 --arg2 123 -x --arg2=w00t";

system(command);

/* now read the file produced by cmdline to get
argv parsed version of command */

-nrk.

nrk wrote:

> Jeff Rodriguez wrote:
>
>> If main is prototyped as:
>> int main(int argc, char *argv[]);
>>
>> You will end up with a bunch of arguments in *argv, and the number in
>> argc. Now what I want to do is emulate that same action on a string. Say
>> for example I have:
>>
>> char *command = "./blah --arg1 --arg2 123 -x --arg2=w00t"
>>
>> How do I acheive the same effect as in main()?
>>
>>
>> Jeff
>
> A simple hack is to use another C program that simply prints out its
> command line arguments to a known file. Then invoke said program with the
> system call:
>
> /* assume that our argv printer is called cmdline
> and is accessible through a "system" call */
> char *command = "./cmdline ./blah --arg1 --arg2 123 -x
> --arg2=w00t";
>
> system(command);
>
> /* now read the file produced by cmdline to get
> argv parsed version of command */
>
> -nrk.

Just in case you're wondering what an "argv printer" might look like

#include <stdio.h>

int main(int argc, char **argv) {
while ( *argv ) {
printf("%s\n", *argv);
++argv;
}

return 0;
}

If you want one that ignores argv[0]:

#include <stdio.h>

int main(int argc, char **argv) {
if ( argc )
while ( *++argv ) printf("%s\n", argv);

return 0;
}

-nrk.