コード例 #1
0
ObjLexer::ObjLexer(std::string const& raw_object)
{
  char ch;
  int i = 0;

  while (i < (int)raw_object.size())
  {
    ch = raw_object[i];

    // v/vt/vn
    if (ch == 'v')
    {
      Token::Type type;

      if (raw_object[i + 1] == 't')
      {
        type = Token::Type::VERTEX_T;
      }
      else if (raw_object[i + 1] == 'n')
      {
        type = Token::Type::VERTEX_N;
      }
      else
      {
        type = Token::Type::VERTEX;
      }

      i += AddNewToken(type, i, raw_object);
    }
    // f
    else if (ch == 'f')
    {
      i += AddNewToken(Token::Type::FACE, i, raw_object);
    }
    // comment or g (grouping which we ignore atm)
    else if (ch == '#' || ch == 'g')
    {
      size_t size = raw_object.find('\n', i);
      i += size - i;
    }
    // everything else becomes a literal
    else if (isLiteral(ch))
    {
      i += AddNewToken(Token::Type::LITERAL, i, raw_object);
    }
    // whitespace, and eoln
    else if (ch == ' ' || ch == '\n')
    {
      i++;
      continue;
    }
  }
}
コード例 #2
0
void CCmdParse::AddChar()
{                        
   if (*m_pCurrent == '\0')
   {    //check to see if we were in the middle of building something,
   		//otherwise quit.
    	if (strlen(m_Token) > 0)
    		AddNewToken();
   		State = e_end;
   		return;
   }
   
   if (State == e_start  && (*m_pCurrent == '"'))
   {    //we are handling a quoted string
		State = e_quote;
		Previous = e_start;
		++m_pCurrent;
		return;
   }        
   
   if (State == e_start && ((*m_pCurrent != '"') && (!isspace(*m_pCurrent))) )
   {    //we are handling a non quoted string
		State = e_other;
		Previous = e_start;
		return;   	
   }
   
   if (State == e_start && (isspace(*m_pCurrent)))
   {
	   State = e_space;
       Previous = e_start;
	   return;
   }
       
   if (State == e_quote && (*m_pCurrent != '"'))   
   {    //add it to the token builder
   		m_Token[m_nIndex++] = *m_pCurrent++;
   		return;	
   }                     
   
   if (State == e_quote && (*m_pCurrent == '"'))
   {    //we found another quote.             
   		if (*(m_pCurrent -1) == '"')
   		{   //look back and see if quotes are wrong
   			//path names must be separated by quotes!!!!
   			State = e_error;
   			return;
   		}
   		if( !isspace(*(m_pCurrent +1)) && (*(m_pCurrent +1) != '\0') )
   		{
   			//look ahead and make sure they delimeted the quoted argument
   			State = e_error;
   			return;
   		}
   		Previous = State;//not used
   		//set the state so we know what we last saw and can expect
   		State = e_end_quote;
 		//add the quoted string minus the quotes
   		AddNewToken();
  		return;
   }   
   
   if (State == e_end_quote && (*m_pCurrent != '"'))
   {    //we are expecting a space or a non quote
   	   	if(isspace(*m_pCurrent))
   	   	{    
   	   		++m_pCurrent;
   	   		State = e_space;
   	   		Previous = e_end_quote;
   	   	}
   	   	else
   	   	{
   	   		State = e_other; 		
   	   		Previous = e_end_quote;
   	   	}
   	   	return; 	   		
   }
   if (State == e_end_quote && (*m_pCurrent == '"'))
   {    //suscpicious
   		++m_pCurrent; 
   		return;
   }
   
   
   if (State == e_other && ((!isspace(*m_pCurrent)) && (*m_pCurrent != '"')) )
   {    //add it to the token builder                        
    	m_Token[m_nIndex++] = *m_pCurrent++;
   		return;   		
   }
   else if(State == e_other && (isspace(*m_pCurrent)) )
   {    //add the non quoted token
   		AddNewToken();
   		Previous =  e_other;
   		if ( isspace(*m_pCurrent) )
   			State =  e_space;
   	    else
   			State = e_start;			   	    	    

		return;
    }
    else if(State == e_other && (*m_pCurrent == '"'))
    {
    	 State = e_error;
    	 return;
    }
    
    if (State == e_space && (!isspace(*m_pCurrent) ) )
    {
    	State = e_start;
    	Previous = e_space;
    	return;	
    }
    
    if (State == e_space && (isspace(*m_pCurrent)) )
    {   //eat up spaces.
    	while (isspace(*m_pCurrent))
    		++m_pCurrent;
    	return;
    }
    
     
   
   
}