javaparser.cpp

用bcg库编写的java IDE 源码

// JavaParser.cpp: implementation of the CJavaParser class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "JavaParser.h"
#include "JavaDeclManager.h"
#include "VisualJavaDoc.h"
#include "VisualJava.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
#define floatTypeSuffix(x) (x=='f'||x == 'F' || x=='d'||x == 'D')
#define IS_DIGIT(c) (c>47&&c<58)

#define IS_IDENTIFIERSYM(c) ((IS_DIGIT(c))||(c>64&&c<91)||(c>96&&c<123)||(c=='_'))

#define TK_IDENTIFIER        1
#define TK_OPERATOR_PREFIX   2
#define TK_OPERATOR_INFIX    22
#define TK_OPERATOR_POSTFIX  24

#define TK_OPENPAREN         4
#define TK_CLOSEPAREN        8


#define TK_ASSIGNOPERATOR    35

#define TK_TYPE_FROMCREATOR  20

#define TK_TYPE              26

#define TK_LITERAL_CHAR      27
#define TK_LITERAL_STRING    29
#define TK_LITERAL_INT       30
#define TK_LITERAL_NULL      31
#define TK_LITERAL_BOOLEAN   32
#define TK_LITERAL_FLOAT     33
#define TK_LITERAL_DOUBLE    34
#define TK_LITERAL_LONG      36
#define TK_NUMERICLITERAL    35

#define TK_THIS              500
#define TK_LITERAL           501

#define LITERAL(x)    (x==TK_LITERAL_CHAR)?"char":(x==TK_LITERAL_STRING)?"String"\
:(x == TK_LITERAL_INT)?"int":(x==TK_LITERAL_NULL)?"null":\
(x==TK_LITERAL_BOOLEAN)?"boolean":(x == TK_LITERAL_FLOAT)?"float":\
(x == TK_LITERAL_DOUBLE)?"double":"null"


LPCTSTR   CJavaParser::m_lszpBasicTypes[]=
{
  _T("byte"),
  _T("short"),
  _T("char"),
  _T("long"),
  _T("float"),
  _T("double"),
  _T("boolean"),
  _T("int"),
  NULL
};

LPCTSTR   CJavaParser::m_lszpPostFixOps[]=
{
  _T("++"),
  _T("--"),
  NULL
};



LPCTSTR   CJavaParser::m_lszpInfixOps[]=
{
  _T("||"),
  _T("&&"),
  _T("|"),
  _T("^"),
  _T("&"),
  _T("=="),
  _T("!="),
  _T("<"),
  _T(">"),
  _T("<="),
  _T(">="),
  _T("<<"),
  _T(">>"),
  _T(">>>"),
  _T("+"),
  _T("-"),
  _T("*"),
  _T("/"),
  _T("%"),
  NULL
};



LPCTSTR   CJavaParser::m_lszpPrefixOps[]=
{
  _T("++"),
  _T("--"),
  _T("!"),
  _T("~"),
  _T("+"),
  _T("-"),
  NULL
};

LPCTSTR   CJavaParser::m_lszpAssignmentOps[]=
{
  _T("="),
  _T("+="),
  _T("-="),
  _T("*="),
  _T("/="),
  _T("&="),
  _T("|="),
  _T("^="),
  _T("%="),
  _T("<<="),
  _T(">>="),
  _T(">>>="),
  NULL
};

static LPCTSTR m_lszpOperators[]=
{
  _T("="),
  _T("+"),
  _T("-"),
  _T("*"),
  _T("/"),
  _T("&"),
  _T("|"),
  _T("^"),
  _T("%"),
  _T("<<"),
  _T(">>"),
  _T(">>>"),
  _T("!"),
  _T(">"),
  _T("<"),
  _T("~"),
  _T("?"),
  _T(":"),
  NULL
};


LPCTSTR   CJavaParser::m_lszpModifiers[]=
{
  _T("public"),
  _T("protected"),
  _T("private"),
  _T("static"),
  _T("abstract"),
  _T("final"),
  _T("native"),
  _T("synchronized"),
  _T("transient"),
  _T("volatile"),
  _T("strictfp"),
  NULL	
};

LPCTSTR   CJavaParser::m_lszpJavaKeyword[]=
{
    _T("abstract"),
	_T("default"),
    _T("if"),
	_T("private"),
	_T("this"),
	_T("boolean"),
	_T("do"),
	_T("implements"),
    _T("protected"),
    _T("throw"),
	_T("break"),
	_T("double"),
	_T("import"),
	_T("public"),
	_T("throws"),
	_T("byte"),
	_T("else"),
	_T("instanceof"),
    _T("return"),
	_T("transient"),
	_T("case"),
	_T("extends"),
    _T("long"),
	_T("short"),
	_T("try"),
	_T("catch"),
	_T("final"),
	_T("interface"),
	_T("static"),
	_T("void"),
	_T("char"),
	_T("finally"),
    _T("long"),
	_T("strictfp"),
	_T("volatile"),
	_T("class"),
	_T("float"),
	_T("native"),
	_T("super"),
	_T("while"),
	_T("const"),
	_T("for"),
	_T("new"),
	_T("switch"),
	_T("continue"),
    _T("goto"),
	_T("package"),
	_T("synchronized"),
	_T("int"),
	NULL
};

static LPCTSTR m_lszpFIRSTexpr2Rest[]=
{
   NULL
};

static LPCTSTR m_lszpFIRSTexpr[]=
{
  _T("("),
  _T("this"),
  _T("super"),
  _T("new"),
  _T("void"),
  NULL
};

static LPCTSTR m_lszpFIRSTexpr_3[]=
{
  _T("("),
  _T("this"),
  _T("super"),
  _T("new"),
  _T("void"),
  NULL
};


CJavaParser::CJavaParser(CJavaDeclManager* pDcMng,bool bTotalParse /*=true*/)
{
  m_nDeclType         = -1;
  m_nCharIndex        = 0;
  m_nLineIndex        = 0;
  m_lszpLine          = NULL;
  m_pDeclManager      = pDcMng;
  m_bSuccess          = false;
  m_bDynamiclyParsing = false;
//  m_bPeeking          = false;
  m_bTotalParse       = bTotalParse;
  m_pLastBlock        = NULL;

  m_bCodeCompletionAction = false;

  m_nLiteralType      = 0;
  m_nBlockCount       = 0;
  m_bCCSuccess        = false;
}

CJavaParser::~CJavaParser()
{

}

//*********************************************************************//
//rule:                                                                //
//   Expression:                                                       //
//            Expression1 [AssignmentOperator Expression1]]            //
//*********************************************************************//
bool CJavaParser::FIRSTexpr()
{
  for(int I=0; m_lszpFIRSTexpr[I] != NULL; I++)
	  if(m_strCurToken.Compare(m_lszpFIRSTexpr[I]) == 0)return true;
   
  if(isPrefixOp())
	  return true;
  else
  if(isLiteral())
    return true;
  else
  if(isIdentifier())
    return true;
  else
  if(isBasicType())
	  return true;
  else
  return false;
}

bool CJavaParser::FIRSTexpr_3()
{
  for(int I=0; m_lszpFIRSTexpr[I] != NULL; I++)
	  if(m_strCurToken.Compare(m_lszpFIRSTexpr_3[I]) == 0)return true;
   
  if(isPrefixOp())
	  return true;
  else
  if(isLiteral())
    return true;
  else
  if(isIdentifier())
    return true;
  else
  if(isBasicType())
	  return true;
  else
  return false;
}


bool CJavaParser::FIRSTselector()
{
  if(m_strCurToken.Compare(".") == 0)
	  return true;
  else
  return (m_strCurToken.Compare("[") == 0);
}

bool CJavaParser::isLiteral()
{
   m_nLiteralType = 0;
   if(m_strCurToken[0] == '\'')
   {
	 m_nLiteralType = TK_LITERAL_CHAR;
     return characterLiteral();
   }
   else
   if(m_strCurToken[0] == '"')
   {
	 m_nLiteralType = TK_LITERAL_STRING;
     return stringLiteral();
   }
   else
   if((m_strCurToken.Compare("true") == 0) ||( m_strCurToken.Compare("false") == 0))
   {
     m_nLiteralType = TK_LITERAL_BOOLEAN;
	 return true;
   }
   else
   if(m_strCurToken.Compare("null") == 0)
   {
	 m_nLiteralType = TK_LITERAL_NULL;
     return true;
   }else  return integerLiteral();
}


bool CJavaParser::expr_0()
{
  if(expr_1())
  {
	//OPT
	saveState();if(!getNextToken()){popStack();return false;}
    if(isAssignmentOp())
	{
       popStack();//extract assignment operator
   	   return expr_1();
	}
	else
	{
	   resetState();//back track;
       return true;
	}
  }return false;
}

bool CJavaParser::isAssignmentOp()
{
  for(int I=0; m_lszpAssignmentOps[I] != NULL; I++)
	  if(m_strCurToken.Compare(m_lszpAssignmentOps[I]) == 0)return true;
  return false;
}
//////////////////////////////////////////////////////////////////////////
//**********************************************************************//
//*rule:                                                               *//
//*   Expression1:                                                     *//
//*             Expression2 [Expression1Rest]                          *//
//**********************************************************************//
//////////////////////////////////////////////////////////////////////////

bool CJavaParser::expr_1()
{
  if(expr_2())
  {
	 saveState();if(!getNextToken()){popStack();return false;}
	 if(m_strCurToken.Compare("?") == 0)
	 {
	   popStack();//consume '?'
	   return expr_1rest();
	 }
	 else
	 {
	   resetState();//backtrack to '?'
       return true;
	 }
  }else return false;
}


bool CJavaParser::expr_1rest()//HANDLE : '?'
{
    if(expr_0())
	{
       if(!getNextToken())return false;
	   if(m_strCurToken.Compare(":") == 0)
		  return expr_1();
	}return false;
}

//*******************************************************************************
//Expression2:
//   Expression3 [Expression2Rest]
//*******************************************************************************


bool CJavaParser::expr_2()
{
   if(!getNextToken())return false;//get handle b4 calling
   if(expr_3())
   {
	 saveState();if(!getNextToken()){popStack();return false;}
	 if(FIRSTexpression2rest())
	 {
	    popStack();
	    return expr_2rest();
	 }
	 else
	 {
	    resetState();//backtrack
	    return true;
	 }
   }return false;
}

bool CJavaParser::FIRSTexpression2rest()
{
  if(isInfixOp())
	  return true;
  else return FIRSTexpr();
}


bool CJavaParser::expr_2rest()//HANDLE : FIRSTexpression2rest
{
  if(isInfixOp())
  {
     /**CODE_COMPLETION**/
	  exprEvaluator(m_strCurToken,TK_OPERATOR_INFIX);
	  /**CODE_COMPLETION**/
	  if(!getNextToken())return false;//get handle for expr_3
	  if(expr_3())
	  {
	      while(true)
		  {
	         saveState();if(!getNextToken()){popStack();return false;}
	         if(isInfixOp())
			 {
	            popStack();//consume  
				if(!getNextToken())return false;//get handle for expr_3
                if(!expr_3())return false;
			 }else{resetState();return true;}
		  }
	  }else return false;
  }  

  if(expr_3())
  {
     if(!getNextToken())return false;
	 if(m_strCurToken.Compare("instanceof") == 0)
        return type();
	 else 
		return false;
  }else return false;
}


bool CJavaParser::expr_3()//HANDLE : FIRSTexpr
{
  if(isPrefixOp())
  {
     /**CODE_COMPLETION**/exprEvaluator(m_strCurToken,TK_OPERATOR_PREFIX);/**CODE_COMPLETION**/
	 if(!getNextToken())return false;//retreve handle for expr_3
	 return expr_3();
  }
  else
  if(m_strCurToken.Compare("(") == 0)
  {
	  saveState();
	  if(!type())
	  {
__1:
		 resetState();
	     if(!expr_0())return false;
		 if(!getNextToken()){popStack();return false;}
		 if(m_strCurToken.Compare(")") == 0)
			   goto __2;
		 return false;
	  }
	  else //run a second test,make sure next token is ')'
	  {
		  if(!getNextToken()){popStack();return false;}
		  if(m_strCurToken.Compare(")") == 0)
		  {
		      popStack();
__2:
		      //this is to resolve the ambigiouty of
		      //"( Expr | Type ) Expression3" or "(Expression)"
		      saveState();if(!getNextToken()){popStack();return false;}
		      if(FIRSTexpr_3())
			  {
			    popStack();
		        return expr_3();
			  }
		      else
			  {
                 resetState();return true;
			  }
		  }else goto __1;//if not ')' then it's an expr
	  }
  }
  else
  if(primary())
  {
	  saveState();if(!getNextToken()){popStack();return false;}
	  while(true)
	  {
	     if(FIRSTselector())
		 {  
		    popStack();
            if(!selector())return false;
            saveState();if(!getNextToken()){popStack();return false;}
		 }else break;
	  }

	  while(true)
	  {
		  if(isPostfixOp())
		  { 
			 popStack();
			 saveState();if(!getNextToken()){popStack();return false;}
		  }else{ resetState(); break;}		  
	  }
	  return true;
  }return false;
}







bool CJavaParser::infixop()
{
  if(!getNextToken())return false;
  for(int i=0; m_lszpInfixOps[i] != NULL; i++)
	  if(m_strCurToken.Compare(m_lszpInfixOps[i]) == 0)return true;
  return false;
}

bool CJavaParser::isInfixOp()
{
  for(long i=0; m_lszpInfixOps[i] != NULL; i++)
	  if(m_strCurToken.Compare(m_lszpInfixOps[i]) == 0)return true;
  return false;
}

bool CJavaParser::primary()//HANDLE : ???
{
  if(m_strCurToken.Compare("(") == 0)
  {
     if(expr_0())
	 {
        if(!getNextToken())return false;
        if(m_strCurToken.Compare(")") == 0)
		  return true;
	 }else return false;
  }
  else
  if(m_strCurToken.Compare("this") == 0)
  {
     saveState(); if(!getNextToken()){popStack();return false;}
	 if(m_strCurToken.Compare("(") == 0)
	 {
	   popStack();//consume '('
	   return arguments();
	 }
	 else
	 {
        /**CODE_COMPLETION**/exprEvaluator("this",TK_THIS);/**CODE_COMPLETION**/
		resetState();//undo consumption
	    return true;
	 }