recursion error

This is a discussion on recursion error within the C Programming forums, part of the General Programming Boards category; I do not understand why I receive the following error when I try to compile the code below: % gcc ...

  1. #1
    Registered User
    Join Date
    Sep 2006
    Posts
    9

    recursion error

    I do not understand why I receive the following error when I try to compile the code below:

    % gcc -o myProg eval.c
    eval.c:30: warning: conflicting types for built-in function 'exp'
    eval.c:62: error: conflicting types for 'expression'
    eval.c:36: error: previous declaration of 'expression' was here

    Thanks in advance.




    Code:
    /* This program uses a form of recursion known as a recursive chain to
       evaluate whether a given string is a valid expression.  The definition
       of a valid expression is as follows:
    
       a valid expression is either a term + term or a term alone
       a valid term is either a factor * factor or a factor alone
       a valid factor is either a single letter or an expression in parentheses
    
       It is in the definition of a valid factor that the recursion is introduced.
       The main function will call the function expression, which in turn will
       begin the recursive chain by calling exp.  The need for expression is
       so be able to check for the end of the line upon concluding that an
       expression is valid.
    
       This program does not evaluate the expression under consideration.  It
       only ascertains whether the expression is or is not valid as defined by
       the rules of the "grammar".  White space between characters in the string
       causes the evaluation to fail.
    
      */
    
    #include <stdio.h>
    
    #define TRUE 1                  /* boolean true */
    #define FALSE 0                 /* boolean false */
    
    int exp(char [], int *) ;       /* global prototypes for recursion */
    int term(char [], int *) ;      /* is input string a term */
    int factor(char [], int *) ;    /* is input string a factor */
    
    int main(void)
    {
       int expression(char [], int *);  /* start/end evaluation here */
    
       char str[80] ;               /* hold candidate expression string */
    
       printf("Enter a string to be checked for validity ");  /* prompt */
       printf("as an expression\n--> ") ;                     /* user for */
       fgets(str, 80, stdin) ;                                /* string */
       if (expression(str, 0 ))             /* if str is a valid expresion */
          printf("%s is a valid expression.\n", str);       /* print OK */
       else
          printf ("%s is not a valid expression.\n", str) ; /* else exp no good */
    }                                                       /* end main */
    
    
    /* --------------------------- EXPRESSION ----------------------------------
       INPUT: the expression string and an index position
       OUTPUT:
       RETURNS: TRUE if the string represents a valid expression; FALSE otherwise
       ASSUMPTIONS:
       DESCRIPTION:
       This function is called from main and in turn calls the recursive
       function to see is the string is a valid expression.  Upon returning
       from the recursive calls, if we are also at the end of the string,
       then the input string is a valid expression
       ------------------------------------------------------------------------- */
    int expression(char str[], int pos)
    {
       if (exp(str,&pos)) {         /* call to check if valid expression */
          pos++;                    /* move to next character */
          if (str[pos] == '\n')     /* if end of string, then */
             return(TRUE);          /* expression is valid */
          else return(FALSE);       /* else extra stuff at end of string */
       } else                       /* else invalid expression */
          return(FALSE);            /* return negative indicator */
    }                               /* end function exp */
    
    
    /* ----------------------------- EXP ----------------------------------------
       INPUT: the string containing the expression under consideration, and
              the current index position
       OUTPUT: the index position is shifted by this function to the end of the
               expression under evaluation.
       RETURNS: TRUE if the string represents a valid expression; FALSE otherwise
       ASSUMPTIONS:
       DESCRIPTION:  This function, first called by expression(), verifies that
       the input string is (or is not) a valid expression by following the rules
       as outlined in the documentation above.  A valid expression is either a
       term+term or a term alone.
    
       To evaluate whether this is a valid expression, check first for a term.
       If a valid term is found, move to the next index position.  If the
       next char is a '+', then another valid term must follow.  If the next
       char is not a '+', then move the index back one space and return to
       the caller with TRUE.
    
       This function is the first in the recursive chain, since a term is a
       factor * factor or a factor alone, and a factor can be an expression.
       ------------------------------------------------------------------------- */
    int exp(char str[], int *pos)
    {
       int flag;                    /* boolean flag for validity */
    
       if (term(str,pos)) {         /* if a term is found */
          flag = TRUE;              /* set marker to true */
          (*pos)++;                 /* examine next position */
          if (str[*pos] == '+') {   /* check for plus sign */
             (*pos)++;              /* if there, skip over it */
             flag = term(str,pos);  /* and check for another term */
          } else                    /* if no plus sign, */
             (*pos)--;              /* move position pointer back to first term */
       } else flag = FALSE;         /* else not a valid term */
       return flag;                 /* return flag to caller */
    }                               /* end function exp1 */
    
    
    /* ------------------------------- TERM ---------------------------------------
       INPUT: the string containing the expression under consideration, and
              the current index position
       OUTPUT: the index position is shifted by this function to the end of the
               term under evaluation.
       RETURNS: TRUE if the substring starting at index pos contains a valid term;
                FALSE otherwise
       ASSUMPTIONS:
       DESCRIPTION: Check if the input is a valid term, starting at index location
       'pos'.  The function stops when it has found a valid term or when it
       ascertains that the term is not valid.  A valid term is either a
       factor*factor or a factor alone.
    
       First check whether there is a valid factor.  If yes, check if the next
       char is a '*'.  If it is, then another valid factor must follow.  If
       it is not, move pos back one spot and return to the caller.
    
       This function is called from the function exp() as the second part of the
       recursive chain.
       -------------------------------------------------------------------------- */
    int term(char str[], int *pos)
    {
       int flag;                    /* boolean flag for validity */
    
       if (factor(str,pos)) {       /* if a factor is found */
          flag = TRUE;              /* set marker to true */
          (*pos)++;                 /* examine next position */
          if (str[*pos] == '*') {   /* if a * found */
             (*pos)++;              /* skip over it */
             flag = factor(str,pos);/* and check for another factor */
          } else                    /* else no * symbol, so point back to */
             (*pos)--;              /* previous factor */
       } else flag = FALSE;         /* else not a valid factor */
       return flag;                 /* return flag to caller */
    }                               /* end function term */
    
    
    /* --------------------------- FACTOR -----------------------------------------
       INPUT: the string containing the expression under consideration, and
              the current index position
       OUTPUT: the index position is shifted by this function to the end of the
               factor under evaluation.
       RETURNS: TRUE if the substring starting at index pos contains a valid
                factor; FALSE otherwise
       ASSUMPTIONS:
       DESCRIPTION: his function checks for a valid factor starting at the
       position pointed at by pos.  Note that a factor is either a letter alone
       or an expression enclosed in parentheses.  This last part of the
       definition of a valid factor is what makes the entire definition
       recursive.
    
       First check if the current substring is a single letter.  If yes,
       return true.  If not, the only other legal character is '('.  If
       found, then there must be a valid expression next, followed by a
       ')'.
       ------------------------------------------------------------------------- */
    int factor(char str[], int *pos)
    {
       int flag;                                    /* boolean flag for validity */
    
       if (str[*pos] >= 'A' && str[*pos] <= 'Z')    /* if a valid letter */
          return(TRUE);                             /* return positive flag */
       else if (str[*pos] == '(') {                 /* else if a ( char */
          (*pos)++;                                 /* skip over it */
          flag = exp(str,pos);                      /* and look for expression */
          (*pos)++;                                 /* move to next space */
          if (flag && str[*pos] == ')')             /* verify matching ) */
             return(TRUE);                          /* if ok, return flag */
          else return(FALSE);                       /* else non-matching () */
       } else
          return(FALSE);                            /* else non-factor */
    }                                               /* end function factor */

  2. #2
    CSharpener vart's Avatar
    Join Date
    Oct 2006
    Location
    Rishon LeZion, Israel
    Posts
    6,454
    int expression(char [], int *);
    int expression(char str[], int pos)

    is not the same

    exp there is standard function with such a name, I think - change the name of your function
    The first 90% of a project takes 90% of the time,
    the last 10% takes the other 90% of the time.

  3. #3
    The larch
    Join Date
    May 2006
    Posts
    3,573
    exp is a math.h library function. Try renaming your exp.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Getting an error with OpenGL: collect2: ld returned 1 exit status
    By Lorgon Jortle in forum C++ Programming
    Replies: 6
    Last Post: 05-08-2009, 08:18 PM
  2. An error is driving me nuts!
    By ulillillia in forum C Programming
    Replies: 5
    Last Post: 04-04-2009, 09:15 PM
  3. Making C DLL using MSVC++ 2005
    By chico1st in forum C Programming
    Replies: 26
    Last Post: 05-28-2008, 01:17 PM
  4. We Got _DEBUG Errors
    By Tonto in forum Windows Programming
    Replies: 5
    Last Post: 12-22-2006, 04:45 PM
  5. Couple C questions :)
    By Divx in forum C Programming
    Replies: 5
    Last Post: 01-28-2003, 12:10 AM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21