javaparser.cpp

用bcg库编写的java IDE 源码

     if(m_nCharIndex<m_nLineLength)
	 {
       if(m_lszpLine[m_nCharIndex] == '>')//">>"
	   {
		  m_strCurToken += '>';
		  ++m_nCharIndex;//move head for next
          
		  if(m_nCharIndex<m_nLineLength)
		  {
            if(m_lszpLine[m_nCharIndex] == '=')//">>="
			{
              m_strCurToken = ">>=";
		      ++m_nCharIndex;//move head for next
		      return true;
			}
			else
            if(m_lszpLine[m_nCharIndex] == '>')//">>>"
			{
              m_strCurToken = ">>>";
		      ++m_nCharIndex;//move head for next
			  
			  if(m_nCharIndex<m_nLineLength)
			  {
                if(m_lszpLine[m_nCharIndex] == '=')//">>="
				{
                  m_strCurToken = ">>>=";
		          ++m_nCharIndex;//move head for next
				  return true;
				}else return true;
			  }else return true;
			}else return true;//">>"
		  }else return true;//">>"             
	   }
	   else
	   if(m_lszpLine[m_nCharIndex] == '=')//">="
	   {
		 m_strCurToken += '=';
		 ++m_nCharIndex;//move head for next
		 return true;
	   }else return true;//'>'
	 }else return true;//'>'
   }return true;
}


bool CJavaParser::isoperator()
{
  for(int I=0; m_lszpOperators[I] != NULL; I++)
    if(m_strCurToken.Compare(m_lszpOperators[I]) == 0)
		return true;
  return false;
}

bool CJavaParser::skipExtComment()
{
  while(true)
  {
    for(m_nCharIndex; m_nCharIndex<m_nLineLength; m_nCharIndex++)
	{
      char nChar = m_lszpLine[m_nCharIndex];
	  if(nChar == '/'&& m_nCharIndex>0&&m_lszpLine[m_nCharIndex-1] == '*')
	                  return true;
	}
    if(!getNextLine())
  	  return false;
  }
  return false;
}


bool CJavaParser::skipExtCommentBU()
{
  while(true)
  {
    for(m_nCharIndex; m_nCharIndex>=0; m_nCharIndex--)
	{
      char nChar = m_lszpLine[m_nCharIndex];
	  if((nChar == '/')&&(
		  ( m_nLineLength == 0 || (m_nLineLength>0&&m_nCharIndex<m_nLineLength-1))
		  &&(m_lszpLine[m_nCharIndex+1] == '*')	))
	                  return true;
	}
    if(!getLineAbove())
  	  return false;
  }
  return false;
}


bool CJavaParser::skipSingleLineComment()
{
  return getNextLine();
}

bool CJavaParser::getStringOrCharLiteral(char nChar)
{
  while(true)
  {
    for(m_nCharIndex; m_nCharIndex<m_nLineLength; m_nCharIndex++)
	{
       char nChar_1 = m_lszpLine[m_nCharIndex];
       if(nChar_1 == nChar)
	   {
         if(m_nCharIndex>0 && m_lszpLine[m_nCharIndex-1] != '\\')
		 {
           m_strCurToken += nChar;
		   ++m_nCharIndex;
		   return true;
		 }
	   }
	   else
	   m_strCurToken += nChar_1;
	}
    if(m_lszpLine[m_nLineLength-1] == '\\')
	{
      if(!getNextLine())return false;
	}else return false;
  }return false;
}

bool CJavaParser::getNextNonSpaceCharBU(char& nChar)
{
   while(true)
   {
     for(m_nCharIndex; m_nCharIndex>=0; m_nCharIndex--)
	 {
 	   if(m_lszpLine[m_nCharIndex] == '/'&& m_nCharIndex>0&&m_lszpLine[m_nCharIndex-1] == '*')
 	   {
 		  if(!skipExtCommentBU())
 		        return false;
	   }
 	   else
       if(m_lszpLine[m_nCharIndex] != ' ')
 	   {
          nChar = m_lszpLine[m_nCharIndex];
 		 return true;
 	   }
	 } 
     if(!getLineAbove())
   	    return false;
   }return false;
}





bool CJavaParser::localVariableDeclarationStatement()
{
  
  if(!getNextToken())return false;
  if(m_strCurToken.Compare("final") == 0)
  {
    if(!getNextToken())return false;
  }
  m_nDeclType = LOCAL_FIELD_DECL;
  if(isType())
  {
	/**SEMANTIC**/smtSetFieldType(m_strCurToken);/**SEMANTIC**/
    if(variableDeclarators())
	{
      if(!getNextToken())return false;
	  return (m_strCurToken.Compare(";") == 0);
	}else return false;
  }return false;
}

bool CJavaParser::variableDeclarators()
{
   if(variableDeclarator())
   {
	  while(true)
	  {
        saveState(); if(!getNextToken()){popStack();return false;}

	    if(m_strCurToken.Compare(",") == 0)
		{
          popStack();//extract ','
		  if(variableDeclarator())
			continue;
		  else
			return false;
		}
		else
		{
		   resetState();
		   return true;
		}
	  }
   }
   return false;
}

bool CJavaParser::variableDeclarator()
{
  if(identifier())
  {
	 /**SEMANTIC**/smtSetVariableName(m_strCurToken);/**SEMANTIC**/
     return variableDeclaratorRest();
  }
  return false;
}


bool CJavaParser::integerLiteral()
{
  m_nLiteralType = TK_LITERAL_INT;

   int nLen = m_strCurToken.GetLength();
   if(m_strCurToken[0] == '0')//hex or octal
   {
	   if(nLen>1&&(m_strCurToken[1] == 'x' || m_strCurToken[1] == 'X'))
		   return hexLiteral();
	   else
	   if(nLen == 1)
		   return decimalLiteral();
	   else
		   return octalLiteral();
   }
   else
   if(IS_DIGIT(m_strCurToken[0]))
   {
      for(int I=0; I<nLen; I++)
	  {
        if(IS_DIGIT(m_strCurToken[I]))
			continue;
		else
		if((m_strCurToken[0] == 'l' || m_strCurToken[0] == 'L')&&(nLen == I-1))
		{
          if(m_bCodeCompletionAction)
			  m_nLiteralType = TK_LITERAL_LONG;
		  return true;
		}
		else goto f;
	  }
	  return true;
   }
   else
   {
f:
      return floatingPointLiteral();
   }
   return false;
}

bool CJavaParser::decimalLiteral()
{
  long nLen = m_strCurToken.GetLength();
  for(int i=0; i<nLen; i++)
  {
    if(IS_DIGIT(m_strCurToken[i]))
		continue;
	else
	if((i==nLen-1&&
		(i>0&&IS_DIGIT(m_strCurToken[i-1])))
		&&(m_strCurToken[i] == 'l' || m_strCurToken[i] == 'L'))
		return true;
	else
		return false;
  }	
  return true;
}


bool CJavaParser::hexLiteral()
{

  int nLen = m_strCurToken.GetLength();
  if(nLen<3)return false;

  for(int i=2; i<nLen; i++)
  {
    if(hexDigit(m_strCurToken[i]))
		continue;
	else//must have at least one hex digit, hence assertion(nLen>3)
	if((i==nLen-1&&(i>2&&hexDigit(m_strCurToken[i-1])))
		&&(m_strCurToken[i] == 'l' || m_strCurToken[i] == 'L'))
		return true;
	else
		return false;
  }	
  return true;
}



bool CJavaParser::hexDigit(char nChar)
{
  return (isxdigit(nChar) != 0);
}


bool CJavaParser::octalLiteral()
{
  long nLen = m_strCurToken.GetLength();
  for(int i=1; i<nLen; i++)
  {
    if(IS_DIGIT(m_strCurToken[i]))
	{
	  CString strC(m_strCurToken);
	  int n = 9;//atoi(strC.GetBuffer(strC.GetLength()+1));strC.ReleaseBuffer();
	  if(n<8)
	    continue;
	  else
		return false;
	}
	else
	if((i==nLen-1&&
		(i>0&&IS_DIGIT(m_strCurToken[i-1])))
		&&(m_strCurToken[i] == 'l' || m_strCurToken[i] == 'L'))
		return true;
	else 
	return false;
  }	
  return true;
}


bool CJavaParser::floatingPointLiteral()
{
  m_nLiteralType = TK_LITERAL_FLOAT;

  int nLen = m_strCurToken.GetLength();
  char f = m_strCurToken[nLen-1];
  
  bool bPoint = false;
  for(int i=0; i<nLen; i++)
  {
    if(IS_DIGIT(m_strCurToken[i]))
         continue;
    else//can't be the first or last item in token
    if((i<nLen-1&&i>0)&&(m_strCurToken[i] == 'e' || m_strCurToken[i] == 'E'))
    {
       for(int x=i+1; x<nLen; x++)
	   {
		 //skip sign , if any
         if(m_strCurToken[x] == '+' || m_strCurToken[x] == '-')
				++x;

		    if(x<nLen-1)//sign can't last item in token
			{
		      for(x; x<nLen; x++)
			  {
                if(IS_DIGIT(m_strCurToken[x]))
                   continue;
				else
				if((x==nLen-1)&&(f == 'f' || f == 'F' || f == 'd' || f == 'D'))
				{
                   if((f == 'd') || (f == 'D'))
				     m_nLiteralType = TK_LITERAL_DOUBLE;
				   return true;
				}
				else
					return false;
			  }
			  return true;

			}else return false;

	   }
	   return false;	 
	}
	else
	if(!bPoint&&(IS_DIGIT(m_strCurToken[0])|| 
				 (m_strCurToken[0] == '.'&&nLen>1&&IS_DIGIT(m_strCurToken[1]))))
           bPoint = true;
	else
    if((i==nLen-1&&nLen>1)&&(f == 'f' || f == 'F' || f == 'd' || f == 'D'))
	{
        if((f == 'd') || (f == 'D'))
	   m_nLiteralType = TK_LITERAL_DOUBLE;
	    return true;
	}
	else return false;
   }
   return true;
}


bool CJavaParser::isCharacterLiteral()
{
  int nLen = m_strCurToken.GetLength();
  return ((m_strCurToken[0] == '\'') & (m_strCurToken[nLen-1] == '\''));
}

bool CJavaParser::isStringLiteral()
{
  int nLen = m_strCurToken.GetLength();
  return ((m_strCurToken[0] == '"') & (m_strCurToken[nLen-1] == '"'));
}

bool CJavaParser::isIntegerLiteral()
{
   return integerLiteral();
}

bool CJavaParser::isFloatingPointLiteral()
{
   return floatingPointLiteral();
}


bool CJavaParser::stringLiteral()
{
  long nLen = m_strCurToken.GetLength();
  return ((m_strCurToken[0] == '"') & (m_strCurToken[nLen-1] == '"'));
}

bool CJavaParser::characterLiteral()
{
  long nLen = m_strCurToken.GetLength();
  return ((m_strCurToken[0] == '\'') & (m_strCurToken[nLen-1] == '\''));
}

bool CJavaParser::booleanLiteral()
{
  return (m_strCurToken == "true" || m_strCurToken == "false");
}

bool CJavaParser::nullLiteral()
{
  return (m_strCurToken == "null");
}



void CJavaParser::saveState()
{
  __state__  state(m_nLineIndex,m_nCharIndex,
	  m_nLineLength,m_lszpLine,m_strCurToken);
  m_stStates.Push(state);
}

void CJavaParser::resetState()
{
  __state__  state;
  m_stStates.Pop(state);
  m_nLineIndex = state.line; m_nCharIndex = state.index; m_strCurToken = state.token;
  m_lszpLine = state.szpLine; m_nLineLength = state.length;
}

void CJavaParser::popStack()
{
  m_stStates.Pop();
}



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


bool CJavaParser::declareMember()
{
   if(classBodyDeclaration())
   {
   switch(m_nDeclType)
   {
     case FIELD_DECL:
		  return declField();
     case METHOD_DECL:
          return declMethod();
	 case CLASS_DECL:
          return declClass();
	 case INTERFACE_DECL:
          return declInterface();
	 default:;
   }}return false;
}


bool CJavaParser::declareLocal()
{
   localVariableDeclarationStatement();
   return false;
}


bool CJavaParser::declareType()
{
  if(m_strCurToken.Compare("class") == 0)
  {
     if(classDeclaration())
		 return declClass();
  }
  else
  if(m_strCurToken.Compare("interface") == 0)
  {
     if(interfaceDeclaration())
		 return declInterface();
  }
  /*

   if(typeDeclaration())
   {
      switch(m_nDeclType)
	  {
	     case CLASS_DECL:
           return declClass();
	     case INTERFACE_DECL:
           return declInterface();
	     default:;
	  }
   }
   */
   return false;
}

bool CJavaParser::declarePackage()
{
   if(packageDeclaration())
   {


     return true;
   }return false;
}

bool CJavaParser::declareImport()
{
 return importDeclaration();
}



void CJavaParser::parseOnFileLoaded()
{
	m_pLastBlock = NULL;
  // ASSERT(m_stSaveInts.StackIsEmpty());
   //initialization
   m_stStates.PopAll();
   m_lszpLine    = m_pDeclManager->getTextBuffer()->GetLineChars(0);
   m_nLineLength = m_pDeclManager->getTextBuffer()->GetLineLength(0);

   m_bDynamiclyParsing = false;

   while(getNextToken())
   {
	  //we want to make sure this token is consumed for good
	  //the parse() call doesn't guarantee such consumption
	  saveState();
	  //get the actual startindex for the following potential declaration
      m_nStartIndex = m_nCharIndex-m_strCurToken.GetLength();
      m_nStartLine  = m_nLineIndex;
      /**m_nCharIndex  = m_nStartIndex;**/
	  //returns true if this parse did lead to a declaration
      if(parse())
	  {
		 popStack();//skip descralation range
	     //if last token of last parse isn't oneof(';','{','}')
	     //break parsing and return
	     if((m_strCurToken.Compare(";") == 0)
			 || (m_strCurToken.Compare("{") == 0) 
			 || (m_strCurToken.Compare("}") == 0))
		 {
            continue;
		 }
	     else
		 {
           //find oneof(';','{','}')
           findStopSymbol();
		 }	 
	  }
	  else
	  {
		 resetState();//get next token
	  }
	  
   }
     ASSERT(m_stStates.StackIsEmpty());
//   ASSERT(m_stSaveInts.StackIsEmpty());
//   ASSERT(m_nBlockCount == 0);
}

//this funtion is call on every editing operation
//it parses a segment of code between declaration blocks;



void CJavaParser::dynamicParse(int nCharIndex,int nLineIndex,CBlockDecl* pBlock/*=NULL*/)
{
   //initialization
   m_nLineIndex  = nLineIndex;
   m_lszpLine    = m_pDeclManager->getTextBuffer()->GetLineChars(nLineIndex);
   m_nLineLength = m_pDeclManager->getTextBuffer()->GetLineLength(nLineIndex);
   m_nCharIndex  = nCharIndex;
   m_pLastBlock  = pBlock;
   m_stStates.PopAll();
   POSITION startPos = (m_pLastBlock)?m_pLastBlock->getMainPos():m_pDeclManager->getDeclList()->GetHeadPosition();

   while(getNextToken())
   {
	  //we want to make sure this token is consumed for good
	  //the parse() call doesn't guarantee such consumption
	  saveState();

	  //get the actual startindex for the following potential declaration
      m_nStartIndex = m_nCharIndex-m_strCurTok