C - Modify undcl so that it does not add redundant parentheses to declarations

女爷i 2022-11-14 15:58 126阅读 0赞

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击[http://www.captainbed.net][http_www.captainbed.net]

/*
     * Modify undcl so that it does not add redundant parentheses to declarations.
     *
     * Undcl.c - by FreeMan
     */
    
    
    #include <stdio.h>
    
    #define BUFSIZE 1000
    
    static char line[BUFSIZE]; /* Buffer for line */
    static int bufp = 0; /* Position in buf */
    static int readflag = 1;
    static int get_line(char *s, int max_length);
    
    /* getch: Read a character */
    int getch(void)
    {
    	int length = 0;
    	do
    	{
    		if (readflag == 1)
    		{
    			/* Prime the line array */
    			if ((length = get_line(line, BUFSIZE)) > 0)
    			{
    				if (length >= (BUFSIZE - 1))
    				{
    					printf("ERROR: line buffer exceeded!\n");
    					return EOF;
    				}
    			}
    			else
    			{
    				return EOF;
    			}
    			bufp = 0;
    			readflag = 0;
    		}
    		if (line[bufp] == '\0')
    		{
    			readflag = 1; /* Need to read a new line */
    		}
    	} while (readflag);
    	return line[bufp++];
    }
    
    /* ungetch: Push character back on input */
    void ungetch(void)
    {
    	if (bufp > 0)
    	{
    		--bufp;
    	}
    }
    /* print_source: Print out the contents of the line read */
    void print_source(void)
    {
    	printf("%s", line);
    }
    
    /* getline: This version will read a line up to a maximum number of characters
     * (max_length - 1) and store a '\0' at the end. The number of characters
     * read is returned, if that is a 0 then we are done reading lines. */
    int get_line(char *s, int max_length)
    {
    	int c;
    	char *start = s; /* Save pointer to start of buffer s */
    	char *end = s + (max_length - 2); /* Point near to end of buffer s */
    	while ((c = getchar()) != EOF && c != '\n' && s < end)
    	{
    		*s++ = c;
    	}
    	/* Store last character read */
    	if (c != EOF)
    	{
    		*s++ = c;
    	}
    	*s = '\0'; /* Terminate the line */
    	return s - start; /* Number of characters read */
    }
    
    
    #include <stdio.h>
    #include <string.h>
    #include <ctype.h>
    
    #define MAXTOKEN 100
    #define MAXPOINTERS 10
    
    /*
     * From the input syntax stipulated for undcl, namely:
     * x () * [] * () char
     * to generate:
     * char (*(*x())[])()
     *
     * We can see that...
     * 1. The only time that parentheses are seen in the input are if they
     * indicate a function.
     * 2. Other than when they indicate a function, parentheses in the output are
     * only added when a pointer '*' is seen.
     *
     * Parentheses used to represent a function are never redundant. So the item
     * of code that we need to focus on to solve the exercise is the pointer
     * section.
     *
     * Sample: x () * * * char
     * output before changes: char(*(*(*x())))
     * output after changes: char(***x())
     */
    enum { NAME, PARENS, BRACKETS };
    
    int gettoken(void);
    int tokentype; /* Type of last token */
    char token[MAXTOKEN]; /* Last token string */
    char out[1000]; /* Output string */
    
    /* undcl: Convert word description to declaration */
    int main(void)
    {
    	int type;
    	int i, c;
    	int pcount;
    	char temp[MAXTOKEN];
    	char p[MAXPOINTERS]; /* Space for 9 pointers */
    	while (gettoken() != EOF)
    	{
    		strcpy(out, token);
    		pcount = 0;
    		while ((type = gettoken()) != '\n')
    		{
    			if (type == PARENS || type == BRACKETS)
    			{
    				strcat(out, token);
    			}
    			else if (type == '*')
    			{
    				pcount++;
    				while ((c = getch()) == '*' || c == ' ')
    				{
    					if (c == '*')
    					{
    						if (pcount < (MAXPOINTERS - 1))
    						{
    							pcount++;
    						}
    						else
    						{
    							break;
    						}
    					}
    				}
    				ungetch();
    				for (i = 0; i < pcount; i++)
    				{
    					p[i] = '*';
    				}
    				p[i] = '\0';
    				pcount = 0;
    				sprintf(temp, "(%s%s)", p, out);
    				strcpy(out, temp);
    			}
    			else if (type == NAME)
    			{
    				sprintf(temp, "%s%s", token, out);
    				strcpy(out, temp);
    			}
    			else
    			{
    				printf("invalid input at %s\n", token);
    			}
    		}
    		printf("%s\n", out);
    	}
    	return 0;
    }
    
    /* gettoken: Return next token */
    int gettoken(void)
    {
    	int c;
    	char *p = token;
    	while ((c = getch()) == ' ' || c == '\t')
    		;
    	if (c == '(')
    	{
    		if ((c = getch()) == ')')
    		{
    			strcpy(token, "()");
    			return tokentype = PARENS;
    		}
    		else
    		{
    			ungetch();
    			return tokentype = '(';
    		}
    	}
    	else if (c == '[')
    	{
    		for (*p++ = c; (*p++ = getch()) != ']'; )
    			;
    		*p = '\0';
    		return tokentype = BRACKETS;
    	}
    	else if (isalpha(c))
    	{
    		for (*p++ = c; isalnum(c = getch()); )
    		{
    			*p++ = c;
    		}
    		*p = '\0';
    		ungetch();
    		return tokentype = NAME;
    	}
    	else
    	{
    		return tokentype = c;
    	}
    }
    
    // Output:
    /*
    x () * * * char
    char(***x())
    
    */

[http_www.captainbed.net]: http://www.captainbed.net/troubleshooter