bool WebSocketExtensionParser::parseExtension(String& extensionToken, HashMap<String, String>& extensionParameters)
{
// Parse extension-token.
if (!consumeToken())
return false;
extensionToken = currentToken();
// Parse extension-parameters if exists.
while (consumeCharacter(';')) {
if (!consumeToken())
return false;
String parameterToken = currentToken();
if (consumeCharacter('=')) {
if (consumeQuotedStringOrToken())
extensionParameters.add(parameterToken, currentToken());
else
return false;
} else
extensionParameters.add(parameterToken, String());
}
if (!finished() && !consumeCharacter(','))
return false;
return true;
}
void Lexer::recognizeString() {
consumeCharacter();
while (this->currentChar != '"') {
consumeCharacter();
}
consumeCharacter();
pushToken(TokenType::STRING);
}
void Lexer::recognizeCharacter() {
consumeCharacter();
while (this->currentChar != '\'') {
consumeCharacter();
}
consumeCharacter();
pushToken(TokenType::CHARACTER);
}
void Lexer::recognizeIdentifier() {
consumeCharacter();
while ((this->currentChar == '_' || this->currentChar == '-') ||
(this->currentChar >= 'a' && this->currentChar <= 'z') ||
(this->currentChar >= 'A' && this->currentChar <= 'Z') ||
(this->currentChar >= '0' && this->currentChar <= '9')) {
consumeCharacter();
}
pushToken(TokenType::IDENTIFIER);
}
void Lexer::recognizeNumber() {
while (this->currentChar >= '0' && this->currentChar <= '9') {
consumeCharacter();
}
if (this->currentChar == '.') {
consumeCharacter();
}
while (this->currentChar >= '0' && this->currentChar <= '9') {
consumeCharacter();
}
pushToken(TokenType::NUMBER);
}
void recognizeIdentifierToken(Lexer *self) {
consumeCharacter(self);
while (isLetterOrDigit(self->currentChar)) {
consumeCharacter(self);
}
while (isUnderscore(self->currentChar) && isLetterOrDigit(peekAhead(self, 1))) {
consumeCharacter(self);
while (isLetterOrDigit(self->currentChar)) {
consumeCharacter(self);
}
}
pushToken(self, TOKEN_IDENTIFIER);
}
void recognizeOperatorToken(Lexer *self) {
// stop the annoying := treated as an operator
// treat them as individual operators instead.
if (self->currentChar == ':' && peekAhead(self, 1) == '=') {
consumeCharacter(self);
}
else {
consumeCharacter(self);
// for double operators
if (isOperator(self->currentChar)) {
consumeCharacter(self);
}
}
pushToken(self, TOKEN_OPERATOR);
}
void expectCharacter(Lexer *self, char c) {
if (self->currentChar == c) {
consumeCharacter(self);
}
else {
errorMessage("Expected `%c` but found `%c`", c, self->currentChar);
return;
}
}
bool ParseOBJ::maybeReadWhitespace() {
bool changedLines = false;
while (remainingCharacters > 0) {
switch (*nextCharacter) {
case '\n':
case '\r':
{
char c = *nextCharacter;
consumeCharacter();
++m_line;
changedLines = true;
if ((remainingCharacters > 0) && (c != *nextCharacter) &&
((*nextCharacter == '\r') || (*nextCharacter == '\n'))) {
// This is part of a two-character, e.g., Mac or
// Windows. Consume the next character as well.
consumeCharacter();
}
}
break;
case ' ':
case '\t':
// Consume whitespace
consumeCharacter();
break;
case '#':
// Consume comment
readUntilNewline();
// Don't consume the newline; we'll catch it on the next
// iteration
break;
default:
return changedLines;
}
}
return true;
}
void recognizeStringToken(Lexer *self) {
expectCharacter(self, '"');
int errpos = self->charNumber;
int errline = self->lineNumber;
// just consume everthing
while (!isString(self->currentChar)) {
consumeCharacter(self);
if (isEndOfInput(self->currentChar)) {
errorMessageWithPosition(self->fileName, errline, errpos, "Unterminated string literal");
}
}
expectCharacter(self, '"');
pushToken(self, TOKEN_STRING);
}
void recognizeCharacterToken(Lexer *self) {
expectCharacter(self, '\'');
int errpos = self->charNumber;
int errline = self->lineNumber;
if (self->currentChar == '\'')
errorMessageWithPosition(self->fileName, self->lineNumber, self->charNumber, "Empty character literal");
while (!(self->currentChar == '\'' && peekAhead(self, -1) != '\\')) {
consumeCharacter(self);
if (isEndOfInput(self->currentChar)) {
errorMessageWithPosition(self->fileName, errline, errpos, "Unterminated character literal");
}
}
expectCharacter(self, '\'');
pushToken(self, TOKEN_CHARACTER);
}
static bool skipLayoutAndCommentsOnce(Lexer *self) {
while (isLayout(self->currentChar)) {
consumeCharacter(self);
}
while (self->currentChar == '#') {
consumeCharacter(self);
while (!isCommentCloser(self->currentChar)) {
if (isEndOfInput(self->currentChar)) return false;
consumeCharacter(self);
}
while (isLayout(self->currentChar)) {
consumeCharacter(self);
}
return true;
}
// consume a block comment and its contents
if (self->currentChar == '/' && peekAhead(self, 1) == '*') {
// consume new comment symbols
consumeCharacter(self);
consumeCharacter(self);
while (true) {
consumeCharacter(self);
if (isEndOfInput(self->currentChar)) {
errorMessage("Unterminated block comment");
return false;
}
if (self->currentChar == '*' && peekAhead(self, 1) == '/') {
// consume the comment symbols
consumeCharacter(self);
consumeCharacter(self);
// eat layout stuff like space etc
while (isLayout(self->currentChar)) {
consumeCharacter(self);
}
break;
}
}
return true;
}
// consume a single line comment
while ((self->currentChar == '/' && peekAhead(self, 1) == '/')) {
consumeCharacter(self); // eat the /
consumeCharacter(self); // eat the /
while (!isCommentCloser(self->currentChar)) {
if (isEndOfInput(self->currentChar)) return false;
consumeCharacter(self);
}
while (isLayout(self->currentChar)) {
consumeCharacter(self);
}
return true;
}
return false;
}
void recognizeErroneousToken(Lexer *self) {
consumeCharacter(self);
pushToken(self, TOKEN_ERRORNEOUS);
}
void recognizeSeparatorToken(Lexer *self) {
consumeCharacter(self);
pushToken(self, TOKEN_SEPARATOR);
}
void recognizeEndOfLineToken(Lexer *self) {
consumeCharacter(self);
}
void Lexer::recognizeSeparator() {
consumeCharacter();
pushToken(TokenType::SEPARATOR);
}
void recognizeNumberToken(Lexer *self) {
consumeCharacter(self);
if (self->currentChar == '_') { // ignore digit underscores
consumeCharacter(self);
}
if (self->currentChar == '.') {
consumeCharacter(self); // consume dot
while (isDigit(self->currentChar)) {
consumeCharacter(self);
}
if (self->currentChar == 'f' || self->currentChar == 'd') {
consumeCharacter(self);
}
pushToken(self, TOKEN_NUMBER);
}
else if (self->currentChar == 'x' || self->currentChar == 'X') {
consumeCharacter(self);
while (isHexChar(self->currentChar)) {
consumeCharacter(self);
}
pushToken(self, TOKEN_NUMBER);
}
else if (self->currentChar == 'b') {
consumeCharacter(self);
while (isBinChar(self->currentChar)) {
consumeCharacter(self);
}
pushToken(self, TOKEN_NUMBER);
}
else if (self->currentChar == 'o') {
consumeCharacter(self);
while (isOctChar(self->currentChar)) {
consumeCharacter(self);
}
pushToken(self, TOKEN_NUMBER);
}
else {
// it'll do
while (isDigit(self->currentChar)) {
if (peekAhead(self, 1) == '.') {
consumeCharacter(self);
while (isDigit(self->currentChar)) {
consumeCharacter(self);
}
if (self->currentChar == 'f' || self->currentChar == 'd') {
consumeCharacter(self);
}
}
else if (peekAhead(self, 1) == '_') { // ignore digit underscores
consumeCharacter(self);
}
consumeCharacter(self);
}
pushToken(self, TOKEN_NUMBER);
}
}
void recognizeEndOfInputToken(Lexer *self) {
consumeCharacter(self);
pushInitializedToken(self, TOKEN_END_OF_FILE, "<TOKEN_END_OF_FILE>");
}
void Lexer::recognizeOperator() {
consumeCharacter();
pushToken(TokenType::OPERATOR);
}
void ParseOBJ::readFace() {
// Ensure that we have a material
if (isNull(m_currentMaterial)) {
m_currentMaterial = m_currentMaterialLibrary.materialTable["default"];
}
// Ensure that we have a group
if (isNull(m_currentGroup)) {
// Create a group named "default", per the OBJ specification
m_currentGroup = Group::create();
m_currentGroup->name = "default";
groupTable.set(m_currentGroup->name, m_currentGroup);
// We can't have a mesh without a group, but conservatively reset this anyway
m_currentMesh.reset();
}
// Ensure that we have a mesh
if (isNull(m_currentMesh)) {
bool created = false;
shared_ptr<Mesh>& m = m_currentGroup->meshTable.getCreate(m_currentMaterial, created);
if (created) {
m = Mesh::create();
m->material = m_currentMaterial;
}
m_currentMesh = m;
}
Face& face = m_currentMesh->faceArray.next();
const int vertexArraySize = vertexArray.size();
const int texCoordArraySize = texCoord0Array.size();
const int normalArraySize = normalArray.size();
// Consume leading whitespace
bool done = maybeReadWhitespace();
while (! done) {
Index& index = face.next();
// Read index
index.vertex = readInt();
if (index.vertex > 0) {
// Make 0-based
--index.vertex;
} else {
// Negative; make relative to the current end of the array.
// -1 will be the last element, so just add the size of the array.
index.vertex += vertexArraySize;
}
if ((remainingCharacters > 0) && (*nextCharacter == '/')) {
// Read the slash
consumeCharacter();
if (remainingCharacters > 0) {
if (*nextCharacter != '/') {
// texcoord index
index.texCoord = readInt();
if (index.texCoord > 0) {
// Make 0-based
--index.texCoord;
} else {
// Negative; make relative to the current end
// of the array. -1 will be the last element,
// so just add the size of the array.
index.texCoord += texCoordArraySize;
}
}
if ((remainingCharacters > 0) && (*nextCharacter == '/')) {
// Consume the slash
consumeCharacter();
// normal index
index.normal = readInt();
if (index.normal > 0) {
// Make 0-based
--index.normal;
} else {
// Negative; make relative to the current
// end of the array. -1 will be the last
// element, so just add the size of the
// array.
index.normal += normalArraySize;
}
}
}
}
// Read remaining whitespace
done = maybeReadWhitespace();
}
}
ParseOBJ::Command ParseOBJ::readCommand() {
if (remainingCharacters == 0) {
return UNKNOWN;
}
// Explicit finite automata parser
switch (*nextCharacter) {
case 'f':
consumeCharacter();
if (isSpace(*nextCharacter)) {
return FACE;
} else {
return UNKNOWN;
}
break;
case 'v':
consumeCharacter();
switch (*nextCharacter) {
case ' ':
case '\t':
return VERTEX;
case 'n':
consumeCharacter();
if (isSpace(*nextCharacter)) {
return NORMAL;
} else {
return UNKNOWN;
}
break;
case 't':
consumeCharacter();
if (isSpace(*nextCharacter)) {
return TEXCOORD;
} else {
return UNKNOWN;
}
break;
default:
return UNKNOWN;
}
break;
case 'm':
if ((remainingCharacters > 6) && (memcmp(nextCharacter, "mtllib", 6) == 0)) {
nextCharacter += 6; remainingCharacters -= 6;
if (isSpace(*nextCharacter)) {
return MTLLIB;
} else {
return UNKNOWN;
}
} else {
return UNKNOWN;
}
break;
case 'u':
if ((remainingCharacters > 6) && (memcmp(nextCharacter, "usemtl", 6) == 0)) {
nextCharacter += 6; remainingCharacters -= 6;
if (isSpace(*nextCharacter)) {
return USEMTL;
} else {
return UNKNOWN;
}
} else {
return UNKNOWN;
}
break;
case 'g':
consumeCharacter();
if (isSpace(*nextCharacter)) {
return GROUP;
} else {
return UNKNOWN;
}
break;
default:
return UNKNOWN;
}
}
