lexer.l

C程序漏洞检查！

%{
/***** uno: lexer.l *****/

/* Copyright (c) 2000-2003 by Lucent Technologies - Bell Laboratories     */
/* All Rights Reserved.  This software is for educational purposes only.  */
/* Permission is given to distribute this code provided that this intro-  */
/* ductory message is not removed and no monies are exchanged.            */
/* No guarantee is expressed or implied by the distribution of this code. */
/* Software written by Gerard J. Holzmann based on the public domain      */
/* ANSI-C parser Ctree Version 0.14 from Shaun Flisakowski                */
/* small tweask by Russ Cox to allow wide characters and string consts    */

/*************************************************
 *	Shaun Flisakowski
 *	revised 1996 Kurt Cockrum <[e-mail]>
 *	revised 2000 Gerard Holzmann <gholzmann [atsignhere] acm.org>
 *	revised 2003 Russ Cox     <[e-mail]<
 *************************************************/

#define DBG	0	/* debugging */
#define ECHO	/* flex on PC inserts an unwanted ECHO */

#undef yywrap
int yywrap(void);

#define  YY_BUFFER_STATE_DEFD

#include <stdlib.h>
#include "globals.h"
#include "gram.h"
#include "lexer.h"
#include "token.h"
#include "nmetab.h"
#include "symtab.h"
#include "heap.h"

FILE *yyin;
char line_buf[MAX_TOKN_LEN];

int  err_cnt = 0;
int  err_tok = 0;
int  err_type = 0;
int  in_preprocess = 0;
int  gcc2_paren_cnt = 0;

char  tokn_buff[MAX_TOKN_LEN];
char *tokn_end = &tokn_buff[MAX_TOKN_LEN-1];
char *tokn_ptr;

int cnt_nl(char *, int);
void *emalloc(uint);

#undef YY_INPUT

#ifdef STRING_PARSE

#define    min(X,Y)    ((X)<(Y) ? (X) : (Y))

    /* Scan input from a string instead */
#define YY_INPUT(buf,result,max_size) \
  {  int n = min(max_size, Parse_TOS->parselimit - Parse_TOS->parseptr);\
     if (n>0){ \
        memcpy(buf,Parse_TOS->parseptr,(unsigned int) n); \
        Parse_TOS->parseptr += n; \
        result = n; \
     } else \
        result = YY_NULL; \
  }

#else    /* not STRING_PARSE */

    /* Scan input from a file pointer (default) */
#define YY_INPUT(buf,result,max_size) \
    {   if (fgets((char*) (buf),max_size,yyin) == NULL) { \
           result = YY_NULL; \
        } else { \
           result = strlen((char*)(buf)); \
           strncpy(line_buf, (char*)(buf), result+1 /* MAX_TOKN_LEN */); \
        } \
    }

#endif    /* not STRING_PARSE */

#define YY_USER_ACTION \
    {   Parse_TOS->yycolno = Parse_TOS->yynxtcol; \
        Parse_TOS->yynxtcol += yyleng; \
    }

#undef SETPOS_NDE
#define SETPOS_NDE(TYPE) \
	{ err_type = 0; \
          lvalp->node = make_node(TN_EMPTY); \
          lvalp->node->hdr.line = Parse_TOS->yylineno; \
          lvalp->node->hdr.col  = Parse_TOS->yycolno; \
	  lvalp->node->hdr.fnm = Parse_TOS->filename; \
          err_tok = lvalp->node->hdr.tok = (int) (TYPE); \
	}

#undef SETPOS_LEAF
#define SETPOS_LEAF(TOK_TYPE,PRSE_TYPE) \
	{ lvalp->leaf = make_leaf((err_type= (int) PRSE_TYPE)); \
          lvalp->leaf->hdr.line = Parse_TOS->yylineno; \
          lvalp->leaf->hdr.col  = Parse_TOS->yycolno; \
	  lvalp->leaf->hdr.fnm = Parse_TOS->filename; \
          err_tok = lvalp->leaf->hdr.tok  = (int) (TOK_TYPE); \
	}

#undef SETPOS_IF
#define SETPOS_IF(TYPE) \
	{ err_type = 0; \
          lvalp->ifn = make_if(err_type= (int) TN_IF); \
          lvalp->ifn->hdr.line = Parse_TOS->yylineno; \
          lvalp->ifn->hdr.col  = Parse_TOS->yycolno; \
	  lvalp->ifn->hdr.fnm = Parse_TOS->filename; \
          err_tok = lvalp->ifn->hdr.tok  = (int) (TYPE); \
	}

#undef SETPOS_FOR
#define SETPOS_FOR(TYPE) \
	{ err_type = 0; \
          lvalp->forn = make_for(err_type= (int) TN_FOR); \
          lvalp->forn->hdr.line = Parse_TOS->yylineno; \
          lvalp->forn->hdr.col  = Parse_TOS->yycolno; \
	  lvalp->forn->hdr.fnm = Parse_TOS->filename; \
          err_tok = lvalp->forn->hdr.tok  = (int) (TYPE); \
	}

#undef  LAST_STATE
#define LAST_STATE() \
        { if (in_preprocess) \
            BEGIN(PP); \
          else \
            BEGIN(INITIAL); \
        }

#undef  BEGIN_PP
#define BEGIN_PP() \
        { BEGIN(PP); \
          in_preprocess = 1; \
        }

/* YYSTYPE my_var;	not used, gjh */

EXTERN int yylex ARGS((YYSTYPE *lvalp));

/*  To give some args to yylex */
#undef YY_DECL
#ifdef  __STDC__
/*  #define YY_DECL int yylex YY_PROTO((YYSTYPE *lvalp))  */
#define YY_DECL int yylex (YYSTYPE *lvalp)
#else
#define YY_DECL int yylex(lvalp) YYSTYPE *lvalp;
#endif
%}

%x Start PP CMMT CC STR GCC2
%a 9000
%o 9000

dot		"."
digit		[0-9]
octdigit	[0-7]
hexdigit	[0-9a-fA-F]
digits          {digit}+
alpha		[a-zA-Z_]
alphanum	{alpha}|{digit}

usuffix         [uU]
lsuffix         [lL]
intsuffix       {usuffix}{lsuffix}*|{lsuffix}{usuffix}?
intnum		{digit}+{intsuffix}?
octnum		0{octdigit}+{intsuffix}?
hexnum		0[xX]{hexdigit}+{intsuffix}*

exponent	[Ee][+-]?{digits}
floatsuffix     [fFlL]

whitespace      [ \t\f\v]
allwhite        [ \t\f\b\v\r\n]

pp_strt         ^{whitespace}*"#"{whitespace}*

%%
<INITIAL>"/*"       { BEGIN(CMMT);
                      tokn_ptr = tokn_buff;
                     *tokn_ptr++ = '/';
                     *tokn_ptr++ = '*';
                      SETPOS_LEAF(COMMENT,TN_COMMENT);
                    }
<INITIAL>L?"'"        { BEGIN(CC);    SETPOS_LEAF(CHAR_CONST,TN_INT); }
<INITIAL>L?\"         { BEGIN(STR);   tokn_ptr = tokn_buff;
                         SETPOS_LEAF(STRING,TN_STRING);
                    }

<INITIAL>"//*"      { /* Ambiguous C++ style comment, must parse as
                            '/' '/*' to be Ansi compliant */
                         yywarn(
                            "Ambiguous C++ comment, use '/ /*' -or- '// *'");
                         yyless(1);
                         SETPOS_NDE(DIV);
                         return(DIV);
                    }
<INITIAL>"//"[^*].*$ { /* C++ style comment */ }

<INITIAL>"auto"     { SETPOS_LEAF(AUTO,TN_TYPE); return(AUTO); }
<INITIAL>"break"    { SETPOS_NDE(BREAK); return(BREAK); }
<INITIAL>"case"     { SETPOS_NDE(CASE); return(CASE); }
<INITIAL>"char"     { SETPOS_LEAF(CHAR,TN_TYPE); return(CHAR); }
<INITIAL>"const"    { SETPOS_LEAF(CONST,TN_TYPE); return(CONST); }
<INITIAL>"continue" { SETPOS_NDE(CONT); return(CONT); }
<INITIAL>"default"  { SETPOS_LEAF(DEFLT,TN_LABEL); return(DEFLT); }
<INITIAL>"do"       { SETPOS_NDE(DO); return(DO); }
<INITIAL>"double"   { SETPOS_LEAF(DOUBLE,TN_TYPE); return(DOUBLE); }
<INITIAL>"else"     { SETPOS_NDE(ELSE); return(ELSE); }
<INITIAL>"enum"     { SETPOS_NDE(ENUM); return(ENUM); }
<INITIAL>"extern"   { SETPOS_LEAF(EXTRN,TN_TYPE); return(EXTRN); }
<INITIAL>"float"    { SETPOS_LEAF(FLOAT,TN_TYPE); return(FLOAT); }
<INITIAL>"for"      { SETPOS_FOR(FOR); return(FOR); }
<INITIAL>"goto"     { SETPOS_NDE(GOTO); return(GOTO); }
<INITIAL>"if"       { SETPOS_IF(IF); return(IF); }
<INITIAL>"__int8"   { SETPOS_LEAF(CHAR,TN_TYPE); return(CHAR);	/* VC++ */ }
<INITIAL>"__int16"  { SETPOS_LEAF(SHORT,TN_TYPE); return(SHORT);/* VC++ */ }
<INITIAL>"__int32"  { SETPOS_LEAF(INT,TN_TYPE); return(INT);	/* VC++ */ }
<INITIAL>"__int64"  { SETPOS_LEAF(LONG,TN_TYPE); return(LONG);	/* VC++ */ }
<INITIAL>"int"      { SETPOS_LEAF(INT,TN_TYPE); return(INT); }
<INITIAL>"long"     { SETPOS_LEAF(LONG,TN_TYPE); return(LONG); }
<INITIAL>"register" { SETPOS_LEAF(REGISTR,TN_TYPE); return(REGISTR); }
<INITIAL>"return"   { SETPOS_NDE(RETURN); return(RETURN); }
<INITIAL>"short"    { SETPOS_LEAF(SHORT,TN_TYPE); return(SHORT); }
<INITIAL>"signed"   { SETPOS_LEAF(SGNED,TN_TYPE); return(SGNED); }
<INITIAL>"sizeof"   { SETPOS_NDE(SIZEOF); return(SIZEOF); }
<INITIAL>"static"   { SETPOS_LEAF(STATIC,TN_TYPE); return(STATIC); }
<INITIAL>"struct"   { SETPOS_NDE(STRUCT); return(STRUCT); }
<INITIAL>"switch"   { SETPOS_NDE(SWITCH); return(SWITCH); }
<INITIAL>"typedef"  { SETPOS_LEAF(TYPEDEF,TN_TYPE); return(TYPEDEF); }
<INITIAL>"union"    { SETPOS_NDE(UNION); return(UNION); }
<INITIAL>"unsigned" { SETPOS_LEAF(UNSGNED,TN_TYPE); return(UNSGNED); }
<INITIAL>"void"     { SETPOS_LEAF(VOID,TN_TYPE); return(VOID); }
<INITIAL>"volatile" { SETPOS_LEAF(VOLATILE,TN_TYPE); return(VOLATILE); }
<INITIAL>"while"    { SETPOS_NDE(WHILE); return(WHILE); }

   /* GCC2 Extensions */
<INITIAL>"__attribute"    { /* gcc2 extension - get rid of it. */
                            BEGIN(GCC2);
                          }

<INITIAL>"__attribute__"  { BEGIN(GCC2); }
<INITIAL>"__declspec"     { BEGIN(GCC2); /* MS Visual Studio */ }

<GCC2>"("[^()]*           { gcc2_paren_cnt++; }
<GCC2>[^()]*              { /* Throw away */ }
<GCC2>")"                 { if (--gcc2_paren_cnt == 0)
                              BEGIN(INITIAL);
                          }

<INITIAL>"__const"    { SETPOS_LEAF(CONST,TN_TYPE); return(CONST); }
<INITIAL>"__const__"  { SETPOS_LEAF(CONST,TN_TYPE); return(CONST); }
<INITIAL>"__signed" { SETPOS_LEAF(SGNED,TN_TYPE); return(SGNED); }
<INITIAL>"__signed__" { SETPOS_LEAF(SGNED,TN_TYPE); return(SGNED); }
<INITIAL>"__volatile" { SETPOS_LEAF(VOLATILE,TN_TYPE); return(VOLATILE); }
<INITIAL>"__volatile__" { SETPOS_LEAF(VOLATILE,TN_TYPE); return(VOLATILE); }

<INITIAL>"typeof"      { }
<INITIAL>"__typeof"    { }
<INITIAL>"__typeof__"  { }

<INITIAL>"inline"      { }
<INITIAL>"__inline"    { }
<INITIAL>"__inline__"  { }
<INITIAL>"__packed"    { }
<INITIAL>"__packed__"  { /* seen in Nexabit Code */ }
<INITIAL>"__cdecl"     { /* MS Visual Studio */ }

<INITIAL>"__extension__"  { }

<INITIAL>"alignof"      { /* gjh */ SETPOS_NDE(ALIGNOF); return(ALIGNOF); }
<INITIAL>"__alignof"    { /* gjh */ SETPOS_NDE(ALIGNOF); return(ALIGNOF); }
<INITIAL>"__alignof__"  { /* gjh */ SETPOS_NDE(ALIGNOF); return(ALIGNOF); }

<INITIAL>"__asm"      { /* gjh added: */ BEGIN(GCC2); }
<INITIAL>"__asm__"    { /* gjh added: */ BEGIN(GCC2); }

<INITIAL>"__imag"     { }
<INITIAL>"__imag__"   { }
<INITIAL>"__real"     { }
<INITIAL>"__real__"   { }
<INITIAL>"__complex"    { }
<INITIAL>"__complex__"  { }
<INITIAL>"__iterator"   { }
<INITIAL>"__iterator__" { }
<INITIAL>"__label__"    { }

<INITIAL>"+"        { SETPOS_NDE(PLUS); return(PLUS); }
<INITIAL>"-"        { SETPOS_NDE(MINUS); return(MINUS); }
<INITIAL>"*"        { SETPOS_NDE(STAR); return(STAR); }
<INITIAL>"/"        { SETPOS_NDE(DIV); return(DIV); }
<INITIAL>"%"        { SETPOS_NDE(MOD); return(MOD); }

<INITIAL>"+="       { SETPOS_NDE(PLUS_EQ); return(ASSIGN); }
<INITIAL>"-="       { SETPOS_NDE(MINUS_EQ); return(ASSIGN); }
<INITIAL>"*="       { SETPOS_NDE(STAR_EQ); return(ASSIGN); }
<INITIAL>"/="       { SETPOS_NDE(DIV_EQ); return(ASSIGN); }
<INITIAL>"%="       { SETPOS_NDE(MOD_EQ); return(ASSIGN); }

<INITIAL>"!"        { SETPOS_NDE(NOT); return(NOT); }
<INITIAL>"&&"       { SETPOS_NDE(AND); return(AND); }
<INITIAL>"||"       { SETPOS_NDE(OR); return(OR); }

<INITIAL>"~"        { SETPOS_NDE(B_NOT); return(B_NOT); }
<INITIAL>"&"        { SETPOS_NDE(B_AND); return(B_AND); }
<INITIAL>"|"        { SETPOS_NDE(B_OR); return(B_OR); }
<INITIAL>"^"        { SETPOS_NDE(B_XOR); return(B_XOR); }

<INITIAL>"~="       { SETPOS_NDE(B_NOT_EQ); return(ASSIGN); }
<INITIAL>"&="       { SETPOS_NDE(B_AND_EQ); return(ASSIGN); }
<INITIAL>"|="       { SETPOS_NDE(B_OR_EQ); return(ASSIGN); }
<INITIAL>"^="       { SETPOS_NDE(B_XOR_EQ); return(ASSIGN); }

<INITIAL>"<<"       { SETPOS_NDE(L_SHIFT); return(L_SHIFT); }
<INITIAL>">>"       { SETPOS_NDE(R_SHIFT); return(R_SHIFT); }
<INITIAL>"<<="      { SETPOS_NDE(L_SHIFT_EQ); return(ASSIGN); }
<INITIAL>">>="      { SETPOS_NDE(R_SHIFT_EQ); return(ASSIGN); }

<INITIAL>"=="       { SETPOS_NDE(EQUAL); return(COMP_EQ); }
<INITIAL>"<"        { SETPOS_NDE(LESS); return(COMP_ARITH); }
<PP>"<"             { SETPOS_NDE(LESS); return(LESS); }
<INITIAL>"<="       { SETPOS_NDE(LESS_EQ); return(COMP_ARITH); }
<INITIAL>">"        { SETPOS_NDE(GRTR); return(COMP_ARITH); }
<PP>">"             { SETPOS_NDE(GRTR); return(GRTR); }
<INITIAL>">="       { SETPOS_NDE(GRTR_EQ); return(COMP_ARITH); }
<INITIAL>"!="       { SETPOS_NDE(NOT_EQ); return(COMP_EQ); }

<INITIAL>"="        { SETPOS_NDE(EQ); return(EQ); }
<INITIAL>"++"       { SETPOS_NDE(INCR); return(INCR); }
<INITIAL>"--"       { SETPOS_NDE(DECR); return(DECR); }

<INITIAL>"("        { SETPOS_NDE(LPAREN); return(LPAREN); }
<INITIAL>")"        { SETPOS_NDE(RPAREN); return(RPAREN); }
<INITIAL>"["        { SETPOS_NDE(LBRCKT); return(LBRCKT); }
<INITIAL>"]"        { SETPOS_NDE(RBRCKT); return(RBRCKT); }
<INITIAL>"{"        { SETPOS_NDE(LBRACE); return(LBRACE); }
<INITIAL>"}"        { SETPOS_NDE(RBRACE); return(RBRACE); }

<INITIAL>"."        { SETPOS_NDE(DOT); return(DOT); }