main.c

C++版 词法分析、语法分析器

		    for ( ++i; arg[i] != '\0'; ++i )
			switch ( arg[i] )
			    {
			    case 'e':
				useecs = true;
				break;

			    case 'F':
				fullspd = true;
				break;

			    case 'f':
				fulltbl = true;
				break;

			    case 'm':
				usemecs = true;
				break;

			    default:
				fprintf(stderr, "unknown -C option '%c'",
					(int) arg[i] );
				flexinfo(1);
				break;
			    }

		    goto get_next_arg;

		case 'd':
		    ddebug = true;
		    break;

		case 'f':
		    useecs = usemecs = false;
		    fulltbl = true;
		    break;

		case 'F':
		    useecs = usemecs = false;
		    fullspd = true;
		    break;
		case 'g':
		    if ( i != 1 )
			flexerror( "-g flag must be given separately" );

		    includefilename = arg + i + 1;
			if(*includefilename=='\0')
				flexerror("no space is allowed between -g and a file name");
		    goto get_next_arg;
		case 'h':
		    if ( i != 1 )
			flexerror( "-h flag must be given separately" );

		    headerfilename = arg + i + 1;
			if(*headerfilename=='\0')
				flexerror("no space is allowed between -h and a file name");
		    goto get_next_arg;
		case 'o':
		    if ( i != 1 )
			flexerror( "-o flag must be given separately" );

		    outputfilename = arg + i + 1;
			if(*outputfilename=='\0')
				flexerror("no space is allowed between -o and a file name");
		    goto get_next_arg;

		case 'H':
		    if ( i != 1 )
			flexerror( "-H flag must be given separately" );

		    skelheaderfilename = arg + i + 1;
			if(*skelheaderfilename=='\0')
				flexerror("no space is allowed between -H and a file name");
		    goto get_next_arg;


		case 'I':
		    interactive = true;
		    break;

		case 'i':
		    caseins = true;
		    break;

		case 'L':
		    gen_line_dirs = false;
		    break;

		case 'n':
		    /* stupid do-nothing deprecated option */
		    break;

		case 'p':
		    performance_report = true;
		    break;

		case 'S':
		    if ( i != 1 )
			flexerror( "-S flag must be given separately" );

		    skelname = arg + i + 1;
		    goto get_next_arg;

		case 's':
		    spprdflt = true;
		    break;

		case 't':
		    use_stdout = true;
		    break;

		case 'T':
		    trace = true;
		    break;

		case 'v':
		    printstats = true;
		    break;

		case '8':
		    csize = CSIZE;
		    break;

		case '?':
		    flexinfo(0);
		    break;

		default:
		    fprintf(stderr, "unknown flag '%c'", (int) arg[i] );
		    flexinfo(1);
		    break;
		}

get_next_arg: /* used by -C and -S flags in lieu of a "continue 2" control */
	;
	}

    if ( (fulltbl || fullspd) && usemecs )
	flexerror( "full table and -Cm don't make sense together" );

    if ( (fulltbl || fullspd) && interactive )
	flexerror( "full table and -I are (currently) incompatible" );

    if ( fulltbl && fullspd )
	flexerror( "full table and -F are mutually exclusive" );
    if( use_stdout && outputfilename )
	flexerror( "-t (generate to stdout) and -o (generate to file) are mutually exclusive" );
    if ( ! skelname )
	{
#ifdef	WIN32
		skelname = computeFileName( DEFAULT_SKELETON_FILE );
#else
		skelname = DEFAULT_SKELETON_FILE;
#endif
	}

    if ( ! skelheaderfilename )
	{
#ifdef	WIN32
		skelheaderfilename = computeFileName( DEFAULT_SKELETONHEADER_FILE );
#else
		skelheaderfilename=DEFAULT_SKELETONHEADER_FILE;
#endif
	}
    if ( ! use_stdout )
	{FILE *prev_stdout;
	if(outputfilename && outputfilename[0] ) outfile=outputfilename;
	prev_stdout = freopen( outfile, "w", stdout );

	if ( prev_stdout == NULL )
	    lerrsf( "could not create %s", outfile );

	outfile_created = 1;
	}

    num_input_files = argc;
    input_files = argv;
    set_input_file( num_input_files > 0 ? input_files[0] : NULL );
    if ( (skelheaderfile = fopen( skelheaderfilename, "r" )) == NULL )
#ifdef _MSDOS
     if(getenv("INIT")!=NULL)
     {char *t;
      t=malloc(strlen(getenv("INIT"))+strlen(skelheaderfilename)+2);
      strcpy(t,getenv("INIT"));
      strcat(t,"/");
      strcat(t,skelheaderfilename);
      skelheaderfilename=t;
      if((skelheaderfile = fopen( skelheaderfilename, "r" )) == NULL)
	lerrsf( "can't open skeleton header file %s", skelheaderfilename );
     }
     else
#endif
	lerrsf( "can't open skeleton header file %s", skelheaderfilename );
    if(headerfilename==NULL) headerfile=stdout;
    else  
     {
      if(headerfilename[0]=='\0')
       {char **suffix;
	headerfilename=malloc(strlen(outfile)+3);
	strcpy(headerfilename,outfile);
	for(suffix=c_suffixes;*suffix;suffix++)
	/* try to detect .c .cpp options */
	  {if(strlen(headerfilename)>strlen(*suffix)
	      && strcmp(headerfilename+
		   strlen(headerfilename)-strlen(*suffix),*suffix)==0
	      )
	    { *(headerfilename+strlen(headerfilename)-strlen(*suffix))='\0';
	     break;}
	  };
	strcat(headerfilename,".h");     
	}
      if(includefilename==NULL)
	 includefilename=headerfilename;
      if ( (headerfile = fopen( headerfilename, "w" )) == NULL )
	lerrsf( "can't open header file %s", headerfilename );
      };
    if ( backtrack_report )
	{
#ifndef SHORT_FILE_NAMES
	backtrack_file = fopen( "lex.backtrack", "w" );
#else
	backtrack_file = fopen( "lex.bck", "w" );
#endif
	if ( backtrack_file == NULL )
	    flexerror( "could not create lex.backtrack" );
	}

    else
	backtrack_file = NULL;


    lastccl = 0;
    lastsc = 0;

    /* initialize the statistics */

    if ( (skelfile = fopen( skelname, "r" )) == NULL )
#ifdef _MSDOS
       if(getenv("INIT")!=NULL)
     {char *t;
      t=malloc(strlen(getenv("INIT"))+strlen(skelname)+2);
      strcpy(t,getenv("INIT"));
      strcat(t,"/");
      strcat(t,skelname);
      skelname=t;
      if((skelfile = fopen(skelname , "r" )) == NULL)
	lerrsf( "can't open skeleton file %s", skelname );
     }
     else
#endif
	lerrsf( "can't open skeleton file %s", skelname );
    if(tmp_action)
     {char *ftmp;
      ftmp=malloc(strlen(tmp_action)+1+32);
      strcpy(ftmp,tmp_action);
#ifndef SHORT_FILE_NAMES
	(void) strcat( ftmp, "/flexXXXXXX" );
#else
	(void) strcpy( ftmp, "/flXXXXXX.tmp" );
#endif
      action_file_name=ftmp;
      (void) mktemp( action_file_name );
     }
    else
     {
#ifdef _MSDOS
      action_file_name=_tempnam(".","flex");
#else
#ifdef SYS_V
    action_file_name = tmpnam( NULL );
#endif
#endif
     }
    if ( action_file_name == NULL )
	{
	static char temp_action_file_name[32];

#if !defined(SHORT_FILE_NAMES) && !defined(WIN32)
	(void) strcpy( temp_action_file_name, "/tmp/flexXXXXXX" );
#else
	(void) strcpy( temp_action_file_name, "flXXXXXX.tmp" );
#endif
	(void) mktemp( temp_action_file_name );
	action_file_name = temp_action_file_name;
	}

    if ( (temp_action_file = fopen( action_file_name, "w" )) == NULL )
	lerrsf( "can't open temporary action file %s", action_file_name );

    lastdfa = lastnfa = num_rules = numas = numsnpairs = tmpuses = 0;
    numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 0;
    numuniq = numdup = hshsave = eofseen = datapos = dataline = 0;
    num_backtracking = onesp = numprots = 0;
    variable_trailing_context_rules = bol_needed = false;

    linenum = sectnum = 1;
    firstprot = NIL;

    /* used in mkprot() so that the first proto goes in slot 1
     * of the proto queue
     */
    lastprot = 1;

    if ( useecs )
	{ /* set up doubly-linked equivalence classes */
	/* We loop all the way up to csize, since ecgroup[csize] is the
	 * position used for NUL characters
	 */
	ecgroup[1] = NIL;

	for ( i = 2; i <= csize; ++i )
	    {
	    ecgroup[i] = i - 1;
	    nextecm[i - 1] = i;
	    }

	nextecm[csize] = NIL;
	}

    else
	{ /* put everything in its own equivalence class */
	for ( i = 1; i <= csize; ++i )
	    {
	    ecgroup[i] = i;
	    nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */
	    }
	}

    set_up_initial_allocations();
    }

 int flexinfo(status)
 int status;
 {
    fprintf(stderr,"Syntax  :  flex  [options...] inp_file\n");
    fprintf(stderr,"Function: fast lexical analyzer generator C/C++  V%s\n",flex_version);
    fprintf(stderr,"Options : \n");
    fprintf(stderr,"	-a dir_path  : directory path for temporary files\n");
    fprintf(stderr,"	-b  : generate backtracking information to lex.backtrack\n");
    fprintf(stderr,"	-c  : compressed table, no equiv., no meta equiv.classes\n");
    fprintf(stderr,"	-C  : compressed table, no equiv., no meta equiv.classes\n");
    fprintf(stderr,"	-Ce : compressed table, with equivalence classes\n");
    fprintf(stderr,"	-Cem: compressed table, with equivalence and meta equiv. classes\n");
    fprintf(stderr,"	-Cm: compressed table, with meta equivalence classes\n");
    fprintf(stderr,"	-Cm: compressed table, with meta equivalence classes\n");
    fprintf(stderr,"	-CF :  alternate fast table\n");
    fprintf(stderr,"	-Cf :  full table\n");
    fprintf(stderr,"	-CFe : alternate fast table, with equivalence classes\n");
    fprintf(stderr,"	-Cfe : full table, with equivalence classes\n");
    fprintf(stderr,"	-F  : fast table\n");
    fprintf(stderr,"	-f  : full (not compressed) table\n");
    fprintf(stderr,"	-d  : generate debugging scanner\n");
    fprintf(stderr,"	-I  : generate interactive scanner\n");
    fprintf(stderr,"	-i  : generate case-insensitive scanner\n");
    fprintf(stderr,"	-L  : supress #line directives\n");
 /*   fprintf(stderr,"	-n hexnum : generate scanner using <hexnum> as newline char.\n");*/
    fprintf(stderr,"	-p  : generate performance report to stderr\n");
    fprintf(stderr,"	-S skeleton_path : file path for skeleton file\n");
    fprintf(stderr,"	-H header_skeleton_path : file path for header skeleton file\n");
    fprintf(stderr,"	-s  : suppress echo of unmatched scanner input to stdout\n");
    fprintf(stderr,"	-T  : run flex in trace mode\n");
    fprintf(stderr,"	-t  : place result on stdout \n");
    fprintf(stderr,"	-v  : print statistics of generated scanner\n");
    fprintf(stderr,"	-o code_file  : set name of output code file\n");
    fprintf(stderr,"	-h [header_file]  : generate a separate header_file\n");
    fprintf(stderr,"	-g include_file  : name of header to include (default= same as -h)\n");
    fprintf(stderr,"	-?   : this help\n");
    fprintf(stderr,"	default =  -Cem\n");
    exit(status);
    return 0;
 }



/* readin - read in the rules section of the input file(s)
 *
 * synopsis
 *    readin();
 */

void readin()

    {    
    char *ch_type;

    if(headerfilename!=NULL)
     {char symb[32],ch;
      char *p=headerfilename;
      int i=0;symb[0]='\0';
      while(*p) 
       {
	if(*p=='/'
#ifdef MS_DOS
	   || *p=='\\' || *p==':'
#endif
	   ) {symb[0]='\0';i=0;}
	else {
	 if((*p>='A' && *p<='Z')||((*p>='a' && *p<='z'))
             ||((*p>='0' && *p<='9'))||(ch=='_')) 
          ch=*p;
	 else 
          ch='_';
	 if(i<sizeof(symb)-1)
	  {symb[i++]=ch;symb[i]='\0';}
	 }
	p++; 
       };
      fprintf(headerfile,"#ifndef FLEX_HEADER_%s\n",symb );
      fprintf(headerfile,"#define FLEX_HEADER_%s\n",symb );
     }
     if ( csize == 256 ) 
      ch_type="unsigned char";
     else 
      ch_type="char";
    if ( ddebug )
      fprintf(stdout, "#define FLEX_DEBUG\n" );
    fprintf(stdout, "#define YY_CHAR %s\n",ch_type );
    skelout();
    line_directive_out( stdout );

    if ( yyparse() )
	{
	pinpoint_message( "fatal parse error" );
	flexend( 1 );
	}

    if ( xlation )
	{
	numecs = ecs_from_xlation( ecgroup );
	useecs = true;
	}

    else if ( useecs )
	numecs = cre8ecs( nextecm, ecgroup, csize );

    else
	numecs = csize;

    /* now map the equivalence class for NUL to its expected place */
    ecgroup[0] = ecgroup[csize];
    NUL_ec = abs( ecgroup[0] );

    if ( useecs )
	ccl2ecl();
    line_directive_out( headerfile );
    if(headerfilename!=NULL) fprintf(headerfile,"#endif\n" );
    header_skeleton_out();

    }



/* set_up_initial_allocations - allocate memory for internal tables */

void set_up_initial_allocations()

    {
    current_mns = INITIAL_MNS;
    firstst = allocate_integer_array( current_mns );
    lastst = allocate_integer_array( current_mns );
    finalst = allocate_integer_array( current_mns );
    transchar = allocate_integer_array( current_mns );
    trans1 = allocate_integer_array( current_mns );
    trans2 = allocate_integer_array( current_mns );
    accptnum = allocate_integer_array( current_mns );
    assoc_rule = allocate_integer_array( current_mns );
    state_type = allocate_integer_array( current_mns );

    current_max_rules = INITIAL_MAX_RULES;
    rule_type = allocate_integer_array( current_max_rules );
    rule_linenum = allocate_integer_array( current_max_rules );

    current_max_scs = INITIAL_MAX_SCS;
    scset = allocate_integer_array( current_max_scs );
    scbol = allocate_integer_array( current_max_scs );
    scxclu = allocate_integer_array( current_max_scs );
    sceof = allocate_integer_array( current_max_scs );
    scname = allocate_char_ptr_array( current_max_scs );
    actvsc = allocate_integer_array( current_max_scs );

    current_maxccls = INITIAL_MAX_CCLS;
    cclmap = allocate_integer_array( current_maxccls );
    ccllen = allocate_integer_array( current_maxccls );
    cclng = allocate_integer_array( current_maxccls );

    current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE;
    ccltbl = allocate_character_array( current_max_ccl_tbl_size );

    current_max_dfa_size = INITIAL_MAX_DFA_SIZE;

    current_max_xpairs = INITIAL_MAX_XPAIRS;
    nxt = allocate_integer_array( current_max_xpairs );
    chk = allocate_integer_array( current_max_xpairs );

    current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS;
    tnxt = allocate_integer_array( current_max_template_xpairs );

    current_max_dfas = INITIAL_MAX_DFAS;
    base = allocate_integer_array( current_max_dfas );
    def = allocate_integer_array( current_max_dfas );
    dfasiz = allocate_integer_array( current_max_dfas );
    accsiz = allocate_integer_array( current_max_dfas );
    dhash = allocate_integer_array( current_max_dfas );
    dss = allocate_int_ptr_array( current_max_dfas );
    dfaacc = allocate_dfaacc_union( current_max_dfas );

    nultrans = (int *) 0;
    }