problem with recursive descent parser

[fish1709]

I am writing a code in c++ to do a recursive descent parser/evaluation for int's for a grammar. I will say right now yes this is homework. I have made a lot of progress on this, but am running into a problem when i come to a closing parenthesis. I believe the problem to be in my parseF function around line 173 but am uncertain. A point in the right direction would be greatly appreciated(I hope it is easy enough to read).

/*****************************/
/*  E-->C|CAC                 |
/*  C-->F|FMF                 |
/*  F-->N|(E)                 |
/*  N-->SI|I                  |
/*  I-->DI|D                  |
/*  D-->0|1|2|3|4|5|6|7|8|9   |
/*  A-->+|-                   |
/*  S-->-                     |
/*  M-->*|/|%                 |
******************************/

#include <iostream>
#include <cstring>
#define DEBUG 1

using namespace std;

int parseE(int *val, char *inp, int *idx);
int parseC(int *val, char *inp, int *idx);
int parseF(int *val, char *inp, int *idx);
int parseN(int *val, char *inp, int *idx);
int parseS(int *val, char *inp, int *idx);
int parseI(int *val, char *inp, int *idx);
int parseD(int *val, char *inp, int *idx);
int parseM(int *val, char *inp, int *idx);
int parseA(int *val, char *inp, int *idx);

int main()
{
        int val, idx;
        val = idx = 0;
        char *inp = new char[256];
        strcpy(inp, "(13+6)+4");
        printf("Input string: %s\n", inp);
        int answer = parseE(&val, inp, &idx);
        cout << answer << endl;
        cout << val << endl;

}

int parseE(int *val, char *inp, int *idx)
{
        int temp;
        #if DEBUG
        printf("parsing E on %s \n", &(inp[*idx]));
        #endif

        if(!parseC(val, inp, idx))
                return 0;

        if(inp[*idx] != '+' && inp[*idx] != '-')
                return 1;

        if(!parseA(val, inp, idx))
                return 0;

        temp = *val;

        if(inp[*idx - 1] == '+')
        {
                if(!parseC(val, inp, idx))
                        return 0;
                *val = temp + *val;
        }
        else
        {
                if(!parseC(val, inp, idx))
                        return 0;
                *val = temp - *val;
        }
        return 1;
}

int parseI(int *val, char *inp, int *idx)
{
        int temp;
        #if DEBUG
        printf("parsing I on %s \n", &(inp[*idx]));
        #endif
        if(!parseD(val, inp, idx))
        {
        fprintf(stderr, "ERROR: Expecting digit but received %c \n", inp[*idx]);

                        return 0;
        }

        temp = *val;

        while(*idx < strlen(inp) && isdigit(inp[*idx]))
        {
                if(!parseD(val, inp, idx))
                        return 0;
                temp *= 10;
                temp += *val;
        }

        *val = temp;
        return 1;
}

int parseD(int *val, char *inp, int *idx)
{
        #if DEBUG
        printf("parsing D on %s \n", &(inp[*idx]));
        #endif
        if(isdigit(inp[*idx]))
        {
                *val = inp[*idx] - '0';
                *idx += 1;
                return 1;
        }
        return 0;
}

int parseC(int *val, char *inp, int *idx)
{
        int temp;
        #if DEBUG
        printf("parsing C on %s \n", &(inp[*idx]));
        #endif

        if(!parseF(val, inp, idx))
                return 0;

        if(inp[*idx] != '*' && inp[*idx] != '/' && inp[*idx] != '%')
                return 1;

        if(!parseM(val, inp, idx))
                return 0;  //possibly return 1;

        temp = *val;

        if(inp[*idx - 1] == '*')
        {
                if(!parseF(val, inp, idx))
                        return 0;
                *val = temp * *val;
        }
        else if(inp[*idx - 1] == '/')
        {
                if(!parseF(val, inp, idx))
                        return 0;
                *val = temp / *val;
        }
        else if(inp[*idx - 1] == '%')
        {
                if(!parseF(val, inp, idx))
                        return 0;
                *val = temp % *val;
        }
        return 1;
}

int parseF(int *val, char *inp, int *idx)
{
        #if DEBUG
        printf("parsing F on %s \n", &(inp[*idx]));
        #endif
        if(inp[*idx] == '(')
        {
                *idx++;
                if(!parseE(val, inp, idx))
                        return 0;

                if(inp[*idx] != ')')
                {
                fprintf(stderr,"ERROR: Expecting ')' but received '%c'\n", inp[*idx]);

                        *idx++;
                        return 0;
                }
                else                     //look  here
                        *idx++;

                return 1;

        }
        else
        {
                if (!parseN(val, inp, idx))
                        return 0;
        }
        return 0;
}

int parseN(int *val, char *inp, int *idx)
{
        *val = 0;
        int flag = parseS(val, inp, idx); // found -

        #if DEBUG
        printf("parsing N on %s \n", &(inp[*idx]));
        #endif
        if(!parseI(val, inp, idx))
        {
                return 0;
        }
        if(flag)
                *val *= -1;
}

int parseS(int *val, char *inp, int *idx)
{
        int temp = *val;
        #if DEBUG
        printf("parsing S on %s \n", &(inp[*idx]));
        #endif
        if(inp[*idx] == '-')
        {
                *idx += 1;
                return 1;
        }
        return 0;
}

int parseM(int *val, char *inp, int *idx)
{
        #if DEBUG
        printf("parsing M on %s \n", &(inp[*idx]));
        #endif
        if(inp[*idx] == '*' || inp[*idx] == '/' || inp[*idx] == '%')
        {
                *idx += 1;
                return 1;
        }
        return 0;
}

int parseA(int *val, char *inp, int *idx)
{
        #if DEBUG
        printf("parsing A on %s \n", &(inp[*idx]));
        #endif
        if(inp[*idx] == '-' || inp[*idx] == '+')
        {
                *idx += 1;
                return 1;
        }
        return 0;
}