Reverse Polish Calcullator

Good evening. I'm studying the reverse polish calculator of KnR but there are some lines I'm not understanding very well.

Code:

---

#include <stdio.h>
#include <stdlib.h>

#ifndef MAXOP
  #define MAXOP 100
#endif 

#ifndef NUMBER
  #define NUMBER '0'
#endif 

int getop(char[]);
void push(double);
double pop(void);

int main(void)
{
  int type;
  double op2;
  char s[MAXOP];
 
  while( (type = getop(s)) != EOF)
  {
    switch(type)
    {
    case NUMBER:
        push(atof(s));
        break;
    case '+':
        push(pop() + pop());
        break;
    case '-':
        op2 = pop();
        push(pop() - op2);
        break;
    case '*':
        push(pop() * pop());
        break;
    case '/':
        op2 = pop();
        if(op2 != 0.0)
          push(pop() / op2);
        else
          printf("error: zero divisor\n");
        break;
    case '\n':
        printf("\t%.8g\n", pop());     
        break;
    default:
        printf("error: unknown command %s\n", s);
        break;                 
    }
  }             
 return 0;
}

#define MAXVAL 100

int sp = 0;
double val[MAXVAL];

void push(double f)
{
  if(sp < MAXVAL)
    val[sp++] = f;
  else
    printf("error: stack full, can't push %g\n", f);         
}   

double pop(void)
{
  if(sp > 0)
  {
    return val[--sp]; 
  }
  else  {
    printf("error: stack empty\n");
    return 0.0;     
  }     
}

#include <ctype.h>

int getch(void);
void ungetch(int);   

/* getop: get next operator or numeric operand */
int getop(char s[])
{
  int i, c;
 
  while( (s[0] = c = getch()) == ' ' || c == '\t')
  ;
  s[1] = '\0';
  if(!isdigit(c) && c != '.')
    return c; /* not a number */   
  i = 0;
  if(isdigit(c)) /* collect integer part */
    while(isdigit(s[++i] = c = getch()))
    ; 
  if(c == '.') /* collect fraction part */
    while(isdigit(s[++i] = c = getch()))
    ;
  s[i] = '\0';
  if(c != EOF)
    ungetch(c);
  return NUMBER; 
}

#define BUFSIZE 100

char buf[BUFSIZE]; /* buffer for ungetch */
int bufp = 0; /* next free position in buf */   

int getch(void)
{
  return (bufp > 0)? buf[--bufp] : getchar();   
}

void ungetch(int c)
{
  if(bufp >= BUFSIZE)
    printf("Ungetch: too many characters\n");
  else
    buf[bufp++] = c;     
}

---

this section

Code:

---


while( (s[0] = c = getch()) == ' ' || c == '\t')
  ;
  s[1] = '\0';
  if(!isdigit(c) && c != '.')
    return c; /* not a number */   
  i = 0;
  if(isdigit(c)) /* collect integer part */
    while(isdigit(s[++i] = c = getch()))

---

Why did he insert the null terminator in s[1] ? to stop getting blanks ? after that, did he reset i to overwrite '\0' with an input ? (isdigit(s[++i]) ) ... if so, why did he insert the null terminator in the first place? I don't get it ...

This code in my eyes does the following (line by line)

• Line 1 --> It will read a character.It will store this character to c.Then c will be stored in s[0].Then i will check if what was read was a space or a tab.If so read again and execute all the procedure again.In other words he 'eats' whitespaces and tabs by this way.
• Line 2 --> An empty while body, because all work is done in line 1.
• Line 3 --> Set s[1] to the null terminator, because no matter how many times the while loop is going to be executed we always will assign c to s[0]
• Line 4 --> If c is not a digit AND it is not a dot, then go to line 5
• Line 5 --> return c because it is not a number
• Line 6 --> Assign to i the value of zero
• Line 7 --> If c is a digit go to line 8
• Line 8 --> First increment i by one.Then read a char, assign it to c, and then assign c to s[i].Check if s[i] is digit.If so the while loop will be executed

Hmm.. I admit it is not clear why he sets s[1] to null terminator.But if you look the whole function, when on line 98 and 101 the if conditions are false, then this means that i still has value of zero,thus he will assign first element with null terminator ( it was read by the first while in the function ).But again i am not really convinced that s[1] = '\0' was mandatory...

EDIT : Can you please provide me with the page of the book where this function lies to? :)

Quote:

---

when on line 98 and 101 the if conditions are false

---

But if the input isn't a digit, then c will be returned.

by the away, congratulations for the 1000th post !!! [open champagne]

Haha,yeah you are right....!! :D :D :D Thank you a lot. I hope it was a helpful one ;) :biggrin:

I see your point.. can you tell me the page ?

page 90 of the second edition.

have a good night people!

Code:

---


Reading symbols from /home/ethereal/C/DataStructures/reversepolish...done.
(gdb) break 101
Breakpoint 1 at 0x4008fe: file reversepolish.c, line 101.
(gdb) break 111
Breakpoint 2 at 0x4009ba: file reversepolish.c, line 111.
(gdb) break 114
Breakpoint 3 at 0x4009d6: file reversepolish.c, line 114.
(gdb) run
Starting program: /home/ethereal/C/DataStructures/reversepolish
2.5 3.5 + 4.0 *

Breakpoint 2, getop (s=0x7fffffffe640 "2.5 ") at reversepolish.c:111
111        s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "2.5") at reversepolish.c:114
114        return NUMBER;
(gdb) cont
Continuing.

Breakpoint 2, getop (s=0x7fffffffe640 "3.5 ") at reversepolish.c:111
111        s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "3.5") at reversepolish.c:114
114        return NUMBER;
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "+") at reversepolish.c:101
101          return c; /* not a number */
(gdb) cont
Continuing.

Breakpoint 2, getop (s=0x7fffffffe640 "4.0 ") at reversepolish.c:111
111        s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "4.0") at reversepolish.c:114
114        return NUMBER;
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "*") at reversepolish.c:101
101          return c; /* not a number */
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "\n") at reversepolish.c:101
101          return c; /* not a number */
(gdb) cont
Continuing.
    24

---

I think I understood the reason of assigning '\0' to s[1]. he's eliminating ' ' or '\t'. As you can see, Those don't appear inside s after the digits start to be input. My idea is strengthened by the fact the null terminator is overwritten with the first digit input.
Almost in the same way, he overwrites the next char after the digit with '\0' (like the program did with ' '). That's the meaning of assigning '\0' to s[i].

Still i am not convinced.Which will the problem if we remove this line?

Quote:

---

Still i am not convinced.Which will the problem if we remove this line?

---

the problem, I don't know. But I noticed a difference in the last three breaks. There's a ".0" after some chars.

without s[1] = '\0'

Code:

---


gdb -q reversepolish
Reading symbols from /home/ethereal/C/DataStructures/reversepolish...done.
(gdb) break 99
Breakpoint 1 at 0x40086f: file reversepolish.c, line 99.
(gdb) break 108
Breakpoint 2 at 0x4008e5: file reversepolish.c, line 108.
(gdb) break 111
Breakpoint 3 at 0x400901: file reversepolish.c, line 111.
(gdb) run
Starting program: /home/ethereal/C/DataStructures/reversepolish
1.5 2.5 + 4.0 *

Breakpoint 2, getop (s=0x7fffffffe640 "1.5 ") at reversepolish.c:108
108      s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "1.5") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.

Breakpoint 2, getop (s=0x7fffffffe640 "2.5 ") at reversepolish.c:108
108      s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "2.5") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "+.5") at reversepolish.c:99
99        return c; /* not a number */
(gdb) cont
Continuing.

Breakpoint 2, getop (s=0x7fffffffe640 "4.0 ") at reversepolish.c:108
108      s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "4.0") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "*.0") at reversepolish.c:99
99        return c; /* not a number */
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "\n.0") at reversepolish.c:99
99        return c; /* not a number */

---

with s[1] = '\0';

Code:

---


/home/ethereal/C/DataStructures/reversepolish
1.5 2.5 + 4.0 *

Breakpoint 2, getop (s=0x7fffffffe640 "1.5 ") at reversepolish.c:108
108      s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "1.5") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.

Breakpoint 2, getop (s=0x7fffffffe640 "2.5 ") at reversepolish.c:108
108      s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "2.5") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "+") at reversepolish.c:99
99        return c; /* not a number */
(gdb) cont
Continuing.

Breakpoint 2, getop (s=0x7fffffffe640 "4.0 ") at reversepolish.c:108
108      s[i] = '\0';
(gdb) cont
Continuing.

Breakpoint 3, getop (s=0x7fffffffe640 "4.0") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "*") at reversepolish.c:99
99        return c; /* not a number */
(gdb) cont
Continuing.

Breakpoint 1, getop (s=0x7fffffffe640 "\n") at reversepolish.c:99
99        return c; /* not a number */
(gdb) cont
Continuing.
    16

---

Oh, now i see your point. Great observation.Bravo ;)

Thank you for the compliment. But what does that ".0" mean? a kind of junk ?

When you encounter code such as this one, you can rewrite/refactor it to make it more readable:

Code:

---

/* getop: get next operator or numeric operand */
int getop(char s[])
{
  int i, c;

  do {
    c = getch();
  } while (c == ' ' || c == '\t');

  s[0] = c;
  s[1] = '\0';

  if(!isdigit(c) && c != '.')
    return c;

  i = 0;

  /* Integer part */
  if(isdigit(c))
    do {
        s[++i] = c;
        c = getch();
    } while (isdigit(c));

  /* Fractional part */
  if(c == '.')
    do {
      s[++i] = c;
      c = getch();
    } while (isdigit(c));

  s[i] = '\0';

  if(c != EOF)
    ungetch(c);

  return NUMBER; 
}

---

When the function is written this way, the intent becomes clear.

On lines 6-8 the function reads the next character, skipping all spaces and tabs.

On lines 10-11, the function constructs a string of that character into the char array specified by the caller.

On lines 13-14, if the character was not a number, the function returns the character code. (The char array was filled with a string, to make other operations easier.)

On lines 17-22, the function adds the integer part, if any, of a number into the character array.

On lines 25-29, the function adds the fractional part, if any, starting with the decimal point, into the character array.

On line 31, the function adds a NUL to the character array, so that the contents form a proper string. (The number just read.)

The first character not part of the number is still in variable c. Therefore, on lines 33-34, if there really was a character (and not just end of input), that character is unread: put back into the stream. (This is internal to the C library, just something that makes parsing complicated stuff easier. It is not visible outside the process in any way, it is just part of the buffering mechanisms the C library does.)

Compare the original function and my version side-by-side; perhaps the contrast will make it easier to decipher the intent behind the code?

(I do take this approach when I see obtuse code. One must be extra careful to test that the rewritten code works exactly like the original. To my shame I admit I was too lazy to do that step here, so there may be bugs or typos in my version.)

Quote:

---

Originally Posted by thames

Thank you for the compliment. But what does that ".0" mean? a kind of junk ?

---

Not really. This is what was left by previous call.

I will use your own - beautiful - in my mind explanation ( which i really appreciate and thank you for that, because it really gave me the answer in a question i was thinking all the time in bed the last night. Thank you again .)

See the following breakpoints
Without the s[1] = '\0';

Code:

---

Breakpoint 3, getop (s=0x7fffffffe640 "2.5") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.
 
Breakpoint 1, getop (s=0x7fffffffe640 "+.5") at reversepolish.c:99
99        return c; /* not a number */
(gdb) cont
Continuing.

---

Now with the s[1] = '/0';

Code:

---

Breakpoint 3, getop (s=0x7fffffffe640 "2.5") at reversepolish.c:111
111      return NUMBER; 
(gdb) cont
Continuing.
 
Breakpoint 1, getop (s=0x7fffffffe640 "+") at reversepolish.c:99
99        return c; /* not a number */
(gdb) cont
Continuing.

---

So in the first call we have 2.5 inside s <- the parameter of getop.
Then we get the plus operator ( + ) .
If we remove line s[1] = '\0' (first piece of code) then we have in the buffer 2.5 , but then when we read the + operator, because it is only one element - one cell, only the first element of the buffer is going to be overwritten, while the the second (had the '.' from previous call) and third (had the '5' from previous call) elements will not be overwritten.

As a result in the second call of getop we will have inside the buffer +.5

Now ,with the line s[1]='\0'; we have in the first call of getop 2.5 inside the buffer and in the second call we have + inside the buffer , which is what we want :D

Then in the last three breakpoints you have , you receive in the first call of the function 4.0 , thus buffer gets the 4.0 as content of it.Then you read * , but without the s[1]='\0' line you will get *.0 . The dot and the zero come from the 4.0 , because again only the first element of buffer (array s) will be overwritten.

Can you understand what i am saying? :)

Again thank for this beautiful question and your nice breakpoints ;)

Quote:

---

(This is internal to the C library, just something that makes parsing complicated stuff easier. It is not visible outside the process in any way, it is just part of the buffering mechanisms the C library does.)

---

actually, getch and ungetch were coded.

Quote:

---

If we remove line s[1] = '\0' (first piece of code) then we have in the buffer 2.5 , but then when we read the + operator, because it is only one element - one cell, only the first element of the buffer is going to be overwritten, while the the second (had the '.' from previous call) and third (had the '5' from previous call) elements will not be overwritten.

---

Thank you. As clear as water!!! "many thanks high power. " :biggrin:

edit:

Nominal code was very enlightening. I couldn't picture the getch char was being assigned to c before assigning it to s[0]. To be honest, that simultaneous assigning confused me a bit.

Quote:

---

Originally Posted by thames

actually, getch and ungetch were coded.

---

True, but nomimal knows what he is talking about.If I remember well they were not yet introduced to you at the current point of the book :)

Quote:

---

Originally Posted by thames

actually, getch and ungetch were coded.

---

Ah, so they were. I don't know how I overlooked that, sorry. (I guess I just missed the h at the end.)

I added the note just to make sure there is no confusion about how ungetc() works; it just rebuffers the character, so that following read or scan operations will see use it. It is not visible outside the process in any way.

In fact, you could just use getchar() or fgetc(stdin) instead of getch(), and ungetc(c, stdin) instead of ungetch(c).

You are always guaranteed to be able to push the last character you just read back into the buffer (which is what the code uses it for, only). For the code you showed, the standard functions provide the needed functionality; there is no need for the wrappers or the buffer.

(In fact, the man page says "ungetc() pushes c back to stream, cast to unsigned char, where it is available for subsequent read operations. Pushed-back characters will be returned in reverse order; only one pushback is guaranteed." It means that the char does not have to be the one you read. It also explains the odd extra input character, ((unsigned char)EOF), if you accidentally ungetc(EOF, stdin);)

I'm doing KnR exercise 4-6:

Add access to library functions like sin, exp and pow to the polish calculator.

but I'm having a buffer problem. I'm trying to enter an exponent inside a function I called power (because I think people should choose the power they want).

But I'm getting this:

Code:

---


  current value of the top of the stack: 4.000000000000000Enter a power: You Entered: 0 Inserted value: 1.000000000000000000

---

heh, that buffer problem.

I know I have to reset the buffer. I tried to reset the val[MAXVAL] unsuccessfully.

What do I have to reset ?

edit:
I tried to reset s (I thought I had to reset it because, after all, s is a char*)

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>

#ifndef NUMBER
 #define NUMBER '0'
#endif


#ifndef MAXOP
 #define MAXOP 100
#endif


#ifndef PERIOD
 #define PERIOD '.'
#endif


#ifndef MAXVAL
 #define MAXVAL 100
#endif


#ifndef MAXBUF
 #define MAXBUF 100
#endif


int bufp = 0;
char buf[MAXBUF];


int sp = 0;
double val[MAXVAL];


int getch(void);
void ungetch(int);
int getop(char*);
double pop(void);
void push(double);
void peek(void);
void duplicate(void);
void swap(void);
void clear(void);
double power(double);
int isanumber(char* s);


int main(void)
{
  int type;
  char s[MAXOP];
  double op2;
 
  while( (type = getop(s)) != EOF)
  {
    switch(type)
    {
      case NUMBER:
        push(atof(s));
        break;
     
      case '+':
        push(pop() + pop());
        break;
     
      case '-':
        op2 = pop();
        push(pop() - op2);
        break;             
       
      case '*':
        push(pop() * pop());
        break;
     
      case '\n':
        printf("Polish pop: \t%.8g\n", pop());
        break;
       
      case 'i':
        push(sin(pop()));
        break;
       
      case 'e':
        push(exp(pop()));
        break;
       
      case 'o':
        push(power(pop()));
        break; 
     
      case 'p':
        peek();
        break; 
       
      case 'd':
        duplicate();
        break; 
     
      case 'c':
        clear();
        break; 
       
      case 's':
        swap();
        break; 
     
      case '/':
        op2 = pop();
        if(op2 > 0.0)
          push(pop() / op2);
        else
          printf("error: zero divisor\n");
        break;
     
      case '%':
        op2 = pop();
        if(op2 > 0.0)
          push(fmod(pop(), op2));
        else
          printf("error: zero divisor\n");
        break;
       
        default:
          printf("error: unknown command\n");             
        break; 
    }     
  }         
  return EXIT_SUCCESS;   
}     

int isanumber(char* s)
{
  int i;
  for(i = 0; s[i] != '\0'; i++)
    if(isalpha(s[i]))
      break;


  if(s[i] != '\0')
      return 0;
  return 1;
}

void push(double f)
{
  if(sp < MAXVAL)
  { 
      val[sp++] = f; 
      printf("Inserted value: %f\n", val[sp - 1]);
  } 
  else
    printf("push: stack full, can't push %g\n", f);           
}


double power(double f)
{
  char strnum[MAXVAL];
  int pw = 0;
 
  do  {
    printf("Enter a power: ");
    fgets(strnum, sizeof(strnum), stdin);   
  }while(!isanumber(strnum));
 
  pw = atoi(strnum);
  printf("You entered: %d", pw);
 
  return pow(f,pw);
}   


void duplicate(void)
{
  if(sp < MAXVAL)
  {
    val[sp++] = pop(); 
  }
  else       
    printf("duplicate: stack full, can't push %f\n", pop());
} 


void swap(void)
{
  double temp;
 
  if(sp > 0)
  { 
    temp = val[sp];
    val[sp] = val[sp - 1];
    val[sp - 1] = temp;   
  }
  else {
    printf("swap: at least, two values have to be inserted for swapping.\n");
  }         
}


void clear(void)
{
  int i;
  for(i = 0; i < MAXVAL; i++)
    val[i] = 0.0;
}             
 
double pop(void)
{
  if(sp > 0)
    return val[--sp];
  else
  {
    printf("pop: stack empty\n");
    return 0.0; 
  }           
}


void peek(void)
{
  if(sp > 0)
    printf("top element: %.2f\n", val[sp]);
  else
    printf("peek: stack is empty\n");     
}   


int getop(char* s)
{
  int next;
  int c, i;
 
  while( (s[0] = c = getch()) == ' ' || c == '\t')
  ;
  s[1] = '\0';   
   
  if(!isdigit(c) && c != PERIOD && c != '-')
      return c;
 
  if(c == '-') 
  {
    next = getch(); 
    if(!isdigit(next) && next != PERIOD)
      return c;
 
    c = next;
  }
  else {
    c = getch(); 
  }           
 
  i= 0;
  while(isdigit(s[++i] = c)) /* collect integer part */
    c = getch();
  if(c == PERIOD) /* collect fraction part */
    while(isdigit(s[++i] = c = getch()))
      ;
               
  s[i] = '\0';
  if(c != EOF)
    ungetch(c);     
 
  return NUMBER; 
}


int getch(void)
{
  return (bufp > 0) ? buf[--bufp] : getchar();   
}     


void ungetch(int c)
{
  if(bufp < MAXBUF)
    buf[bufp++] = c;
  else
    printf("ungetch: too many characters.");
}

---

Good evening! I'm trying to write the Reverse Polish program with arguments from argv instead of getting chars from getchar():

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>

#ifndef NUMBER
 #define NUMBER '0'
#endif

#ifndef MAXOP
 #define MAXOP 100
#endif

#ifndef PERIOD
 #define PERIOD '.'
#endif

#ifndef MAXVAL
 #define MAXVAL 100
#endif

#ifndef MAXBUF
 #define MAXBUF 100
#endif

int bufp = 0;
char buf[MAXBUF];

int sp = 0;
double val[MAXVAL];

int getch(void);
void ungetch(int);
int getop(char*);
double pop(void);
void push(double);
void peek(void);
void duplicate(void);
void swap(void);
void clear(void);

int main(int argc, char* argv[])
{
  int type;
  char s[MAXOP];
  double op2;
  char* argument = argv[1];
 
  while( (type = getop(argument)) != EOF)
  {
    ++argument;
   
    switch(type)
    {
      case NUMBER:
        push(atof(s));
        break;
     
      case '+':
        push(pop() + pop());
        break;
     
      case '-':
        op2 = pop();
        push(pop() - op2);
        break;             
       
      case '*':
        push(pop() * pop());
        break;
     
      case '\n':
        printf("Polish pop: \t%.8g\n", pop());
        break;
       
      case 'i':
        push(sin(pop()));
        break;
       
      case 'e':
        push(exp(pop()));
        break;
       
      case 'o':
        push(pow(pop(), 2));
        break; 
     
      case 'p':
        peek();
        break; 
       
      case 'd':
        duplicate();
        break; 
     
      case 'c':
        clear();
        break; 
       
      case 's':
        swap();
        break; 
     
      case '/':
        op2 = pop();
        if(op2 > 0.0)
          push(pop() / op2);
        else
          printf("error: zero divisor\n");
        break;
     
      case '%':
        op2 = pop();
        if(op2 > 0.0)
          push(fmod(pop(), op2));
        else
          printf("error: zero divisor\n");
        break;
       
        default:
          printf("error: unknown command\n");             
        break; 
    }     
  }         
  return EXIT_SUCCESS;   
}     

int isanumber(char* s) {
 
  int i = 0;
 
  while(s[i] != '\n')
  {
    if(isalpha((unsigned char) s[i]) || isblank( (unsigned char) s[i]) )
      break;
   
    i++;   
  }       
 
  if(s[i] == '\n')
    return 1;
  return 0;           
}

void push(double f)
{
  if(sp < MAXVAL)
  { 
      val[sp++] = f; 
      printf("Inserted value: %f\n", val[sp - 1]);
  } 
  else
    printf("push: stack full, can't push %g\n", f);           
}

void duplicate(void)
{
  if(sp < MAXVAL)
  {
    val[sp++] = pop(); 
  }
  else       
    printf("duplicate: stack full, can't push %f\n", pop());
} 

void swap(void)
{
  double temp;
 
  if(sp > 1)
  { 
    temp = val[sp - 1];
    val[sp - 1] = val[sp - 2];
    val[sp - 2] = temp;   
  }
  else {
    printf("swap: at least, two values have to be inserted for swapping.\n");
  }         
}

void clear(void)
{
  int i;
  for(i = 0; i < MAXVAL; i++)
    val[i] = 0.0;
}             
 
double pop(void)
{
  if(sp > 0)
    return val[--sp];
  else
  {
    printf("pop: stack empty\n");
    return 0.0; 
  }           
}

void peek(void)
{
  if(sp > 0)
    printf("top element: %.2f\n", val[sp - 1]);
  else
    printf("peek: stack is empty\n");     
}   

int getop(char* s)
{
  int next;
  int c, i;
 
  while( (s[0] = c = getch()) == ' ' || c == '\t')
  ;
  s[1] = '\0';   
   
  if(!isdigit(c) && c != PERIOD && c != '-')
      return c;
 
  if(c == '-') 
  {
    next = getch(); 
    if(!isdigit(next) && next != PERIOD)
      return c;
 
    c = next;
  }
  else {
    c = getch(); 
  }           
 
  i= 0;
  while(isdigit(s[++i] = c)) /* collect integer part */
    c = getch();
  if(c == PERIOD) /* collect fraction part */
    while(isdigit(s[++i] = c = getch()))
      ;
               
  s[i] = '\0';
  if(c != EOF)
    ungetch(c);     
 
  return NUMBER; 
}

int getch(void)
{
  return (bufp > 0) ? buf[--bufp] : getchar();   
}     

void ungetch(int c)
{
  if(bufp < MAXBUF)
    buf[bufp++] = c;
  else
    printf("ungetch: too many characters.");
}

---

I started by doing this:

Code:

---


char* argument = argv[1];
 
  while( (type = getop(argument)) != EOF)
  {
    ++argument;

---

am I doing that wrong ?

I can't see where you have tried to implement any argv/argc

Have you read this tutorial? Command Line Arguments in C - Cprogramming.com

Here's a snippet from my solution with no buffering.

Code:

---

int get_type( char * );


int main( int argc , char * argv[] )
{
    if( argc < 4 )    /* it takes at least two operands & an operator */
    {
        const char * PROGRAM_NAME = argv[ 0 ];
        printf( "Usage:\t%s [ expression ]  ( multiplication operator ( * ) must be preceded by backslash '\\' )\n" , PROGRAM_NAME );
        printf( "Example:\t%s 2 2 5 \\* +\n( 5 * 2 ) + 2\n12\n" , PROGRAM_NAME );
        return 1;
    }


    char * operand;
    int type;
    double op2;
    double value_stack[ VALUE_MAX ];


    while( ( operand = ( *++argv) ) != NULL )
    {
        //heres all the operations and whatnot
        }
}

---

Note that while not talking about this particular program, they do mention how to walk through the arguments starting at the bottom of page 117 and finishing with another paragraph at the top of 118. It really helped me to understand how to walk through command line arguments using pointer arithmetic.

EDIT: Ironically, I just noticed that the paragraph just mentioned leads into turning the RPN calc into a command line version called expr, which is where I pulled my source from.

Also in this example, the var operand ends up being a pointer to the beginning of the char array's, or strings, containing the arguments.