c_cinsight/0000755000176400017640000000000010524163057013443 5ustar ognenognen00000000000000c_cinsight/analyzer.c0000644000176400017640000005160307756712132015450 0ustar ognenognen00000000000000/* analyzer.c This module recognizes the elements of a file as C tokens. Uses: * scanner.h -> the scanner functions exported are here written by Ognen Duzlevski rev 0.0.1 History: */ #include #include #include "scanner.h" #include "constants.h" #include "structs.h" /* Append a character to a string with reallocating memory. If NULL is passed to the routine, it will allocate the initial string. */ char *append_char(char *str, char ch) { char *temp; /* in case a NULL was passed */ if (str == NULL) { temp = malloc(2); temp[0] = ch; temp[1] = '\0'; } else { /* allocate a new string */ temp = malloc(strlen(str)+2); /* and copy the old one in */ strcpy(temp, str); temp[strlen(str)] = ch; temp[strlen(str)+1] = '\0'; } free(str); /* we dont need the old string */ return temp; } /* Return 1 if a character is a letter or 0 if not. */ int is_letter(char c) { if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) || (c == '_')) return 1; else return 0; } /* Return 1 if c is a digit, 0 if not. */ int is_digit(char c) { if ((c >= '0') && (c <= '9')) return 1; else return 0; } /* Return 1 if c is a whitespace, 0 if not. */ int is_whitespace(char c) { switch (c) { case ' ': case '\t': case '\v': case '\n': case '\f': return 1; default: return 0; } } /* Return 1 if c is a hex digit, otherwise 0 */ int is_hexdigit(char c) { if (is_digit(c) || ((c >= 'A') && (c <= 'F')) || ((c >= 'a') && (c <= 'f'))) return 1; else return 0; } /* Return 1 if f|F|l|L, otherwise 0. */ int is_FS(char c) { switch (c) { case 'F': case 'f': case 'L': case 'l': return 1; default: return 0; } } /* Return 1 if u|U|f|F, otherwise 0 */ int is_IS(char c) { switch (c) { case 'u': case 'U': case 'l': case 'L': return 1; default: return 0; } } /* Fails miserably ;> */ void abnormal_fail(char *msg) { printf("Analyzer: abnormal fail: msg = %s\n", msg); exit(0); } /* abnormal_fail */ /* Retracts to the last marker. For now. */ void analyzer_fail() { int res = scanner_retract(-1); if (res == -1) { printf("analyzer_fail() failed.\n"); exit(0); } } /* analyzer_fail() */ /* Copy a string into another string, allocating memory before. */ char *str_cpy(char *source) { char *temp = malloc(strlen(source)+1); if (temp == NULL) abnormal_fail("Could not allocate memory."); strcpy(temp, source); return temp; } /* str_cpy() */ /* Returns the full comment without the star-slash. Assumes that the slash-star have been read before. Note: allocates its own space for the string returned. */ char *get_comment() { char ch, pk; int i = 0; char *res = NULL; res = append_char(res, '/'); while (1) { ch = scanner_next(); if (ch == 0) /* eof detected */ return NULL; if (ch == '*') { pk = scanner_peek(); if (pk == '/') { res = append_char(res, ch); ch = scanner_next(); res = append_char(res, ch); return res; } } res = append_char(res, ch); } } /* get_comment */ /* Return the E, defined as [Ee][+|-]?{D}+ */ char *get_E(char first) { char ch; char *E = NULL; E = append_char(E, first); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if ((ch == '+') || (ch == '-')) E = append_char(E, ch); if (!is_digit(ch)) { analyzer_fail(); return NULL; } /* read for digits now */ while (is_digit(ch)) { E = append_char(E, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ } scanner_retract(1); return(E); } /* get_E() */ /* Returns the full identifier with argument prepended. Uses the first char read. */ char *get_identifier(char first) { char ch, pk; char *identifier = NULL; /* get the first letter into the identifier */ identifier = append_char(identifier, first); while (1) { ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (!is_digit(ch) && !is_letter(ch)) break; identifier = append_char(identifier, ch); } scanner_retract(1); return identifier; } /* get_identifier */ /* Returns the hex constant or NULL if not. First is assumed to be '0'. hex constant is defined as 0[xX]{H}+{IS}+ */ char *get_hexconst(char first) { char ch; char *hexc = NULL; hexc = append_char(hexc, first); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if ((ch != 'x') && (ch != 'X')) { analyzer_fail(); return NULL; } hexc = append_char(hexc, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (!is_hexdigit(ch)) { analyzer_fail(); return NULL; } /* now read the hexdigits until exhausted */ while (is_hexdigit(ch)) { hexc = append_char(hexc, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (is_IS(ch)) { hexc = append_char(hexc, ch); return hexc; } } scanner_retract(1); return hexc; } /* get_hexconst() */ /* Return a digital constant of form {D}+{IS}? or NULL. */ char *get_dconst(char first) { char ch; char *digc = NULL; digc = append_char(digc, first); /* now add all other digits following */ ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ while (is_digit(ch)) { digc = append_char(digc, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (is_IS(ch)) { digc = append_char(digc, ch); return digc; } } scanner_retract(1); return digc; } /* get_dconst() */ /* Return a digital constant with a leading zero of form 0{D}+{IS}? */ char *get_leading_dconst(char first) { char ch; char *ldigc; char *digc; char *temp = NULL; ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (!is_digit(ch)) { analyzer_fail(); return NULL; } /* get the rest of the constant */ digc = get_dconst(ch); if (digc == NULL) return NULL; /* get the final result starting char */ temp = append_char(temp, first); /* allocate memory for the final result */ ldigc = malloc(strlen(digc) + strlen(temp)); if (ldigc == NULL) abnormal_fail("Not enough memory."); /* the result is going into ldigc */ ldigc = strcat(temp, digc); return ldigc; } /* get_leading_dconst() */ /* Returns a char literal of form '(\\.|[^\\'])+' or NULL if not recognized. */ char *get_char_literal(char first) { char ch; char *literal = NULL; literal = append_char(literal, first); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (ch == '\\') { literal = append_char(literal, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if ((ch == '\"') || (ch == 't') || (ch == 'v') || (ch == 'n') || (ch == 'f')) { literal = append_char(literal, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (ch == '\'') { /* form '\v' or '\n' or '\t' or '\f' recognized */ literal = append_char(literal, ch); return literal; } analyzer_fail(); return NULL; } /* perhaps it is a '\DDD' constant (or '\DD' or '\D') */ if (is_digit(ch)) { literal = append_char(literal, ch); ch = scanner_next(); if (ch == 0) return NULL; if (ch == '\'') { /* recognized '\D' */ literal = append_char(literal, ch); return literal; } if (!is_digit(ch)) { analyzer_fail(); return NULL; } literal = append_char(literal, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (ch == '\'') { /* recognized '\DD' */ literal = append_char(literal, ch); return literal; } if (!is_digit(ch)) { analyzer_fail(); return NULL; } literal = append_char(literal, ch); /* try for the '\DDD' constant */ ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (ch == '\'') { /* recognized '\DDD' constant */ literal = append_char(literal, ch); return literal; } analyzer_fail(); return NULL; } if ((ch == '\'') || (ch == '\\')) { /* case of '\'' */ literal = append_char(literal, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (ch == '\'') { literal = append_char(literal, ch); return literal; } analyzer_fail(); return NULL; } analyzer_fail(); return NULL; } /* case of a normal char constant such as 'a' */ literal = append_char(literal, ch); ch = scanner_next(); if (ch == 0) return NULL; if (ch == '\'') { literal = append_char(literal, ch); return literal; } analyzer_fail(); return NULL; } /* get_char_literal() */ /* Return a scientific integer constant of form {D}+{E}{FS}? or NULL. */ char *get_E_dconst(char first) { char ch; char *temp = NULL; char *econst = NULL; /* result here */ char *E = NULL; temp = append_char(temp, first); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ while (is_digit(ch)) { temp = append_char(temp, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ } if ((ch == 'e') || (ch == 'E')) { /* allocate ram for the result in econst */ E = get_E(ch); if (E == NULL) return NULL; econst = malloc(strlen(temp) + strlen(E)); econst = strcat(temp, E); /* from now on we append to econst */ ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (is_FS(ch)) econst = append_char(econst, ch); return econst; } analyzer_fail(); return NULL; } /* get_E_dconst() */ /* Returns a constant of the form {D}*"."{D}+({E})?{FS}? or NULL. */ char *get_E_dstarconst(char first) { char ch; char *temp = NULL; char *dstar = NULL; char *E = NULL; temp = append_char(temp, first); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ while (is_digit(ch)) { temp = append_char(temp, ch); ch = scanner_next(ch); if (ch == 0) return NULL; /* EOF */ } if (ch == '.') { temp = append_char(temp, ch); ch = scanner_next(); if (!is_digit(ch)) { analyzer_fail(); return NULL; } temp = append_char(temp, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ while(is_digit(ch)) { temp = append_char(temp, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ } if ((ch == 'e') || (ch == 'E')) { /* append the E part now */ E = get_E(ch); if (E == NULL) { analyzer_fail(); return NULL; } /* allocate memory for the result in dstar */ dstar = malloc(strlen(temp) + strlen(E)); if (dstar == NULL) abnormal_fail("Memory allocation error (starconst)."); dstar = strcat(temp, E); /* get the next char */ ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ } else { /* put temp into dstar since thats our result now */ dstar = malloc(strlen(temp)); if (dstar == NULL) abnormal_fail("Memory allocation error (starconst)."); strcpy(dstar, temp); } /* test if we have an FS */ if (is_FS(ch)) { dstar = append_char(dstar, ch); return dstar; } scanner_retract(1); return dstar; } analyzer_fail(); return NULL; } /* Returns recognized constant {D}+"."{D}*({E})?{FS}? or NULL. */ char *get_E_dplusconst(char first) { char ch; char *temp = NULL; char *dplus = NULL; char *E = NULL; temp = append_char(temp, first); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (!is_digit(ch)) { analyzer_fail(); return NULL; } temp = append_char(temp, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ while (is_digit(ch)) { temp = append_char(temp, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ } if (ch == '.') { temp = append_char(temp, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ while (is_digit(ch)) { temp = append_char(temp, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ } if ((ch == 'e') || (ch == 'E')) { E = get_E(ch); if (E == NULL) { analyzer_fail(); return NULL; } dplus = malloc(strlen(temp)+strlen(E)); if (dplus == NULL) abnormal_fail("Memory allocation error (analyzer)."); dplus = strcat(temp, E); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (is_FS(ch)) { dplus = append_char(dplus, ch); return dplus; } scanner_retract(1); return dplus; } /* else test if maybe we dont have E but have an FS */ /* before that setup the return */ if (is_FS(ch)) { temp = append_char(temp, ch); return temp; } } analyzer_fail(); return NULL; } /* get_E_dplusconst() */ /* Returns string literal of form "(\\.|[^\\"])*" or NULL. */ char *get_string_literal(char first) { char ch; char *slit = NULL; slit = append_char(slit, first); while (1) { lbl: ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if (ch == '\\') { slit = append_char(slit, ch); ch = scanner_next(); if (ch == 0) return NULL; /* EOF */ if ((ch == 't') || (ch == 'n') || (ch == 'v') || (ch == 'f') || (ch == '\\') || (ch == '\"') || (is_digit(ch))) { slit = append_char(slit, ch); goto lbl; } else { analyzer_fail(); return NULL; } } if (ch == '\"') { slit = append_char(slit, ch); return slit; } slit = append_char(slit, ch); } /* while */ } /* get_string_literal() */ /* Skips over whitespace. */ void skip_whitespace() { char ch; ch = scanner_next(); if (ch == 0) return; /* EOF */ while (is_whitespace(ch)) { ch = scanner_next(); if (ch == 0) return; } return; } /* skip_whitespace() */ /* Returns 1 if a string parameter is recognized, 0 if not. */ int recognized(char *str) { char ch; int i; for (i = 0; i < strlen(str); i++) { ch = scanner_next(); if (ch == 0) return 0; /* EOF */ if (str[i] != ch) { analyzer_fail(); return 0; } } return 1; } /* recognized() */ /* Main parser function - returns a (token, type_of_token) pair. */ struct tokenpair *next_token() { char ch, pk; struct tokenpair *tp; char *temp = NULL; /* allocate memory for the token pair */ tp = malloc(sizeof(struct tokenpair)); if (tp == NULL) abnormal_fail("next_token() memory allocation failure"); /* and set the char * member to NULL */ tp->token = NULL; start_func: /* this is where the intelligence is */ ch = scanner_next(); if (ch == 0) return NULL; /* set a scanner marker */ scanner_mark(); /* is it a comment? */ if (ch == '/') { pk = scanner_peek(); if (pk == '*') { temp = get_comment(); if (temp != NULL) { tp->token = str_cpy(temp); tp->type = COMMENT; return tp; } else return NULL; } else { tp->token = str_cpy("/"); return tp; } } if (is_letter(ch)) { temp = get_identifier(ch); if (!strcmp(temp, "auto")) tp->type = AUTO; else if (!strcmp(temp, "break")) tp->type = BREAK; else if (!strcmp(temp, "case")) tp->type = CASE; else if (!strcmp(temp, "char")) tp->type = CHAR; else if (!strcmp(temp, "const")) tp->type = CONST; else if (!strcmp(temp, "continue")) tp->type = CONTINUE; else if (!strcmp(temp, "default")) tp->type = DEFAULT; else if (!strcmp(temp, "do")) tp->type = DO; else if (!strcmp(temp, "double")) tp->type = DOUBLE; else if (!strcmp(temp, "else")) tp->type = ELSE; else if (!strcmp(temp, "enum")) tp->type = ENUM; else if (!strcmp(temp, "extern")) tp->type = EXTERN; else if (!strcmp(temp, "float")) tp->type = FLOAT; else if (!strcmp(temp, "for")) tp->type = FOR; else if (!strcmp(temp, "goto")) tp->type = GOTO; else if (!strcmp(temp, "if")) tp->type = IF; else if (!strcmp(temp, "int")) tp->type = INT; else if (!strcmp(temp, "long")) tp->type = LONG; else if (!strcmp(temp, "register")) tp->type = REGISTER; else if (!strcmp(temp, "return")) tp->type = RETURN; else if (!strcmp(temp, "short")) tp->type = SHORT; else if (!strcmp(temp, "signed")) tp->type = SIGNED; else if (!strcmp(temp, "sizeof")) tp->type = SIZEOF; else if (!strcmp(temp, "static")) tp->type = STATIC; else if (!strcmp(temp, "struct")) tp->type = STRUCT; else if (!strcmp(temp, "switch")) tp->type = SWITCH; else if (!strcmp(temp, "typedef")) tp->type = TYPEDEF; else if (!strcmp(temp, "union")) tp->type = UNION; else if (!strcmp(temp, "unsigned")) tp->type = UNSIGNED; else if (!strcmp(temp, "void")) tp->type = VOID; else if (!strcmp(temp, "volatile")) tp->type = VOLATILE; else if (!strcmp(temp, "while")) tp->type = WHILE; else { tp->type = IDENTIFIER; tp->token = str_cpy(temp); } return tp; } if (ch == '0') { /* is it a constant starting with a zero? */ temp = get_hexconst(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); return tp; } temp = get_leading_dconst(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); return tp; } } if (is_digit(ch)) { temp = get_E_dconst(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); return tp; } temp = get_E_dplusconst(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); return tp; } temp = get_E_dstarconst(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); return tp; } temp = get_dconst(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); return tp; } return NULL; } /* now check for all other cases */ if (ch == '\'') { temp = get_char_literal(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); return tp; } return NULL; } if (ch == '\"') { temp = get_string_literal(ch); if (temp != NULL) { tp->type = STRING_LITERAL; tp->token = str_cpy(temp); return tp; } return NULL; } if (ch == '.') { temp = get_E_dstarconst(ch); if (temp != NULL) { tp->type = CONSTANT; tp->token = str_cpy(temp); } else if (recognized("..")) tp->type = ELLIPSIS; else { tp->type = SINGLE; tp->token = str_cpy("."); } return tp; } if (ch == '>') { if (recognized(">=")) tp->type = RIGHT_ASSIGN; else if (recognized(">")) tp->type = RIGHT_OP; else if (recognized("=")) tp->type = GE_OP; else { tp->type = SINGLE; tp->token = str_cpy(">"); } return tp; } if (ch == '<') { if (recognized("<=")) tp->type = LEFT_ASSIGN; else if (recognized("<")) tp->type = LEFT_OP; else if (recognized("=")) tp->type = LE_OP; else if (recognized("%")) { tp->type = SINGLE; tp->token = str_cpy("{"); } else if (recognized(":")) { tp->type = SINGLE; tp->token = str_cpy("["); } else { tp->type = SINGLE; tp->token = str_cpy("<"); } return tp; } if (ch == '+') { if (recognized("=")) tp->type = ADD_ASSIGN; else if (recognized("+")) tp->type = INC_OP; else { tp->type = SINGLE; tp->token = str_cpy("+"); } return tp; } if (ch == '-') { if (recognized("=")) tp->type = SUB_ASSIGN; else if (recognized("-")) tp->type = DEC_OP; else if (recognized(">")) tp->type = PTR_OP; else { tp->type = SINGLE; tp->token = str_cpy("-"); } return tp; } if (ch == '*') { if (recognized("=")) tp->type = MUL_ASSIGN; else { tp->type = SINGLE; tp->token = str_cpy("*"); } return tp; } if (ch == '/') { if (recognized("=")) tp->type = DIV_ASSIGN; else { tp->type = SINGLE; tp->token = str_cpy("/"); } return tp; } if (ch == '%') { if (recognized("=")) tp->type = MOD_ASSIGN; if (recognized(">")) { tp->type = SINGLE; tp->token = str_cpy("}"); } else { tp->type = SINGLE; tp->token = str_cpy("%"); } return tp; } if (ch == '&') { if (recognized("=")) tp->type = AND_ASSIGN; else if (recognized("&")) tp->type = AND_OP; else { tp->type = SINGLE; tp->token = str_cpy("&"); } return tp; } if (ch == '^') { if (recognized("=")) tp->type = XOR_ASSIGN; else { tp->type = SINGLE; tp->token = str_cpy("^"); } return tp; } if (ch == '|') { if (recognized("=")) tp->type = OR_ASSIGN; else if (recognized("|")) tp->type = OR_OP; else { tp->type = SINGLE; tp->token = str_cpy("|"); } return tp; } if (ch == '=') { if (recognized("=")) tp->type = EQ_OP; else { tp->type = SINGLE; tp->token = str_cpy("="); } return tp; } if (ch == '!') { if (recognized("=")) tp->type = NE_OP; else { tp->type = SINGLE; tp->token = str_cpy("!"); } return tp; } if (ch == ';') { tp->type = SINGLE; tp->token = str_cpy(";"); return tp; } if (ch == '{') { tp->type = SINGLE; tp->token = str_cpy("{"); return tp; } if (ch == '}') { tp->type = SINGLE; tp->token = str_cpy("}"); return tp; } if (ch == ',') { tp->type = SINGLE; tp->token = str_cpy(","); return tp; } if (ch == ':') { tp->type = SINGLE; if (recognized(">")) tp->token = str_cpy("]"); else tp->token = str_cpy(":"); return tp; } if (ch == '(') { tp->type = SINGLE; tp->token = str_cpy("("); return tp; } if (ch == ')') { tp->type = SINGLE; tp->token = str_cpy(")"); return tp; } if (ch == '[') { tp->type = SINGLE; tp->token = str_cpy("["); return tp; } if (ch == ']') { tp->type = SINGLE; tp->token = str_cpy("]"); return tp; } if (ch == '~') { tp->type = SINGLE; tp->token = str_cpy("~"); return tp; } if (ch == '?') { tp->type = SINGLE; tp->token = str_cpy("?"); return tp; } if (is_whitespace(ch)) { skip_whitespace; goto start_func; } return NULL; } /* next_token() */ c_cinsight/parser.c0000644000176400017640000011417407753761257015133 0ustar ognenognen00000000000000/* parser.c This module recognizes the tokens as a part of the C grammar produced strings. Parsing with full-backup is implemented. Uses: * constants.h -> all constants returned by the analyzer * analyzer.h -> next_token function * structs.h -> the token structure Written by Ognen Duzlevski rev 0.0.1 To-do: * clean up the code to utilize labels in order to make it simpler and easier to read * test more? History: */ #include "constants.h" #include "structs.h" #include "analyzer.h" #include "scanner.h" #include "utility.h" /* some helper routines follow */ int failure(int marker) { queue_set_marker(marker); return 0; } /* check if the token is a single and a specified character */ int test_token_single(tokenpair *tp, char ch) { if ((tp->type == SINGLE) && (tp->token[0] == ch)) return 1; else return 0; } /* make life easier (a bit ;) */ tokenpair *get_next_token() { tokenpair *tp = queue_next_token(); check_eof(tp); return tp; } /* Recognize a primary_expression. See code for definition of one. Returns 1 if successful, otherwise 0. */ int primary_expression() { tokenpair *tp; int marker = queue_get_marker(); tp = get_next_token(); if ((tp->type == IDENTIFIER) || (tp->type == CONSTANT) || (tp->type==STRING_LITERAL)) { tp = get_next_token(); if test_token_single(tp, ';') return 1; /* test for ( expression ) */ if (!strcmp(tp->token, "(")) { /* now fetch the expression */ if (!expression()) return failure(marker); tp = get_next_token(); if test_token_single(tp, ')') { tp = get_next_token(); if test_token_single(tp, ';') return 1; else return failure(marker); } } } else return failure(marker); } /* Recognize a postfix_expression. See code for definition of one. Returns 1 if successful, otherwise 0. */ int postfix_expression() { struct tokenpair *tp; int m1; int marker = queue_get_marker(); /* check for [ expression ]; */ int expr_1() { struct tokenpair *tkn; int mark = queue_get_marker(); tkn = get_next_token(); if test_token_single(tkn, '[') { if (!expression()) return failure(mark); else { tkn = get_next_token(); if test_token_single(tkn, ']') return 1; else return failure(mark); } } else return failure(mark); } /* check for () */ int expr_2() { struct tokenpair *tkn; int mark = queue_get_marker(); tkn = get_next_token(); if test_token_single(tkn, '(') { tkn = get_next_token(); if test_token_single(tkn, ')') return 1; else return failure(mark); } else return failure(mark); } /* check for ( argument_expression_list ) */ int expr_3() { struct tokenpair *tkn; int mark = queue_get_marker(); tkn = get_next_token(); if test_token_single(tkn, '(') { if (!argument_expression_list()) return failure(mark); else { tkn = get_next_token(); if test_token_single(tkn, ')') return 1; else return failure(mark); } } else return failure(mark); } int expr_4() { struct tokenpair *tkn; int mark = queue_get_marker(); tkn = get_next_token(); if test_token_single(tkn, '.') { if (identifier()) return 1; else return failure(mark); } else return failure(mark); } int expr_5() { struct tokenpair *tkn; int mark = queue_get_marker(); tkn = get_next_token(); if (tkn->type == PTR_OP) { if (identifier()) return 1; else return failure(mark); } else return failure(mark); } int expr_6() { struct tokenpair *tkn; int mark = queue_get_marker(); tkn = get_next_token(); if ((tkn->type == INC_OP) || (tkn->type == DEC_OP)) return 1; else return failure(mark); } if (primary_expression()) { m1 = queue_get_marker(); tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else { queue_set_marker(m1); while (1) { if (expr_1() || expr_2() || expr_3() || expr_4() || expr_5() || expr_6()) { m1 = queue_get_marker(); tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else { queue_set_marker(m1); continue; } } else return failure(marker); } } return failure(marker); } else return failure(marker); } /* postfix_expression() */ /* Recognizes an argument_expression_list. See code for definition of it. Returns 1 for success, zero otherwise. */ int argument_expression_list() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (assignment_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (!test_token_single(tp, ',')) return failure(marker); } else return failure(marker); } return failure(marker); } int bracket_typename_bracket() { struct tokenpair *tkn; int mar = queue_get_marker(); tkn = get_next_token(); if (tkn->type == SIZEOF) { tkn = get_next_token(); if (test_token_single(tkn, '(')) { if (typename()) { tkn = get_next_token(); if (test_token_single(tkn, ')')) return 1; } else return failure(mark); } else return failure(mark); } else return failure(mark); } /* Recognizes a unary_expression. See code below for the definition. Returns 1 if success, zero for not. */ int unary_expression() { struct tokenpair *tp; int m1; int marker = queue_get_marker(); int expr_2() { int mark = queue_get_marker(); if (postfix_expression() || (unary_operator() && cast_expression())) return 1; else return failure(mark); } while (1) { m1 = queue_get_marker(); tp = get_next_token(); if (tp->type == SIZEOF) { queue_set_marker(m1); if (bracket_typename_bracket()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else return failure(marker); } } else if ((tp->type == INC_OP) || (tp->type == DEC_OP) || (tp->type == SIZEOF)) continue; else if (expr_2()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else return failure(marker); } else return failure(marker); } return failure(marker); } /* unary_expression() */ /* Recognizes a unary operator. See code below for definition. Returns 1 for success, zero otherwise. */ int unary_operator() { struct tokenpair *tp; int marker = queue_get_marker(); tp = get_next_token(); if ( (test_token_single(tp, '&')) || (test_token_single(tp, '*')) || (test_token_single(tp, '+')) || (test_token_single(tp, '-')) || (test_token_single(tp, '~')) || (test_token_single(tp, '!'))) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; } else return failure(marker); } /* unary_operator */ /* Recognizes a cast_expression. See code below for definition. Returns 1 for success, zero otherwise. */ int cast_expression() { struct tokenpair *tp; int marker = queue_get_marker(); /* recognizes ( type_name ) */ while (1) { if (unary_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else return failure(marker); } else if (bracket_typename_bracket()) continue; else return failure(marker); } return failure(marker); } /* cast_expression */ /* Recognizes a multiplicative_expression. See code below for defintion. Returns 1 if success, zero otherwise. */ int multiplicative_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (cast_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else { int t1, t2, t3; t1 = test_token_single(tp, '*'); t2 = test_token_single(tp, '%'); t3 = test_token_single(tp, '/'); if (t1 || t2 || t3) continue; else return failure(marker); } } else return failure(marker); } return failure(marker); } /* Recognizes an additive_expression. See code below for definition. Returns 1 for success, zero for not. */ int additive_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (multiplicative_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (test_token_single(tp, '+') || test_token_single(tp, '-')) continue; } else return failure(marker); } return failure(marker); } /* Recognizes a shift_expression. See code below for a definition. Returns 1 for success, zero...blah-blah-blah I am tired...just kill me... */ int shift_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (additive_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if ((tp->type == LEFT_OP) || (tp->type == RIGHT_OP)) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* Recognizes a relational_expression. Returns a 1 for success, 0 for not. */ int relational_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (shift_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else { int t1, t2, t3, t4; t1 = test_token_single(tp, '<'); t2 = test_token_single(tp, '>'); t3 = tp->type == LE_OP; t4 = tp->type == GE_OP; if (t1 || t2 || t3 || t4) continue; else return failure(marker); } } else return failure(marker); } return failure(marker); } /* relational_expression() */ /* Recognizes an equality_expression. See code below for details. Returns 1 for success, zero for failure. */ int equality_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (relational_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if ((tp->type == EQ_OP) || (tp->type == NE_OP)) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* Recognizes an and_expression. See code below for deifinition. Returns 1 for success, zero otherwise. */ int and_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (equality_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (test_token_single(tp, '&')) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* and_expression */ /* Recognizes an exclusive_or_expression. See code below for definition. Returns 1 if success, zero for failure. */ int exclusive_or_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (and_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (test_token_single(tp, '^')) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* Recognizes an inclusive_or_expression. See code below for definition. Returns 1 if success, zero for failure. */ int inclusive_or_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (exclusive_or_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (test_token_single(tp, '|')) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* Recognizes a logical_and_expression. See code below for definition. Returns 1 if success, zero for failure. */ int logical_and_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (inclusive_or_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (tp->type == AND_OP) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* Recognizes an locgical_or_expression. See code below for definition. Returns 1 if success, zero for failure. */ int inclusive_or_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (logical_and_expression()) { tp = get_next_token(); if (tp->type == OR_OP) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* Recognizes an conditional_expression. See code below for definition. Returns 1 if success, zero for failure. */ int conditional_expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (logical_or_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; if (test_token_single(tp, '?')) { if (expression()) { tp = get_next_token(); if (test_token_single(tp, ':')) continue; else return failure(marker); } else return failure(marker); } else return failure(marker); } else return failure(marker); } return failure(marker); } /* * Recognizes an assignment_expression. See code below for definition. * Returns 1 for success, zero for failure. */ int assignment_expression() { tokenpair *tp; int marker = queue_get_marker(); while (1) { if (conditional_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (unary_expression()) if (assignment_operator()) continue; else return failure(marker); return failure(marker); } else return failure(marker); } return failure(marker); } /* * Recognizes an assignment_operator. Streightforward. * 1 for success, 0 for failure. */ int assignment_operator() { struct tokenpair *tp; int marker = queue_get_marker(); tp = get_next_token(); switch (tp->type) { case MUL_ASSIGN: case DIV_ASSIGN: case MOD_ASSIGN: case ADD_ASSIGN: case SUB_ASSIGN: case LEFT_ASSIGN: case RIGHT_ASSIGN: case AND_ASSIGN: case XOR_ASSIGN: case OR_ASSIGN: return 1; default: if (test_token_single(tp, '=')) return 1; else return failure(marker); } /* switch */ } /* assignment_operator */ /* * Recognizes an expression. See code below for format. * 1 = success, 0 = failure */ int expression() { struct tokenpair *tp; int marker = queue_get_marker(); while (1) { if (assignment_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; else if (test_token_single(tp, ',')) continue; else return failure(marker); } else return failure(marker); } return failure(marker); } /* * Recognizes a constant_expression. Streightforward. * 1 = success, 0 = failure */ int constant_expression() { struct tokenpair *tp; int marker = queue_get_marker(); if (conditional_expression()) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; } return failure(marker); } /* constant_expression */ /* Recognizes a declaration. See code below for definition. 1 = success, 0 = failure */ int declaration() { struct tokenpair *tp; int m1; int marker = queue_get_marker(); if (declaration_specifiers()) { m1 = queue_get_marker(); tp = get_next_token(); if (test_token_single(tp, ';')) { tp = get_next_token(); if (test_token_single(tp, ';')) return 1; tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ";")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (init_declarator_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ";")) { queue_release_marker(marker); return 1; } } } queue_set_marker(marker); return 0; } /* declaration() */ /* Recognizes declaration_specifiers (see below for definition). 1 = success, 0 = failure. */ int declaration_specifiers() { int marker = queue_get_marker(); if (storage_class_specifier()) { if (declaration_specifiers()) { } queue_release_marker(marker); return 1; } queue_set_marker(marker); if (type_specifier()) { if declaration_specifiers()) { } queue_release_marker(marker); return 1; } queue_set_marker(marker); if (type_qualifier()) { if declaration_specifiers()) { } queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* declaration_specifiers() */ /* Recognizes an init_declarator_list. See below for definition. 1 = success, 0 = failure. */ int init_declarator_list() { struct tokenpair *tp; int marker = queue_get_marker(); if (init_declarator()) { queue_release_marker(marker); return 1; } if (init_declarator_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ",")) if (init_declarator()) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* init_declarator_list() */ /* Recognizes an init_declarator. See below for definition. 1 = success, 0 = failure. */ int init_declarator() { struct tokenpair *tp; int marker = queue_get_marker(); if (declarator()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "=")) { if (initializer()) { queue_release_marker(marker); return 1; } queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* init_declarator() */ /* Recognizes a storage_class_specifier. See below for definition. 1 = success. 0 = failure. */ int storage_class_specifier() { struct tokenpair *tp; int marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); switch (tp->type) { case TYPEDEF: case EXTERN: case STATIC: case AUTO: case REGISTER: { queue_release_marker(marker); return 1; } default: { queue_set_marker(marker); return 0; } } } /* storage_class_specifier() */ /* Recognizes a type_specifier. See below for definition. 1 = success, 0 = failure. */ int type_specifier() { struct tokenpair *tp; int marker = queue_get_marker(); if (struct_or_union_specifier()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (enum_specifier()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); tp = queue_next_token(); check_eof(tp); switch (tp->type) { case VOID: case CHAR: case SHORT: case INT: case LONG: case FLOAT: case DOUBLE: case SIGNED: case UNSIGNED: case TYPE_NAME: { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* type_specifier() */ /* Recognizes a struct_or_union_specifier. See code below for details. 1 = success, 0 = failure */ int struct_or_union_specifier() { struct tokenpair *tp; int marker = queue_get_marker(); if (struct_or_union()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "{")) { if (struct_declaration_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } if (tp->type == IDENTIFIER) { /* we are set to recognize here */ tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "{")) { if (struct_declaration_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* struct_or_union_specifier() */ /* Recognizes a struct_or_union. Piece of cake. 1 = success, 0 = failure. */ int struct_or_union() { struct tokenpair *tp; int marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if ( (tp->type == STRUCT) || (tp->type == UNION)) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* struct_or_union() */ /* Recognizes a struct_declaration_list. See belof for its defintion. 1 = success, 0 = failure */ int struct_declaration_list() { int marker = queue_get_marker(); if (struct_declaration()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (struct_declaration_list()) if (struct_declaration()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* struct_declaration_list() */ /* Recognizes a struct_declaration. See below. 1 = success, 0 = failure */ int struct_declaration() { struct tokenpair *tp; int marker = queue_get_marker(); if (specifier_qualifier_list() && struct_declarator_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ";")) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* struct_declaration() */ /* Recognizes a specifier_qualifier_list. The code below does not reflect the definition properly since it is recursive without a clear criteria on hwo to stop the recursion. Thus, it is broken into an iterative implementation. 1 = success, 0 = failure */ int specifier_qualifier_list() { int marker = queue_get_marker(); if (type_specifier()) { while (type_specifier()) { } while (type_qualifier()) { } queue_release_marker(marker); return 1; } queue_set_marker(marker); if (type_qualifier()) { while (type_specifier()) { } while (type_qualifier()) { } queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* specifier_qualifier_list() */ /* Recognizes a struct_declarator_list. See code below for a definition. 1 = success, 0 = failure. */ int struct_declarator_list() { struct tokenpair *tp; int marker = queue_get_marker(); if (struct_declarator()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (struct_declarator_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ",")) if (struct_declarator()) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* Recognizes a struct_declarator. Returns 1 if success, zero for failure. See code below for streightforward translation of the definion into code. */ int struct_declarator() { struct tokenpair *tp; int marker = queue_get_marker(); if (declarator()) { /* we already recognized something, see if there is anything left */ tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ":")) { if (!constant_expression()) { queue_set_marker(marker); return 0; } } queue_release_marker(marker); return 1; } /* ok, we have to back up */ queue_set_marker(marker); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ":")) if (constant_expression()) { queue_release_marker(marker); return 1; } /* failure */ queue_set_marker(marker); return 0; } /* struct_declarator */ /* Recognizes an enum_specifier. Interesting. I am in a good mood now for coding. 1 = success, 0 = failure */ int enum_specifier() { struct tokenpair *tp; int marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if (tp->type == ENUM) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "{")) { if (enumerator_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } if (tp->type == IDENTIFIER) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "{")) { if (enumerator_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* enum_specifier() */ /* Recognzies an enumerator_list. Should be easy. 1 = success, 0 = failure */ int enumerator_list() { struct tokenpair *tp; int marker = queue_get_marker(); if (enumerator()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (enumerator_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ",")) if (enumerator()) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* enumerator_list() */ /* Recognizes an enumerator. Lightwight :) 1 = success, 0 = failure */ int enumerator() { struct tokenpair *tp; int marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if (tp->type == IDENTIFIER) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "=")) if (constant_expression()) { queue_release_marker(marker); return 1; } else { queue_set_marker(marker); return 0; } queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* enumerator() */ /* type_qualifier is either CONST or VOLATILE. 1 = success, 0 = fail. */ int type_qualifier() { struct tokenpair *tp; int marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if ((tp->type == CONST) || (tp->type == VOLATILE)) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* type_qualifier() */ /* Recognizes a declarator. See below for definition. 1 = success, 0 = failure */ int declarator() { int marker = queue_get_marker(); if (pointer() && direct_declarator()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (direct_declarator()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* declarator() */ /* Recognizes a direct_declarator. Tough stuff. 1 = success, 0 = failure. */ int direct_declarator() { struct tokenpair *tp; int marker = queue_get_marker(); int temp_marker; /* is it an IDENTIFIER? */ tp = queue_next_token(); check_eof(tp); if (tp->type == IDENTIFIER) { queue_release_marker(marker); return 1; } /* or is it ( declarator ) */ if (!strcpy(tp->token, "(")) { if (declarator()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } queue_set_marker(marker); if (direct_declarator()) { temp_marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "[")) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "]")) { queue_release_marker(marker); return 1; } queue_set_marker(temp_marker); if (constant_expression()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "]")) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } if (!strcpy(tp->token, "(")) { temp_marker = queue_get_marker(); if (parameter_type_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(temp_marker); if (identifier_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(temp_marker); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 0; } } } queue_set_marker(marker); return 0; } /* direct_declarator() */ /* Recognizes a pointer. See definition of one below. Recursion is unraveleld below. 1 = success, 0 = failure. */ int pointer() { struct tokenpair *tp; label ptr; int marker = queue_get_token(); int temp_marker; tp = queue_next_token(); check_eof(tp); /* read first "*" */ if (!strcpy(tp->token, "*")) { /* we have a pointer, see if there is anything to ammend it */ ptr: do { temp_marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); } while (!strcpy(tp->token, "*")); queue_set_marker(temp_marker); if (type_qualifier_list()) goto ptr; queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* hope it's recognized alright */ /* Recognizes a type_qualifier_list. See code for easy implementation. 1 = success, 0 = failure */ int type_qualifier_list() { int marker = queue_get_marker(); if (type_qualifier()) { queue_release_marker(marker); return 1; } if (type_qualifier_list()) if (type_qualifier()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* type_qualifier_list() */ /* Recognizes a parameter_type_list. 1 = success, 0 = failure. */ int parameter_type_list() { struct tokenpair *tp; int marker = queue_get_marker(); if (parameter_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ",")) { tp = queue_next_token(); check_eof(tp); if (tp->type == ELLIPSIS) { queue_release_marker(marker); return 1; } else { queue_set_marker(marker); return 0; } } queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* parameter_type_list() */ /* Recognizes a parameter_list. See below for ... it is some minutes past midnight and I want to sleep.... 1 = success, 0 = failure */ int parameter_list() { struct tokenpair *tp; int marker = queue_get_marker(); if (parameter_declaration()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (parameter_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ",")) { if (parameter_declaration()) { queue_release_marker(marker); return 1; } } else { queue_set_marker(marker); return 0; } } queue_set_marker(marker); return 0; } /* parameter_list() */ /* Recognizes a parameter_declaration. See below, it is all easy. 1 = success, 0 = failure. */ int parameter_declaration() { label jmp; int marker = queue_get_marker(); if (declaration_specifiers()) { if (declarator()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (!abstract_declarator()) goto jmp; queue_release_marker(marker); return 1; } jmp: queue_set_marker(marker); return 0; } /* parameter_declaration() */ /* Recognizes an identifier_list. Hmmmm. 1 = success, 0 = failure */ int identifier_list() { struct tokenpair *tp; int marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if (tp->type == IDENTIFIER) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (identifier_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ",")) { tp = queue_next_token(); check_eof(tp); if (tp->type == IDENTIFIER) { queue_release_marker(marker); return 1; } } } queue_set_marker(marker); return 0; } /* identifier_list() */ /* Recognizes a type_name. I hate C language by now.... 1 = sucess, 0 = failure */ int type_name() { label jmp; int marker = queue_get_marker(); if (specifier_qualifier_list()) { if (!abstract_declarator()) goto jmp; queue_release_marker(marker); return 1; } jmp: queue_set_marker(marker); return 0; } /* type_name() */ /* Recognizes an abstract_declarator(). 1 = success, 0 = fail. */ int abstract_declarator() { label jmp; int marker = queue_get_marker(); if (pointer()) { if (!direct_abstract_declarator()) goto jmp; queue_release_marker(marker); return 1; } jmp: queue_set_marker(marker); if (direct_abstract_declarator()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* abstract_declarator() */ /* Recognizes the direct_abstract_declarator. Probably the longest function here. See below for the complicated definition. 1 = success, 0 = fail. */ int direct_abstract_declarator() { struct tokenpair *tp; int marker = queue_get_marker(); int temp_marker; tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "(")) { /* everything starting with a bracket */ temp_marker = queue_get_marker(); if (abstract_declarator()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(temp_marker); if (parameter_type_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(temp_marker); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } if (!strcpy(tp->token, "[")) { temp_marker = queue_get_marker(); if (constant_expression()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "]")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(temp_marker); if (!strcpy(tp->token, "]")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(marker); if (direct_abstract_declarator()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "[")) { temp_marker = queue_get_marker(); if (constant_expression()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "]")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(temp_marker); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "]")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } if (!strcpy(tp->token, "(")) { temp_marker = queue_get_marker(); if (parameter_type_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } queue_set_marker(temp_marker); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ")")) { queue_release_marker(marker); 5H H return 1; } } } queue_set_marker(marker); return 0; } /* direct_abstract_declarator() */ /* Recognizes an initializer. See code below for definition. 1 = success, 0 = failure. */ int initializer() { struct tokenpair *tp; int marker = queue_next_marker(); if (assignment_expression()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "{")) { if (initializer_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) { queue_release_marker(marker); return 1; } if (!strcpy(tp->token, ",")) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) { queue_release_marker(marker); return 1; } } } } queue_set_marker(marker); return 0; } /* initializer() */ /* Recognizes an initializer_list. 1 = success, 0 = failure. */ int initializer_list() { struct tokenpair *tp; int marker = queue_get_marker(); if (initializer()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (initializer_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ",")) if (initializer()) { queue_release_marker(marker); return 1; } } queue_set_marker(marker); return 0; } /* initializer_list() */ /* Recognizes a statement. Hmmmm..... 1 = success, 0 = failure */ int statement() { label success; int marker = queue_get_marker(); if (labeled_statement()) goto success; queue_set_marker(marker); if (compund_statement()) goto success; queue_set_marker(marker); if (expression_statement()) goto success; queue_set_marker(marker); if (selection_statement()) gogo success; queue_set_marker(marker); if (iteration_statement()) goto success; queue_set_marker(marker); if (jump_statement()) goto success; queue_set_marker(marker); return 0; success: queue_release_marker(marker); return 1; } /* statement() */ /* Recognizes a labeled_statement. See below. 1 = success, 0 = failure. */ int labeled_statement() { struct tokenpair *tp; label success; label failure; int marker = queue_next_marker(); tp = queue_next_token(); check_eof(tp); if ((tp->type == IDENTIFIER) || (tp_type == DEFAULT)) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ":")) if (statement()) goto success; goto failure; } if (tp->type == CASE) { if (constant_expression()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, ":")) if (statement()) goto success; } goto failure; } failure: queue_set_marker(marker); return 0; success: queue_release_marker(marker); return 1; } /* labeled_statement() */ /* Recognizes a compound_statement. See below. 1 = success, 0 = failure */ int compound_statement() { struct tokenpair *tp; label success; label failure; int temp_marker; int marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "{")) { temp_marker = queue_get_marker(); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) goto success; queue_set_marker(temp_marker); if (statement_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) goto success; goto failure; } queue_set_marker(temp_marker); if (declaration_list()) { temp_marker = queue_get_marker(); if (statement_list()) { tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) goto success; goto failure; } queue_set_marker(temp_marker); tp = queue_next_token(); check_eof(tp); if (!strcpy(tp->token, "}")) goto success; } } failure: queue_set_marker(marker); return 0; success: queue_release_marker(marker); return 1; } /* compound_statement() */ /* Recognizes a declaration_list(). Success = 1, 0 = failure */ int declaration_list() { int marker = queue_get_marker(); if (declaration()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); if (declaration_list()) if (declaration()) { queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* declaration_list() */ /* Recognizes a statement_list. 1 = success, 0 = failure. */ int statement_list() { int temp_marker; int marker = queue_next_marker(); if (statement()) { while (statement()) { } queue_release_marker(marker); return 1; } queue_set_marker(marker); return 0; } /* statement_list() */ c_cinsight/queue.c0000644000176400017640000000523707753761260014754 0ustar ognenognen00000000000000/* queue.c This file implements buffering on top of the analyzer (tokens). It also implements a way to set and release markers in the buffer. Written by Ognen Duzlevski rev 0.0.1 */ #include #include "analyzer.h" #include "structs.h" #include "utility.h" /* global node structure */ struct node { struct tokenpair *tp; struct node *next; }; /* some globals */ struct node *first = NULL; struct node *last = NULL; struct node *current = NULL; /* Initialize the buffer. Assumes the scanner has been initialized. */ void queue_init() { struct tokenpair *tp; first = malloc(sizeof(struct node)); if (first == NULL) die("queue_init: malloc() error."); first->tp = NULL; first->next = NULL; last = first; current = first; } /* Returns the position (marker) of the current node */ int queue_get_marker() { int i = 0; struct node *temp = first; while (temp != current) { i++; temp = temp->next; } return i; } /* Sets the current pointer to the marker. If marker is past the end of queue, it will be set to the end of queue. Negative markers and a zero marker will set the current to the beginning of the list. */ void queue_set_marker(int marker) { int i; struct node *temp = first; for (i = 0; i < marker; i++) { temp = temp->next; if (temp == last) break; } current = temp; } /* Truncates the list past the current pointer. */ void queue_truncate() { struct node *temp; struct node *kill; /* if we are already at the end of the list just exit */ if (current == last) return; /* we need to release the memory past the end */ temp = current->next; while (temp != last) { kill = temp; temp = temp->next; free(kill); } /* free the node pointed to by last */ free(temp); /* and set the current node to be the last in the queue */ last = current; } struct tokenpair *queue_next_token() { struct tokenpair *tp; struct node *temp; if (current->tp == NULL) { /* read off the token from the file */ tp = next_token(); if (tp == NULL) return NULL; /* copy the token to current */ strcpy(current->tp->token, tp->token); current->tp->type = tp->type; /* make the last entry in the queue (expand the queue) */ temp = malloc(sizeof(struct node)); if (temp == NULL) die("queue_next_token: malloc() failure."); /* default the new entry */ temp->next = NULL; temp->tp = NULL; /* adjust the list pointers */ current->next = temp; last = temp; return tp; } /* else: advance current */ temp = current; current = current->next; return temp->tp; } /* HIGH LEVEL INTERFACE */ /* Set marker and truncate */ void queue_release_marker(int marker) { queue_set_marker(marker); queue_truncate(); } c_cinsight/scanner.c0000644000176400017640000000470407753761260015257 0ustar ognenognen00000000000000/* scanner.c -> a module providing following functions: scanner_init(char *filename) -> opens the file for input scanner_next() -> read the next character from the file scanner_peek() -> peeks into the next character from the file scanner_mark() -> marks the current position within the file scanner_retract(numbytes) -> retracts to the mark or numbytes back written by Ognen Duzlevski rev 0.0.1 untested */ #include #include #include #include #include #include #include int buf_size = 8192; /* default size for the buffer */ int marker = -1; int buf_pos = 0; /* current position within the buffer */ char *buf; /* the global buffer */ int file_size = 0; /* opens the file and initializes the scanner */ void scanner_init(char *file) { int count, file_des; int iter = 0; /* the file is open as a binary so that we can seek into it */ file_des = open(file, O_RDONLY); if (file_des == -1) { printf("Problem opening file %s.\n", file); exit(0); } /* here we will read everything into a global buffer */ if ((buf = (char *)malloc(buf_size * sizeof(char))) == NULL) { perror("malloc()"); exit(errno); } do { count = read(file_des, buf + file_size, buf_size); if (count == -1) { perror("read():"); exit(errno); } file_size += count; if (count < buf_size) break; else { /* we need to realloc the buffer */ iter++; if ((buf = realloc(buf, buf_size * iter)) == NULL) { perror("malloc()"); exit(errno); } } } while (1); /* the buffer has been read here */ close(file_des); } /* return a position marker in the file (-1 if error) */ void scanner_mark() { marker = buf_pos; } /* retracts to the marker if exists (numbytes == -1) or numbytes back */ int scanner_retract(int numbytes) { if (numbytes == -1) if (marker != -1) return marker; else return -1; else /* since we are retracting -> we need minus numbytes below */ if (buf_pos - numbytes > 0) { buf_pos -= numbytes; return buf_pos; } else return -1; } /* returns the next character in the file */ char scanner_next() { char ch; if (buf_pos > file_size) return 0; else return buf[buf_pos++]; } /* peek into the file without advancing file pointer */ char scanner_peek() { char ch = scanner_next(); if (ch == 0) return 0; scanner_retract(1); return ch; } void scanner_buf_release() { free(buf); buf = NULL; buf_pos = -1; } c_cinsight/utility.c0000644000176400017640000000055107753761260015325 0ustar ognenognen00000000000000/* utility.c Any utility routine I can thik of. Written by Ognen Duzlevski rev 0.0.1 */ #include void die(char *msg) { printf("fatal error: "); if (msg != NULL) printf("%s ", msg); printf("Aborting...\n"); exit(0); } /* Checks for EOF and then dies if so. */ void check_eof(void *ptr) { if (ptr == NULL) die("EOF detected."); }c_cinsight/analyzer.h0000644000176400017640000000020407753761271015451 0ustar ognenognen00000000000000/* analyzer.h -> header file for analyzer.c written by Ognen Duzlevski rev 0.0.1 untested */ struct tokenpair *next_token();c_cinsight/constants.h0000644000176400017640000000247407753761272015654 0ustar ognenognen00000000000000/* constants.h -> header file containing all global constants written by Ognen Duzlevski rev 0.0.1 untested This file contains all of the constants defined for the type of token returned. */ /* below are markers for different types of tokens */ #define SINGLE 0 #define AUTO 1 #define BREAK 2 #define CASE 3 #define CHAR 4 #define CONST 5 #define CONTINUE 6 #define DEFAULT 7 #define DO 8 #define DOUBLE 9 #define ELSE 10 #define ENUM 11 #define EXTERN 12 #define FLOAT 13 #define FOR 14 #define GOTO 15 #define IF 16 #define INT 17 #define LONG 18 #define REGISTER 19 #define RETURN 20 #define SHORT 21 #define SIGNED 22 #define SIZEOF 23 #define STATIC 24 #define STRUCT 25 #define SWITCH 26 #define TYPEDEF 27 #define UNION 28 #define UNSIGNED 29 #define VOID 30 #define VOLATILE 31 #define WHILE 32 #define IDENTIFIER 33 #define CONSTANT 34 #define STRING_LITERAL 35 #define ELLIPSIS 36 #define RIGHT_ASSIGN 37 #define LEFT_ASSIGN 38 #define ADD_ASSIGN 39 #define SUB_ASSIGN 40 #define MUL_ASSIGN 41 #define DIV_ASSIGN 42 #define MOD_ASSIGN 43 #define AND_ASSIGN 44 #define XOR_ASSIGN 45 #define OR_ASSIGN 46 #define RIGHT_OP 47 #define LEFT_OP 48 #define INC_OP 49 #define DEC_OP 50 #define PTR_OP 51 #define AND_OP 52 #define OR_OP 53 #define LE_OP 54 #define GE_OP 55 #define EQ_OP 56 #define NE_OP 57 #define COMMENT 58c_cinsight/queue.h0000644000176400017640000000042707753761272014760 0ustar ognenognen00000000000000/* queue.h Declaration of all exports from queue.c Written by Ognen Duzlevski rev 0.0.1 */ void queue_init(); int queue_get_marker(); void queue_set_marker(int marker); void queue_truncate(); struct tokenpair *queue_next_token(); void queue_release_marker(int marker);c_cinsight/scanner.h0000644000176400017640000000040007753761272015254 0ustar ognenognen00000000000000/* scanner.h -> header file for scanner.c written by Ognen Duzlevski rev 0.0.1 untested */ void scanner_init(char *file); void scanner_mark(); int scanner_retract(int numbytes); char scanner_next(); char scanner_peek(); void scanner_buf_release(); c_cinsight/structs.h0000644000176400017640000000036707753761272015346 0ustar ognenognen00000000000000/* structs.h -> header file containing the shared structure for the token, type pair written by Ognen Duzlevski rev 0.0.1 untested */ /* we need to deal with a token value and a token type */ struct tokenpair { char *token; int type; };c_cinsight/utility.h0000644000176400017640000000022407753761272015332 0ustar ognenognen00000000000000/* utility.h Lists routines declared by utility.c Written by Ognen Duzlevski rev 0.0.1 */ void die(char *msg); void check_eof(void *ptr);c_cinsight/Makefile0000644000176400017640000000035010524163025015074 0ustar ognenognen00000000000000OBJS=scanner.o utility.o queue.o analyzer.o OMPILER = gcc CCFLAGS = -g scanner.o: scanner.c scanner.h utility.o: utility.c utility.h queue.o: queue.c queue.h analyzer.o: analyzer.c analyzer.h all: $(OBJS) clean: rm -rf $(OBJS)