Thread: my C snippets

Your formatting can do with a bit more whitespace. This is just one example - I'm too lazy to copy and paste all instances where I think it should be formatted similar to this:

Code:

while (isdigit(*t) || *t == 'e' || *t == '+' || *t == '-' || *t == '.') { t++; offset++; }

should be:

Code:

while (isdigit(*t) || *t == 'e' || *t == '+' || *t == '-' || *t == '.') 
{ 
     t++; 
     offset++; 
}

Also, I'd suggest you write a stack pop/push function:

Code:

      --top; *top = atof(e);
...
      b = *top; top++;
      a = *top; top++;
      --top; *top = postfix_apply(*e, a, b);
...

It would then also be simple to add some range checking to see if the expression fits on the stack.

--
Mats

Thanks Mats.
Yeah, I too noticed, that, my formatting was too dense, and hard on eyes.
But when I tidy up the code it becomes even harder to understand, the function that was fitting on one page now takes more. So it becomes very difficult to grasp the logic.

This is tidy version of arith example:

Code:

void arith_err_die(char *p, int offset, char *msg) 
{
    printf("%s\n", p);
    while (offset--) printf(" ");
    printf("^\n%s\n", msg);
    exit(1);
}

double arith_apply(char op, double a, double b) 
{
    double t = 0.0;
    
    if (op == '+')
    {
        t = a + b; 
    }
	else if (op == '-')
	{
    	t = a - b; 
    }
    else if (op == 'x')
    {
        t = a * b;
    }
	else if (op == '/')
	{
    	t = a / b;
    }
	else if (op == '^')
	{
    	t = pow(a, b);
    }
	return t;
}

double arith(char *p) 
{
    double a, b;
    int is_a, is_op;
    int offset;
    char *e, op;
    
    e = p;
    is_a = is_op = 0;
    offset = 0;
        
	while (*e) 
	{
    	if (*e == '-' && isdigit(e[1]) || isdigit(*e)) 
    	{
        	if (is_a) 
        	{
            	if (is_op) 
            	{
                	b = atof(e);
                	a = arith_apply(op, a, b);
                	is_op = 0;
            	}
            	else
                { 
                    arith_err_die(p, offset, "bad expression");
                }
        	} 
        	else 
        	{
            	a = atof(e);
            	is_a = 1;
        	}
        	while (isdigit(*e) || *e == 'e' || *e == '+' || *e == '-' || *e == '.')
        	{
            	e++;
            	offset++; 
            }
        } 
        else if (strchr("+-x/^", *e)) 
        {
            op = *e;
            is_op = 1;
            e++; 
            offset++;
	    }
	    else if (isspace(*e)) 
	    {
    	    e++;
    	    offset++;
        } 
        else if (*e)
        {
            arith_err_die(p, offset, "bad token"); 
        }
	}
	if (! is_a)
	{
    	arith_err_die(p, offset, "bad expression"); 
    }
	return a;
}

PS: Sorry for the ill formatting. The code is properly formatted/indented in my source file. (I used 4 space tab, and replace tab with spaces option, using Crimson Editor). But after pasting here the formatting becomes ugly!

If a function gets too long to manage with proper formatting, then it's a sign that it needs to be split up.

I think you'll find that this:

Code:

            	a = atof(e);
            	is_a = 1;
        	}
        	while (isdigit(*e) || *e == 'e' || *e == '+' || *e == '-' || *e == '.')
        	{
            	e++;
            	offset++;

can be replaced with simpler logic if you use strtod() and make use of the end-pointer to know where the new e should be [you'd have to figure out how much to change "offset", but that shouldn't be too much of a problem]. As a side-effect, incorrectly written numbers [e.g."2.-+e5ee--+"] will not be skipped over [after parsing as 2.0] but you can report it as a bad number.

And, I find that in an if/else if branching tree, you take the simplest option first - in this case, isspace() - because it's just a case of skipping over it.

--
Mats