C - argc changes with operation - c

Question

for some reason my argc argument changes from 4 to 6 if instead of "a+bi + c+di" I write "a+bi * c+di" and I don't know why. What is happening and how can I solve it?
Thank you
#include <stdio.h>
#include <string.h>
#define FORMATLOG "Invalid Input. Required format: <a+bi> <operator> <c+di>"
#define INPUTLOG "Error: Trying to operate with different sets of numbers"
enum { true, false };
typedef struct {
double realp, imagp;
} Complex;
int checkIfComplex(char *exp) {
unsigned int i = 1;
if(exp[strlen(exp) - 1] == 'i')
while(exp[i] != '\0') {
if(exp[i] == '+' || exp[i] == '-')
return true;
i++;
}
return false;
}
Complex parseComplex(char *exp) {
Complex number;
sscanf(exp, "%lf + %lfi", &number.realp, &number.imagp);
return number;
}
int main(int argc, char **argv) {
printf("%d", argc);
if(argc != 4) {
puts(FORMATLOG);
return false;
}
if(argv[2][0] != '%')
if(checkIfComplex(argv[1]) || checkIfComplex(argv[3])) {
puts(INPUTLOG);
return false;
}
Complex result,
fterm = parseComplex(argv[1]),
sterm = parseComplex(argv[3]);
switch(argv[2][0]) {
case '+':
result.realp = fterm.realp + sterm.realp;
result.imagp = fterm.imagp + sterm.imagp;
break;
case '-':
result.realp = fterm.realp - sterm.realp;
result.imagp = fterm.imagp - sterm.imagp;
break;
case '*': case 'x':
result.realp = fterm.realp * sterm.realp;
result.imagp = fterm.realp * sterm.imagp
+ fterm.imagp * sterm.realp
- fterm.imagp * sterm.imagp;
default:
puts(FORMATLOG);
return false;
}
fprintf(stdout, ">> %g + %gi\n", result.realp, result.imagp);
return true;
}

Answer 1

It would appear that the '*' is being treated as a wild-card and expanded by the shell before being passed to you application. For example,
int main(int argc, char** argv)
{
int ndx;
printf("%d\n", argc);
for(ndx = 0; ndx < argc; ndx++)
{
printf("argument %d is %s\n", ndx, argv[ndx]);
}
return 0;
}
produces the following output (on a Ubuntu host, using gcc-4.8 as the compiler):
******#ubuntu:~/junk$ ./complex a+bi * c+di
6
argument 0 is ./complex
argument 1 is a+bi
argument 2 is complex
argument 3 is complex.c
argument 4 is complex.c~
argument 5 is c+di
I can see two solutions to your problem:
(1) escape the * like this:
xxxxxx#ubuntu:~/junk$ ./complex a+bi \* c+di
4
argument 0 is ./complex
argument 1 is a+bi
argument 2 is *
argument 3 is c+di
Problem here is that you are going to have to escape any symbol that has special significance, and it certainly doesn't seem natural to write *. Additionally, I'm not sure how portable this is going to be due to shells using different escape charaters.
(2) quote the entire expression like this:
xxxxxx#ubuntu:~/junk$ ./complex "a+bi * c+di"
2
argument 0 is ./complex
argument 1 is a+bi * c+di
At least here the user can write the expression in a normal form, they just have to remember to quote it. Additionally, this provides some protection against a user adding an additional space in the expression, vis a + bi * c+di. The problem here is that the use needs to remember to quote the expression and you need to do a bit more parsing to extract the two terms.