Untitled

/*
 *  The scanner definition for COOL.
 */

/*
 *  Stuff enclosed in %{ %} in the first section is copied verbatim to the
 *  output, so headers and global definitions are placed here to be visible
 * to the code in the file.  Don't remove anything that was here initially
 */

%{
#include <cool-parse.h>
#include <stringtab.h>
#include <utilities.h>

/* The compiler assumes these identifiers. */
#define yylval cool_yylval
#define yylex  cool_yylex

/* Max size of string constants */
#define MAX_STR_CONST 1025
#define YY_NO_UNPUT   /* keep g++ happy */
/*
   The two statements below are here just so this program will compile.
   You may need to change or remove them on your final code.
*/
#define yywrap() 1
#define YY_SKIP_YYWRAP

extern FILE *fin; /* we read from this file */

/* define YY_INPUT so we read from the FILE fin:
 * This change makes it possible to use this scanner in
 * the Cool compiler.
 */
#undef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( (result = fread( (char*)buf, sizeof(char), max_size, fin)) < 0) \
		YY_FATAL_ERROR( "read() in flex scanner failed");

char string_buf[MAX_STR_CONST]; /* to assemble string constants */
char *string_buf_ptr;

extern int curr_lineno;
extern int verbose_flag;

extern YYSTYPE cool_yylval;

int nested_comments = 0;
std::string readString = "";
int readNullToken = 0;

%}

SINGLE_TOKENS [{|}|(|)|:|;|@|,|.|+|\-|*|/|=|<|~]
QUOTES \"

/* 
 *  The multiple-character operators. 
 */
DARROW     =>
ASSIGN     <-
LE         <=   

DIGIT      [0-9]
OBJID      [a-z][a-zA-Z0-9_]*
TYPEID     [A-Z][a-zA-Z0-9_]*

%x STR   
%x COMMENT
%x TREAT_STR_ERROR
%x DASH_COMMENT
%x MULTILINE_COMMENT
%x SINGLELINE_COMMENT

%%

[ \t\r\f\v]+ {/*skip whitespace*/}
\n          { curr_lineno++; }
{DIGIT}+ {
  cool_yylval.symbol = idtable.add_string(yytext);
  return (INT_CONST);
}
{SINGLE_TOKENS} { return int(yytext[0]); }

"t"[rR][uU][eE] {
  cool_yylval.boolean = 1;
  return (BOOL_CONST);
}
"f"[aA][lL][sS][eE] {
  cool_yylval.boolean = 0;
  return (BOOL_CONST);
}
[cC][lL][aA][sS][sS]	            { return (CLASS); }
[eE][lL][sS][eE] 			            { return (ELSE); }
[fF][iI]                          { return (FI); }
[iI][fF]                          { return (IF); }
[Ii][Nn]                          { return (IN); }
[iI][nN][hH][eE][rR][iI][tT][sS]  { return (INHERITS); } 
[iI][sS][vV][oO][iI][dD]	        { return (ISVOID); } 
[lL][eE][tT]                      { return (LET); }
[lL][oO][oO][pP]	                { return (LOOP); }
[pP][oO][oO][lL]	                { return (POOL); }
[tT][hH][eE][nN]	                { return (THEN); }
[wW][hH][iI][lL][eE]	            { return (WHILE); }
[cC][aA][sS][eE]	                { return (CASE); }
[eE][sS][aA][cC]	                { return (ESAC); }
[nN][eE][wW]	                    { return (NEW); }
[oO][fF]	                        { return (OF); }
[nN][oO][tT]	                    { return (NOT); }

{TYPEID} {
  cool_yylval.symbol = idtable.add_string(yytext);
  return (TYPEID);
}

{OBJID} {
  cool_yylval.symbol = idtable.add_string(yytext);
  return (OBJECTID);
}

"--" { BEGIN(SINGLELINE_COMMENT); }
"(*" { BEGIN(MULTILINE_COMMENT); }

<MULTILINE_COMMENT>{
  [^\n(*]* { }
  [()*] { }
  "*)" {
    nested_comments--;
    if (nested_comments == 0){
      BEGIN(INITIAL);
    }
  }
  <<EOF>> {
    yylval.error_msg = (char*)"EOF in comment";
    BEGIN(INITIAL);
    return (ERROR);
  }
}

<SINGLELINE_COMMENT>{
  [^\n]* { }
  \n {
    curr_lineno += 1;
    BEGIN(INITIAL);
  }
}

<INITIAL>\" { readString = ""; readNullToken = 0; BEGIN(STR); }
<STR>{
  [^\n\0"\\]* {
    readString += yytext;
  }
  \\(.|\n) {
    switch(yytext[1]) {
      case '\n':
        curr_lineno += 1;
        readString += '\n';
        break; 
      case 'n':
        readString += '\n';
        break; 
      case 't':
        readString += '\t';
        break; 
      case 'f':
        readString += '\f';
        break; 
      case 'b':
        readString += '\b';
        break; 
      case '\0': 
        readNullToken = 1;
        break;
      default:
        readString += yytext[1];
        break;
    }
  }
  \n {
    BEGIN(INITIAL);
    curr_lineno += 1;
    yylval.error_msg = (char*)"Unterminated string constant";
    return (ERROR);
  }
  \0 {
    readNullToken = 1;
  }
  \" {
    BEGIN(INITIAL);
    if(readNullToken == 1) {
      yylval.error_msg = (char*)"String contains null character";
      return (ERROR);
    }
    if(readString.length() >= MAX_STR_CONST) {
      yylval.error_msg = (char*)"String constant too long";
      return (ERROR);
    }
    cool_yylval.symbol = stringtable.add_string((char *) readString.c_str());
    return (STR_CONST);
  }
  <<EOF>> {
    BEGIN(INITIAL);
    yylval.error_msg = (char*)"EOF in string constant";
    return (ERROR);
  }
}

. {
  yylval.error_msg = (char*)yytext;
  return (ERROR);
}

%%