lexer.l

C程序漏洞检查！

<INITIAL>"->"       { SETPOS_NDE(ARROW); return(ARROW); }

<INITIAL>"?"        { SETPOS_NDE(QUESTMARK); return(QUESTMARK); }
<INITIAL>":"        { SETPOS_NDE(COLON); return(COLON); }
<INITIAL>";"        { SETPOS_NDE(SEMICOLON); return(SEMICOLON); }
<INITIAL>","        { SETPOS_NDE(COMMA); return(COMMA); }
<INITIAL>"..."      { SETPOS_LEAF(ELLIPSIS,TN_ELLIPSIS); return(ELLIPSIS); }

	/* Unused (invalid) characters */
<INITIAL>"`"        { SETPOS_NDE(BACKQUOTE); return(BACKQUOTE); }
<INITIAL>"@"        { SETPOS_NDE(AT); return(AT); }
<INITIAL>"$"        { SETPOS_NDE(DOLLAR); return(DOLLAR); }

	/* Preprocessor Stuff */
<INITIAL>{pp_strt}\n       { Parse_TOS->yylineno++; Parse_TOS->yynxtcol = 0; }
<INITIAL>{pp_strt}{digits}.*$ { BEGIN_PP(); get_lineno(); }
<INITIAL>{pp_strt}"define" {
                             int n = yyleng;
                             BEGIN_PP();
                             tokn_ptr = tokn_buff;
                             if (tokn_ptr + n < tokn_end) {
                                 memcpy(tokn_ptr,yytext,n);
                                 tokn_ptr += n;
                             } else 
                                yywarn("Preprocessor line too long");
                             SETPOS_LEAF(PP_DEFINE,TN_CPP);
                           }
<INITIAL>{pp_strt}"include" { BEGIN_PP(); }
<INITIAL>{pp_strt}"line"   { BEGIN_PP(); get_lineno(); }
<INITIAL>{pp_strt}"pragma" { BEGIN_PP(); }
<INITIAL>{pp_strt}"ident"  { BEGIN_PP(); }
<INITIAL>{pp_strt}"if"     { BEGIN_PP(); }
<INITIAL>{pp_strt}"ifdef"  { BEGIN_PP(); }
<INITIAL>{pp_strt}"ifndef" { BEGIN_PP(); }
<INITIAL>{pp_strt}"else"   { BEGIN_PP(); }
<INITIAL>{pp_strt}"elif"   { BEGIN_PP(); }
<INITIAL>{pp_strt}"endif"  { BEGIN_PP(); }
<INITIAL>{pp_strt}"error"  { BEGIN_PP(); }
<INITIAL>{pp_strt}"undef"  { BEGIN_PP(); }

<PP>"#"                { SETPOS_NDE(LB_SIGN); return(LB_SIGN); }
<PP>"##"               { SETPOS_NDE(DOUB_LB_SIGN); return(DOUB_LB_SIGN); }

<PP>\\(\n)             {  /* Preprocessor continuation line */
                         Parse_TOS->yylineno++;
                         Parse_TOS->yynxtcol = 0;
                       }

<PP>\n                 {  /* End of this preprocessor logical line */
                         lvalp->node = (treenode *) NULL;
                         in_preprocess = 0;
                         yyless(0);    /* Hack! */
                         BEGIN(INITIAL);
                       }

<PP>[^\n\\]+           { /* Swallow cpp junk to prevent it being echo'd */
                       }

<INITIAL>{alpha}{alphanum}*  {    /* Identifier */
                         int last_was_type = (err_type == TN_TYPE)
                                          && (err_tok != TYPEDEF)
                                          && (err_tok != AUTO)
                                          && (err_tok != EXTRN)
                                          && (err_tok != STATIC)
                                          && (err_tok != VOLATILE)
                                          && (err_tok != CONST)
                                          && (err_tok != REGISTR);

                         SETPOS_LEAF(IDENT,TN_IDENT);

                         lvalp->leaf->data.sval = nmelook(yytext,yyleng+1);

                         /* Check symbol table and insert */
                         /* ptr back to definition.       */
                         {	symentry_t *se;

				if (DBG)	printf("%s:%d lookup %s <%s>\n",
						lvalp->leaf->hdr.fnm,
						lvalp->leaf->hdr.line,
						yytext, lvalp->leaf->data.sval->str);

				se = symtab_lookup(ParseStack->contxt->syms,
                                              lvalp->leaf->data.sval);
				if (DBG)
				{ if (!se) printf("	new\n");
				  else
				  {	extern void show_hashtab(hashtab_t *that, int, FILE *fp);
					printf("	old (%u) -- owner %s %u\n", se,
					se->nes && se->nes->owner ? se->nes->owner : "no owner",
					se && se->nes? se->nes : 0);
					if (se && se->nes && se->nes->htab)
					show_hashtab(se->nes->htab, 1, stdout);
				  }
				}

				lvalp->leaf->syment = se;

				if (! last_was_type)
				{	if (se && is_typedef(se))
					{	err_type = lvalp->leaf->hdr.type = TN_TYPE;
						err_tok = lvalp->leaf->hdr.tok = TYPEDEF_NAME;
						return(TYPEDEF_NAME);
					}
				}
                         }
                         return(IDENT);
                       }

<INITIAL>{octnum}  |
<INITIAL>{intnum}  |
<INITIAL>{hexnum}   {  /* An integer */
                         SETPOS_LEAF(INUM,TN_INT);
                         lvalp->leaf->data.ival 
                                = strtol(yytext,(char **) NULL,0);
                         return(INUM);
                    }
          
<INITIAL>{digits}{dot}{digits}{exponent}?{floatsuffix}? |
<INITIAL>{digits}{dot}{exponent}?{floatsuffix}?         |
<INITIAL>{dot}{digits}{exponent}?{floatsuffix}?         |
<INITIAL>{digits}{exponent}{floatsuffix}? {
                         /*
                         ** Note: The floatsuffix, if any, will be
                         ** ignored by atof().
                         */
                         SETPOS_LEAF(RNUM,TN_REAL);
                         lvalp->leaf->data.dval = atof(yytext);
                         return(RNUM);
                       }

<STR>\"{allwhite}*\"   {   /* String Pasting */
                         cnt_nl(yytext,yyleng);
                       }

<STR>\"                {   /* Closing quote */
                         LAST_STATE();
                         *tokn_ptr = '\0';
                         lvalp->leaf->data.str = emalloc(strlen(tokn_buff)+1);
                         strcpy(lvalp->leaf->data.str,tokn_buff);
                         return(STRING);
                       }

<STR>\n                { /* Error - unterminated string constant */
                         yyerr("Unterminated string constant starting");
                         LAST_STATE();
                         return(INVALID);
                       }

<STR>\\[0-7]{1,3}      {   /* octal escape sequence */
                         uint result;

                         if (sscanf(yytext+1, "%o", &result ) < 1)
                         {
                             yyerr("Invalid octal escape sequence");
                             LAST_STATE();
                             return(INVALID);
                         }

                             /* error, constant is out-of-bounds */
                         if ( result > 0xff ){
                            yyerr("Escape sequence out-of-bounds");
                         }

                         if (tokn_ptr < tokn_end)
                            *tokn_ptr++ = result;
                         else
                            yywarn("String constant too long");
                       }

<STR>\\x{hexdigit}+    {   /* hex escape sequence - ISO C */
                         uint result;

                         if (sscanf(yytext+2, "%x", &result ) < 1)
                         {
                             yyerr("Invalid hex escape sequence");
                             LAST_STATE();
                             return(INVALID);
                         }

                             /* error, constant is out-of-bounds */
                         if ( result > 0xff ){
                            yyerr("Escape sequence out-of-bounds");
                         } else if (yyleng > 4){
                            yywarn("Hexadecimal escape exceeds two chars");
                         }

                         if (tokn_ptr < tokn_end)
                            *tokn_ptr++ = result;
                         else
                            yywarn("String constant too long");
                       }

<STR>\\{digits}        {  /* Bad escape sequence */
                         yywarn("Bad escape sequence in string");
                        *tokn_ptr++ = '?';
                       }

<STR>\\n               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = '\n';
                         else
                            yywarn("String constant too long");
                       }

<STR>\\t               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = '\t';
                         else
                            yywarn("String constant too long");
                       }

<STR>\\r               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = '\r';
                         else
                            yywarn("String constant too long");
                       }

<STR>\\b               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = '\b';
                         else
                            yywarn("String constant too long");
                       }

<STR>\\f               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = '\f';
                         else
                            yywarn("String constant too long");
                       }

<STR>\\v               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = '\v';
                         else
                            yywarn("String constant too long");
                       }

<STR>\\a               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = '\a';
                         else
                            yywarn("String constant too long");
                       }

<STR>\\(\n)            {  /* String continuation */
                         Parse_TOS->yylineno++;
                         Parse_TOS->yynxtcol = 0;
                       }

<STR>\\.               {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = yytext[1];
                         else
                            yywarn("String constant too long");
                       }

<STR>[^\\\n\"]+        {
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("String constant too long");
                       }

<CMMT>[^*\n/\\]*       {   /* Inside C-style comment */
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("Comment too long");
                       }

<CMMT>[^*\n/\\]*\n     {
                         int n = yyleng;
                         Parse_TOS->yylineno++;
                         Parse_TOS->yynxtcol = 0;
                         in_preprocess = 0;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("Comment too long");
                       }
<CMMT>"/"[^*\n]        {
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("Comment too long");
                       }
<CMMT>\\\n             {
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("Comment too long");
                         Parse_TOS->yylineno++;
                         Parse_TOS->yynxtcol = 0;
                       }
<CMMT>\\[^\n]          {
                         if (tokn_ptr < tokn_end)
                           *tokn_ptr++ = yytext[1];
                         else
                            yywarn("Comment too long");
                         yyless(1);
                       }
<CMMT>"/"\n            {
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("Comment too long");
                         Parse_TOS->yylineno++;
                         Parse_TOS->yynxtcol = 0;
                         in_preprocess = 0;
                       }
<CMMT>"/*"             {
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("Comment too long");
                         yywarn("/* inside comment");
                       }
<CMMT>"*"+[^*/\n\\]*   {   /* Stars */
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);
                             tokn_ptr += n;
                         } else 
                            yywarn("Comment too long");
                       }
<CMMT>"*"+[^*/\n\\]*\n {
                         int n = yyleng;
                         if (tokn_ptr + n < tokn_end) {
                             memcpy(tokn_ptr,yytext,n);