/*
* Copies the characters forming an identifier from *cp into
* name, leaving *cp pointing to the character after the identifier.
*/
static rubyKind parseIdentifier (
const unsigned char** cp, vString* name, rubyKind kind)
{
/* Method names are slightly different to class and variable names.
* A method name may optionally end with a question mark, exclamation
* point or equals sign. These are all part of the name.
* A method name may also contain a period if it's a singleton method.
*/
const char* also_ok = (kind == K_METHOD) ? "_.?!=" : "_";
skipWhitespace (cp);
/* Check for an anonymous (singleton) class such as "class << HTTP". */
if (kind == K_CLASS && **cp == '<' && *(*cp + 1) == '<')
{
return K_UNDEFINED;
}
/* Check for operators such as "def []=(key, val)". */
if (kind == K_METHOD || kind == K_SINGLETON)
{
if (parseRubyOperator (name, cp))
{
return kind;
}
}
/* Copy the identifier into 'name'. */
while (**cp != 0 && (isalnum (**cp) || charIsIn (**cp, also_ok)))
{
char last_char = **cp;
vStringPut (name, last_char);
++*cp;
if (kind == K_METHOD)
{
/* Recognize singleton methods. */
if (last_char == '.')
{
vStringTerminate (name);
vStringClear (name);
return parseIdentifier (cp, name, K_SINGLETON);
}
/* Recognize characters which mark the end of a method name. */
if (charIsIn (last_char, "?!="))
{
break;
}
}
}
return kind;
}
int skipWord(const char *&c){
while(!charIsIn(*c, whitespace) && (*c != '\0')){
const int delimeterChars = isAWordDelimeter(c);
if(delimeterChars == 0)
++c;
else
return delimeterChars;
}
return 0;
}
std::string strip(const char *c, const size_t chars){
if(chars == 0)
return "";
const char *cLeft = c;
const char *cRight = c + (chars - 1);
while(charIsIn(*cLeft , whitespace) && (cLeft <= cRight)) ++cLeft;
while(charIsIn(*cRight, whitespace) && (cRight > cLeft)) --cRight;
if(cLeft > cRight)
return "";
std::string ret = "";
const char *cMid = cLeft;
while(cMid < cRight){
if((cMid[0] == '\\') && isWhitespace(cMid[1])){
ret += strip(cLeft, cMid - cLeft);
ret += ' ';
++cMid;
cLeft = (cMid + 1);
}
++cMid;
if((cMid >= cRight) && ret.size())
ret += strip(cLeft, (cMid - cLeft + 1));
}
if(ret.size() == 0)
return compressWhitespace( std::string(cLeft, (cRight - cLeft + 1)) );
return compressWhitespace(ret);
}
char isAWordDelimeter(const char *c){
if( charIsIn(c[0], wordDelimeter) ){
if(charIsIn2(c, wordDelimeter2)){
if(charIsIn3(c, wordDelimeter3))
return 3;
return 2;
}
return 1;
}
return 0;
}
void skipToWhitespace(const char *&c){
while(!charIsIn(*c, whitespace) && (*c != '\0'))
++c;
}
bool isWhitespace(const char c){
return charIsIn(c, whitespace);
}
