
package java_qxt;
import java.lang.System;
import java_cup.runtime.*;

class Utility {
  public static void assert
    (
     boolean expr
     )
      { 
	if (false == expr) {
	  throw (new Error("Error: Assertion failed."));
	}
      }
  
  private static final String errorMsg[] = {
    "Error: Unmatched end-of-comment punctuation.",
    "Error: Unmatched start-of-comment punctuation.",
    "Error: Unclosed string.",
    "Error: Illegal character."
    };
  
  public static final int E_ENDCOMMENT = 0; 
  public static final int E_STARTCOMMENT = 1; 
  public static final int E_UNCLOSEDSTR = 2; 
  public static final int E_UNMATCHED = 3; 

  public static void error
    (
     int code
     )
      {
	System.out.println(errorMsg[code]);
      }
}

%%

%{
  private int comment_count = 0;
%} 
%line
%char

%class    scanner
%function get_next_token
%type     token

%public

%eofval{
return (new token(sym_num.EOF));
%eofval}

%state NOW_EQUAL

ALPHA=[A-Za-z]
LLETTER=[a-z]
ULETTER=[A-Z]
DIGIT=[0-9]
NONNEWLINE_WHITE_SPACE_CHAR=[\ \t\b]
WHITE_SPACE_CHAR=[\n\ \t\b\012]


%% 

<YYINITIAL> {NONNEWLINE_WHITE_SPACE_CHAR}+ { }

<YYINITIAL> \n       {
  if (Extern_h.error_recovering == true)                          
    {                                            
      switch (Extern_h.mq_mode)                           
        {                                        
        case macro.MODE_COMMAND:                       
        case macro.MODE_PROGRAM:                       
        case macro.MODE_PROGRAM_SUBSUMPTION:           
        case macro.MODE_PROGRAM_RULE:                  
        case macro.PS_EXPECT_TERM:                     
          return new token(sym_num.TERMINATER);                     
                                                 
        case macro.MODE_QUERY:                         
        case macro.PS_EXPECT_PRD:                      
        case macro.PS_EXPECT_Q_PRD:                    
          return new token(sym_num.DOTFOREND);                            
                                                 
        default:                                 
          MQ_Error.mq_fatal ("wrong parser staten");        
          break;                                 
        }                                        
    }                                            
  switch (Extern_h.mq_mode)                               
    {                                            
    case macro.MODE_COMMAND:                           
    case macro.MODE_PROGRAM:                           
    case macro.MODE_PROGRAM_SUBSUMPTION:               
    case macro.MODE_PROGRAM_RULE:                      
      if (Extern_h.last_char_is_newline == 0)                 
        {
	Extern_h.mq_mode = macro.PS_EXPECT_TERM;                
	System.out.println("yes");}	
	break;                                     
                                                 
    case macro.MODE_QUERY:                             
      if (Extern_h.last_char_is_newline == 0)                 
        {
	Extern_h.mq_mode = macro.PS_EXPECT_PRD;                 
	System.out.println("yes");
	}
	break;                                     
                                                 
    default:                                     
      break;                                     
    }                                            
//  System.out.println("mq_mode :"+Extern_h.mq_mode);
//  System.out.println("last_char_is_newline :"+Extern_h.last_char_is_newline);
  Extern_h.last_char_is_newline++;                        
  FileList.output_prompt (); 
}

<YYINITIAL> %(.)*\n  { 
  if (Extern_h.error_recovering == true)                          
    {                                            
      switch (Extern_h.mq_mode)                           
        {                                        
        case macro.MODE_COMMAND:                       
        case macro.MODE_PROGRAM:                       
        case macro.MODE_PROGRAM_SUBSUMPTION:           
        case macro.MODE_PROGRAM_RULE:                  
        case macro.PS_EXPECT_TERM:                     
          return new token(sym_num.TERMINATER);                     
   
                                                 
        case macro.MODE_QUERY:                         
        case macro.PS_EXPECT_PRD:                      
        case macro.PS_EXPECT_Q_PRD:                    
          return new token(sym_num.DOTFOREND);                            

                                                 
        default:                                 
          MQ_Error.mq_fatal ("wrong parser staten");        
          break;                                 
        }                                        
    }                                            
  switch (Extern_h.mq_mode)                               
    {                                            
    case macro.MODE_COMMAND:                           
    case macro.MODE_PROGRAM:                           
    case macro.MODE_PROGRAM_SUBSUMPTION:               
    case macro.MODE_PROGRAM_RULE:                      
      if (Extern_h.last_char_is_newline==0)                 
        Extern_h.mq_mode = macro.PS_EXPECT_TERM;                
      break;                                     
                                                 
    case macro.MODE_QUERY:                             
      if (Extern_h.last_char_is_newline==0)                 
        Extern_h.mq_mode = macro.PS_EXPECT_PRD;                 
      break;                                     
                                                 
    default:                                     
      break;                                     
    }                                            
  Extern_h.last_char_is_newline++;                        
  FileList.output_prompt ();                              

}

<YYINITIAL> "/" {return new token(sym_num.MOD);}

<YYINITIAL> "."{WHITE_SPACE_CHAR} { return new token(sym_num.DOTFOREND);}
<YYINITIAL> "."   { return new token(sym_num.DOT);}


<YYINITIAL> &bottom   {return MQ_Atom.make_ATOM("&bottom",sym_num.ATOM);}
<YYINITIAL> &clear    {return new token(sym_num.CLEAR);} 
<YYINITIAL> &end     {return new token(sym_num.END);}
<YYINITIAL> &load     {return new token(sym_num.LOAD);}
<YYINITIAL> &program  {return new token(sym_num.PROGRAM);}
<YYINITIAL> &query    {return new token(sym_num.QUERY);}
<YYINITIAL> &quit     {
System.out.println("I read &quit");return new token(sym_num.QUIT);}
<YYINITIAL> &rule     {return new token(sym_num.RULE);}
<YYINITIAL> &set      {return new token(sym_num.SET);}
<YYINITIAL> &show     {return new token(sym_num.SHOW);}
<YYINITIAL> &subsumption  {return new token(sym_num.SUBSUMPTION);}
<YYINITIAL> &top          {return MQ_Atom.make_ATOM("&top",sym_num.ATOM);}
<YYINITIAL> &true         {return new token(sym_num.LEX_TRUE);}

<YYINITIAL> ({LLETTER}|{DIGIT})({ALPHA}|{DIGIT}|_)* {
	return MQ_Atom.make_ATOM(yytext(),sym_num.ATOM);
}

<YYINITIAL> ({ULETTER}|_)({ALPHA}|{DIGIT}|_)* {
	return MQT_Var.makeT_var(sym_num.VARIABLE,yytext());	
}

<YYINITIAL> ";;"  {return new token(sym_num.TERMINATER);}

<YYINITIAL> "->"  {return new AttrRel(sym_num.ATTRREL, AttrRel.InstanceOf);}

<YYINITIAL> "="   {return new AttrRel(sym_num.ATTRREL, AttrRel.Equal);}
<YYINITIAL> "=="  {return new Rel(sym_num.SUBREL, Rel.Congruent);}
<YYINITIAL> "=<"  {return new Rel(sym_num.SUBREL, Rel.Supersumes);}

<YYINITIAL> "||"  {return new token(sym_num.CONSTRAINED);}
<YYINITIAL> "|"  {return new token(sym_num.BAR);}

<YYINITIAL> ">=" {return new Rel(sym_num.SUBREL, Rel.Subsumes);}

<YYINITIAL> "<=" {return new token(sym_num.COMMITS);}
<YYINITIAL> "<-"  {return new AttrRel(sym_num.ATTRREL, AttrRel.AbstractOf);}

<YYINITIAL> "?-"  {return new token(sym_num.SOLVE);}

<YYINITIAL> ","  {return new token(sym_num.COMMA);}
<YYINITIAL> "{"  {return new token(sym_num.BIGLPAREN);}
<YYINITIAL> "}"  {return new token(sym_num.BIGRPAREN);}
<YYINITIAL> "["  {return new token(sym_num.LPAREN);}
<YYINITIAL> "]"  {return new token(sym_num.RPAREN);}


<YYINITIAL> . {
        System.out.println("Illegal character: <" + yytext() + ">");
	Utility.error(Utility.E_UNMATCHED);

}
