static bool parseIdentifier(LexerCarriage* carriage, Token* result)
{
int shift = 0;
while (carriage->posInText + shift < carriage->lexingText.length)
{
char ch = carriage->lexingText.pointer[carriage->posInText + shift];
if (shift == 0)
{
if (isCharacter(ch) || ch == '_')
{
++shift;
}
else break;
}
else
{
if (isCharacter(ch) || isDigit(ch) || ch == '_')
{
++shift;
}
else break;
}
}
if (shift != 0)
{
result->type = TOK_IDENTIFIER;
result->identifierValue = StringSlice{ &carriage->lexingText.pointer[carriage->posInText], shift };
carriage->posInText += shift;
return true;
}
else return false;
}
QByteArray stringFromContents(const uint* contents, int count) {
QByteArray ret;
for(int a = 0; a < count; ++a) {
if(isCharacter(contents[a]))
ret.append(characterFromIndex(contents[a]));
else
ret += KDevelop::IndexedString::fromIndex(contents[a]).byteArray();
}
return ret;
}
QByteArray stringFromContents(const PreprocessedContents& contents, int offset, int count) {
QByteArray ret;
for(int a = offset; a < (count ? offset+count : contents.size()); ++a) {
if(isCharacter(contents[a]))
ret.append(characterFromIndex(contents[a]));
else
ret += KDevelop::IndexedString::fromIndex(contents[a]).byteArray();
}
return ret;
}
char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
if( !isNumeric( *in ) && !isCharacter( *in ) ) {
++in;
}
in = lookForNextToken( in, end );
Value::ValueType type( Value::ddl_none );
size_t arrayLen( 0 );
in = OpenDDLParser::parsePrimitiveDataType( in, end, type, arrayLen );
if( Value::ddl_none != type ) {
// parse a primitive data type
in = lookForNextToken( in, end );
if( *in == Grammar::OpenBracketToken[ 0 ] ) {
Reference *refs( ddl_nullptr );
DataArrayList *dtArrayList( ddl_nullptr );
Value *values( ddl_nullptr );
if( 1 == arrayLen ) {
size_t numRefs( 0 ), numValues( 0 );
in = parseDataList( in, end, type, &values, numValues, &refs, numRefs );
setNodeValues( top(), values );
setNodeReferences( top(), refs );
} else if( arrayLen > 1 ) {
in = parseDataArrayList( in, end, type, &dtArrayList );
setNodeDataArrayList( top(), dtArrayList );
} else {
std::cerr << "0 for array is invalid." << std::endl;
error = true;
}
}
in = lookForNextToken( in, end );
if( *in != '}' ) {
logInvalidTokenError( in, std::string( Grammar::CloseBracketToken ), m_logCallback );
return ddl_nullptr;
} else {
//in++;
}
} else {
// parse a complex data type
in = parseNextNode( in, end );
}
return in;
}
void getNextToken(Lexer *self) {
self->startPos = 0;
skipLayoutAndComments(self);
self->startPos = self->pos;
if (isEndOfInput(self->currentChar)) {
recognizeEndOfInputToken(self);
self->running = false; // stop lexing
return;
}
else if (isDigit(self->currentChar) || (self->currentChar == '.' && isDigit(peekAhead(self, 1)))) {
// number
recognizeNumberToken(self);
}
else if (isLetterOrDigit(self->currentChar) || self->currentChar == '_') {
// ident
recognizeIdentifierToken(self);
}
else if (isString(self->currentChar)) {
// string
recognizeStringToken(self);
}
else if (isCharacter(self->currentChar)) {
// character
recognizeCharacterToken(self);
}
else if (isOperator(self->currentChar)) {
// operator
recognizeOperatorToken(self);
}
else if (isEndOfLine(self->currentChar)) {
recognizeEndOfLineToken(self);
}
else if (isSeparator(self->currentChar)) {
// separator
recognizeSeparatorToken(self);
}
else {
// errorneous
recognizeErroneousToken(self);
}
}
int Describe(char* str, int len, Object* object){
if( isNil(object) )
return DescribeNil(str, len, object);
if( isConsCell(object) )
return DescribeConsCell(str, len, object);
if( isSymbol(object) )
return DescribeSymbol(str, len, object);
if( isInteger(object) )
return DescribeInteger(str, len, object);
if( isLambda(object) )
return DescribeLambda(str, len, object);
if( isPrimitiveFunc(object) )
return DescribePrimitiveFunc(str, len, object);
if( isContinuation(object) )
return DescribeContinuation(str, len, object);
if( isEnvironment(object) )
return DescribeEnvironment(str, len, object);
if( isBool(object) )
return DescribeBool(str, len, object);
if( isSpecialForm(object) )
return DescribeSpecialForm(str, len, object);
if( isCondition(object) )
return DescribeCondition(str, len, object);
if( isCharacter(object) )
return DescribeCharacter(str, len, object);
else
return DescribeUnknown(str, len, object);
}
int Inspect(char* str, int len, Object* object){
if( isNil(object) )
return InspectNil(str, len, object);
if( isConsCell(object) )
return InspectConsCell(str, len, object);
if( isSymbol(object) )
return InspectSymbol(str, len, object);
if( isInteger(object) )
return InspectInteger(str, len, object);
if( isLambda(object) )
return InspectLambda(str, len, object);
if( isPrimitiveFunc(object) )
return InspectPrimitiveFunc(str, len, object);
if( isContinuation(object) )
return InspectContinuation(str, len, object);
if( isEnvironment(object) )
return InspectEnvironment(str, len, object);
if( isBool(object) )
return InspectBool(str, len, object);
if( isSpecialForm(object) )
return InspectSpecialForm(str, len, object);
if( isCondition(object) )
return InspectCondition(str, len, object);
if( isCharacter(object) )
return InspectCharacter(str, len, object);
else
return InspectUnknown(str, len, object);
}
int canWalk(MAP* m, char character, int x, int y){
return isValid(m, x, y) && !isWall(m, x, y) && !isCharacter(m, character, x, y);
}
