void ParserMixin::skipComments(const ParseContextSPtr& context, CommentSPtr pComment)
{
if (!pComment)
pComment = parseComment(context);
while (pComment)
{
context->mMessageCollector->addMessage(
warningMessage(context, Message::p_misplacedComment,
pComment->line(), pComment->column()));
pComment = parseComment(context);
}
}
void XMLDocumentParser::parse()
{
while (!isStopped() && !m_parserPaused && !m_stream.atEnd()) {
m_stream.readNext();
switch (m_stream.tokenType()) {
case QXmlStreamReader::StartDocument:
startDocument();
break;
case QXmlStreamReader::EndDocument:
endDocument();
break;
case QXmlStreamReader::StartElement:
parseStartElement();
break;
case QXmlStreamReader::EndElement:
parseEndElement();
break;
case QXmlStreamReader::Characters: {
if (m_stream.isCDATA()) {
//cdata
parseCdata();
} else {
//characters
parseCharacters();
}
break;
}
case QXmlStreamReader::Comment:
parseComment();
break;
case QXmlStreamReader::DTD:
//qDebug()<<"------------- DTD";
parseDtd();
break;
case QXmlStreamReader::EntityReference: {
//qDebug()<<"---------- ENTITY = "<<m_stream.name().toString()
// <<", t = "<<m_stream.text().toString();
if (isXHTMLDocument()) {
QString entity = m_stream.name().toString();
if (!m_leafTextNode)
enterText();
// qDebug()<<" ------- adding entity "<<str;
m_leafTextNode->appendData(decodeNamedEntity(entity), IGNORE_EXCEPTION);
}
break;
}
case QXmlStreamReader::ProcessingInstruction:
parseProcessingInstruction();
break;
default: {
if (m_stream.error() != QXmlStreamReader::PrematureEndOfDocumentError) {
XMLErrors::ErrorType type = (m_stream.error() == QXmlStreamReader::NotWellFormedError) ?
XMLErrors::fatal : XMLErrors::warning;
handleError(type, qPrintable(m_stream.errorString()), textPosition());
}
break;
}
}
}
}
/**
* Get next token.
* @param in Input stream.
* @return Found token.
*/
Parser::token_t Parser::next(io::InStream& in) throw(json::Exception) {
while(true) {
char c = nextChar(in);
switch(c) {
case '{': return LBRACE;
case '}': return RBRACE;
case '[': return LBRACK;
case ']': return RBRACK;
case '\'': parseString(in, '\''); return STRING;
case '\"': parseString(in, '"'); return STRING;
case ':': return COLON;
case ',': return COMMA;
case '\n':
case '\t':
case '\r':
case ' ': break;
case '+':
case '-': return parseNumber(in, c);
case 'n': parseLitt(in, "null"); return _NULL;
case 't': parseLitt(in, "true"); return TRUE;
case 'f': parseLitt(in, "false"); return FALSE;
case '/': parseComment(in); break;
case '0': return parseBasedNumber(in);
default:
if(isNumber(c))
return parseNumber(in, c);
else
error(_ << "bad character '" << c << "' (code = " << int(c) << ")");
}
}
}
void Parser::parseContent (Node * node)
{
bool foundContent = true;
do
{
if (parseCDSection (node))
{
}
else if (parseProcessingInstruction (node))
{
}
else if (parseComment ())
{
}
else if (parseElement (node))
{
}
else if (parseCharData (node))
{
}
else if (current == '&')
node->setData (node->data () + parseReference ());
else
foundContent = false;
}
while (foundContent);
}
/** @see BencSerializer.h */
static int32_t parseDictionary(const struct Reader* reader,
const struct Allocator* allocator,
Dict* output)
{
uint8_t nextChar;
readUntil('{', reader);
String* key;
Object* value;
struct Dict_Entry* entryPointer;
struct Dict_Entry* lastEntryPointer = NULL;
int ret = 0;
for (;;) {
while (!ret) {
ret = reader->read(&nextChar, 0, reader);
switch (nextChar) {
case '"':
break;
case '}':
reader->skip(1, reader);
*output = lastEntryPointer;
return 0;
case '/':
parseComment(reader);
continue;
default:
reader->skip(1, reader);
continue;
}
break;
}
if (ret) {
printf("Unterminated dictionary\n");
return OUT_OF_CONTENT_TO_READ;
}
// Get key and value.
if ((ret = parseString(reader, allocator, &key)) != 0) {
return ret;
}
readUntil(':', reader);
if ((ret = parseGeneric(reader, allocator, &value)) != 0) {
return ret;
}
/* Allocate the entry. */
entryPointer = allocator->malloc(sizeof(struct Dict_Entry), allocator);
entryPointer->next = lastEntryPointer;
entryPointer->key = key;
entryPointer->val = value;
lastEntryPointer = entryPointer;
}
}
Integer ParseNonbondedFile::parse(StringParser *sp)
{
ParseComment parseComment("[#;");
ParseSigmaEpsilonCharge parseSEC;
Units *DU = Units::distanceUnits();
Units *EU = Units::energyUnits();
int NParsed = 0;
do{
sp->skipChars(" \t\n");
if(sp->isOver()) return 1;
if(expectStatement(sp,&parseComment)) continue;
if(!expectStatement(sp,&parseSEC)) return NParsed>0;
SigmaEpsilonCharge sec;
sec.sigma = parseSEC.m_sigma * DU->unit2unit("nm","Angstr");
sec.epsilon = parseSEC.m_epsilon * EU->unit2unit("kJ/mol","kcal/mol");
sec.charge = parseSEC.m_charge;
(*m_ff)[parseSEC.m_atomType] = sec;
NParsed++;
}while(1);
}
bool MorkParser::parseDict()
{
char cur = nextChar();
bool Result = true;
nowParsing_ = NPValues;
while (Result && cur != '>' && cur) {
if (!isWhiteSpace(cur)) {
switch (cur) {
case '<':
if (mMorkData.mid(mMorkPos - 1, strlen(MorkDictColumnMeta))
== MorkDictColumnMeta) {
nowParsing_ = NPColumns;
mMorkPos += strlen(MorkDictColumnMeta) - 1;
}
break;
case '(':
Result = parseCell();
break;
case '/':
Result = parseComment();
break;
}
}
cur = nextChar();
}
return Result;
}
CommentSPtr ParserMixin::lastComment(const ParseContextSPtr& context)
{
TokenizerPtr& tokenizer = context->tokenizer;
CommentSPtr comment = parseComment(context);
while (comment)
{
if (!tokenizer->current())
break;
if (tokenizer->current()->type() != Token::TYPE_COMMENT)
break;
context->mMessageCollector->addMessage(Message::SEVERITY_WARNING, Message::p_misplacedComment,
context->mSourceId, comment->line(), comment->column());
comment = parseComment(context);
}
return comment;
}
void LocationParser_ns::parseExamineData(ZonePtr z) {
TypeData *data = &z->u;
if (!scumm_stricmp(_tokens[0], "file")) {
data->_filename = _tokens[1];
} else
if (!scumm_stricmp(_tokens[0], "desc")) {
data->_examineText = parseComment();
}
}
XMLNode* XMLDecoderUTF8::parseElement()
{
String name;
advance(1);
/* spec says no whitespaces allowd - whatever */
skipWhitespace();
if(!parseName( name))
throw CVTException("Malformed element name");
/* START Tag */
XMLElement* element = new XMLElement( name );
while( _rlen ) {
skipWhitespace();
if( match( "/>" ) ) {
advance( 2 );
return element;
} else if( match( '>' ) ) {
advance( 1 );
break;
} else {
element->addChild( parseAttribute() );
}
}
/* Content */
skipWhitespace();
while( !match("</") ) {
if( match("<?") )
element->addChild( parsePI() );
else if( match("<!--") )
element->addChild( parseComment() );
else if( match("<") )
element->addChild( parseElement() );
else if( match("<![CDATA[") )
element->addChild( parseCData() );
else
element->addChild( parseText() );
skipWhitespace();
}
/* END Tag */
advance( 2 );
/* spec says no whitespaces allowd - whatever */
skipWhitespace();
String ename;
if( ! parseName( ename ) )
throw CVTException("Malformed element name");
if( name != ename )
throw CVTException("Names in start- and end-tag differ");
skipWhitespace();
if( !match('>') )
throw CVTException("Missing '>'");
advance( 1 );
return element;
}
///////////////////////////////////////////////////////////////////////////
//
// Parsing Interface
//
Token *tokenizer_next( Tokenizer *tokenizer ) {
wchar_t c, next;
Token *token = NULL;
next = ss_peek( tokenizer->ss_ );
while ( next != WEOF && !token ) {
// Whitespace
if ( isWhitespaceStart( tokenizer->ss_, 0 ) ) {
token = parseWhitespace( tokenizer );
}
// Strings
else if ( isStringStart( tokenizer->ss_, 0 ) ) {
token = parseString( tokenizer );
}
// Comments
else if ( isCommentStart( tokenizer->ss_, 0 ) ) {
token = parseComment( tokenizer );
}
// URL
else if ( isUrlStart( tokenizer->ss_, 0 ) ) {
token = parseUrl( tokenizer );
}
// SGML Comments
else if ( isSGMLCommentStart( tokenizer->ss_, 0 ) ) {
token = parseSGMLComment( tokenizer );
}
// Identifier
else if ( isIdentifierStart( tokenizer->ss_, 0 ) ) {
token = parseIdentifier( tokenizer );
}
// @keyword
else if ( isAtkeywordStart( tokenizer->ss_, 0 ) ) {
token = parseAtkeyword( tokenizer );
}
// #keyword
else if ( isHashkeywordStart( tokenizer->ss_, 0 ) ) {
token = parseHashkeyword( tokenizer );
}
// Number
else if ( isNumberStart( tokenizer->ss_, 0 ) ) {
token = parseNumber( tokenizer );
}
// Operators & Delims (everything else)
else {
token = parseEverythingElse( tokenizer );
}
}
if ( token ) {
return token;
} else {
return NULL;
}
}
FileSPtr ParserMixin::parseFile(const ParseContextSPtr& context)
{
TokenizerPtr& tokenizer = context->tokenizer;
FileSPtr file = boost::make_shared<File>();
CommentSPtr pComment = parseComment(context);
while (pComment)
{
file->mutable_comments().push_back(pComment);
pComment = parseComment(context);
}
if (!tokenizer->check(Token::TYPE_IDENTIFIER, "compil"))
return FileSPtr();
initilizeObject(context, file);
tokenizer->shift();
if (!tokenizer->expect(Token::TYPE_BRACKET, "{"))
{
*context <<= errorMessage(context, Message::p_expectStatementBody)
<< Message::Statement("compil");
return FileSPtr();
}
tokenizer->shift();
skipComments(context);
if (!tokenizer->expect(Token::TYPE_BRACKET, "}"))
{
*context <<= errorMessage(context, Message::p_unexpectEOFInStatementBody)
<< Message::Statement("compil");
return FileSPtr();
}
tokenizer->shift();
return file;
}
bool Parser::parseMisc( Node *node )
{
if( parseWhitespace() )
return true;
if( parseComment() )
return true;
if( parseProcessingInstruction( node ) )
return true;
return false;
}
bool MorkParser::parse()
{
bool Result = true;
char cur = 0;
// Run over mork chars and parse each term
cur = nextChar();
int i = 0;
while ( Result && cur )
{
if ( !isWhiteSpace( cur ) )
{
i++;
// Figure out what a term
switch ( cur )
{
case '<':
// Dict
Result = parseDict();
break;
case '/':
// Comment
Result = parseComment();
break;
case '{':
Result = parseTable();
// Table
break;
case '[':
Result = parseRow( 0, 0 );
// Row
break;
case '@':
Result = parseGroup();
// Group
break;
default:
error_ = DefectedFormat;
Result = false;
break;
}
}
// Get next char
cur = nextChar();
}
return Result;
}
void stylesheetParser::parse(){
if(!m_stopProcessing){
if(!m_styleSheet.isEmpty()){
if(m_styleSheet.startsWith("/*"))
parseComment();
else if(m_styleSheet.startsWith("@page"))
parseAtRules1();
else if(m_styleSheet.startsWith("@media"))
parseAtRules1();
else if(m_styleSheet.startsWith("@import"))
parseAtRules2();
else if(m_styleSheet.startsWith("@charset"))
parseAtRules2();
else parseSelector();
}
else return;
}
}
void CoedeParser::readFile(std::string file) {
string path = core->getDynacoeDir() + STR(MOD_PATH) + file;
InputBuffer in(path);
if (in.isGood()) {
(*sys) << BeginSys << "Reading script \"" << file
<< "\", " << in.get_Size() <<" B";
} else {
(*sys) << BeginSys << " Error Reading script \"" << path
<< "\"";
return;
}
string script = in.readString(in.get_Size() - 1);
ParserBuffer buffer(script);
string next;
while(!buffer.isEmpty()) {
next = buffer.getNextToken();
if (next == "/") {// potential comment
bool isComment = parseComment(buffer);
if (!isComment) {
currentOperators.push_back(COEDE_OP_DIV);
}
} else if (next == ";") { // end of operation queue, start processing operations
currentOperands.clear();
currentOperators.clear();
}
}
}
XMLNode* XMLDecoderUTF8::parseNode()
{
skipWhitespace();
if( !_rlen || match( ( uint8_t ) 0 ) )
return NULL;
if( match("<?") )
return parsePI();
if( match("<!--") )
return parseComment();
if( match("<") )
return parseElement();
else {
std::cout << "'" << *_stream << "'" << std::endl;
std::cout << "'" << *( _stream + 1 ) << "'" << std::endl;
throw CVTException("Invalid XML data");
}
if( !match('<') )
throw CVTException("Malformed element - expected \"<\"");
advance( 1 );
}
void RenJS::parseParam(const CString& strParam, RenJS::Node& node)
{
int index = strParam.Find("=");
CString strKey(strParam.Left(index));
CString strValue(strParam.Right(strParam.GetLength() - 1 - index));
if (strKey == "i")
{
parseId(strValue, node);
}
else if (strKey == "p")
{
parseCoordinate(strValue, node);
}
else if (strKey == "m")
{
parseNumber(strValue, node);
}
else if (strKey == "f")
{
parseParent(strValue, node);
}
else if (strKey == "c")
{
parseChildren(strValue, node);
}
else if (strKey == "co")
{
parseComment(strValue, node);
}
else if (strKey == "k")
{
parseBoardText(strValue, node);
}
}
/**
@brief Controls the meat of the processing.
Basically a state machine, which accumulates the incoming
stream of characters and chops them up into meaningful
chunks, then passes those chunks off to other routines
to further process and output.
@param[in] inFile the file to process
@param[out] outFile where to write the result
@return int
@retval 0 everything went smoothly
@retval -108 unable to allocate memory
*/
int processFile(FILE *outFile, FILE *inFile)
{
tBuffer *buf;
int prevc, c, nextc; /* needs to be int to hold EOF */
int depthCurly,depthRound;
bool inComment, inCppComment;
bool inPreprocessor;
bool inSingleQuotes, inDoubleQuotes;
bool inBetween, isLiteral, isChar1;
bool atStart, doFlush;
buf = (tBuffer *)malloc(sizeof(tBuffer));
if (buf == NULL)
{
fprintf(stderr,
"### error: unable to allocate a buffer\n");
return (-108);
}
initBuffer(buf,outFile);
depthCurly = 0;
depthRound = 0;
isLiteral = false;
inComment = false;
inCppComment = false;
inPreprocessor = false;
inSingleQuotes = false;
inDoubleQuotes = false;
atStart = true;
inBetween = true;
isChar1 = true;
doFlush = false;
prevc = '\0';
c = fgetc(inFile);
while (c != EOF)
{
nextc = fgetc(inFile);
/*
the main state machine
*/
if (isLiteral)
{
/* normally the 'literal' is a single character.
but in the odd case of DOS cr/lf pairs, they
should be treated as one logical character */
if ((c != '\r' || nextc != '\n')
&& (c != '\n' || nextc != '\r'))
{
isLiteral = false;
}
}
else if (inComment)
{
if (inCppComment)
{
if (c == '\n' || c == '\r')
{
inCppComment = false;
inComment = false;
inPreprocessor = false;
isChar1 = true;
if (depthCurly == 0)
{
buf->description.end = buf->ptr;
++buf->description.count;
if (buf->fileComment)
{
flushBuffer(buf);
buf->fileComment = false;
}
}
else
{
parseComment(buf);
}
}
}
else
{
if (prevc == '*' && c == '/')
{
inComment = false;
if (depthCurly == 0)
{
buf->description.end = buf->ptr + 1;
++buf->description.count;
if (buf->fileComment)
{
doFlush = true;
}
}
else
{
parseComment(buf);
}
}
}
}
else if (inPreprocessor)
{
switch (c)
{
case '\n':
case '\r':
if (inCppComment)
{
inCppComment = false;
inComment = false;
if (depthCurly == 0)
{
buf->description.end = buf->ptr;
++buf->description.count;
}
else
{
parseComment(buf);
}
}
if (depthCurly == 0 && !inComment)
{
doFlush = true;
}
inPreprocessor = false;
isChar1 = true;
break;
case '/':
switch (nextc)
{
case '/':
inCppComment = true;
/* fall through */
case '*':
inComment = true;
break;
}
if (inComment)
{
if (depthCurly == 0)
{
flushBuffer(buf);
buf->description.start = buf->ptr;
}
else
{
buf->commentStart = buf->ptr;
}
}
break;
}
}
else if (inSingleQuotes)
{
switch (c)
{
case '\'':
inSingleQuotes = false;
break;
case '\\':
isLiteral = true;
break;
}
}
else if (inDoubleQuotes)
{
switch (c)
{
case '"':
inDoubleQuotes = false;
break;
case '\\':
isLiteral = true;
break;
}
}
else {
switch (c)
{
case '\\':
isLiteral = true;
break;
case '/':
switch (nextc)
{
case '*':
inComment = true;
break;
case '/':
inCppComment = true;
inComment = true;
break;
}
if (inComment)
{
if (depthCurly == 0)
{
flushBuffer(buf);
buf->description.start = buf->ptr;
}
else
{
buf->commentStart = buf->ptr;
}
}
break;
case '#':
/* is this the first non-whitepace char on the line? */
if (isChar1)
{
if (depthCurly == 0)
{
/* if there was a comment preceeding this pre-
processor directive, it wasn't a description */
buf->description.count = 0;
buf->description.start = NULL;
buf->description.end = NULL;
}
inPreprocessor = true;
}
break;
case '\'':
inSingleQuotes = true;
break;
case '"':
inDoubleQuotes = true;
break;
case '(':
if (depthCurly == 0 && depthRound == 0)
{
buf->function.end = buf->ptr;
++buf->function.count;
buf->arglist.start = buf->ptr;
}
++depthRound;
break;
case ')':
--depthRound;
if (depthCurly == 0 && depthRound == 0)
{
buf->arglist.end = buf->ptr + 1;
++buf->arglist.count;
}
break;
case '{':
if (depthCurly == 0)
{
buf->body.start = buf->ptr;
}
else
parseStatement(buf);
++depthCurly;
inBetween = true;
break;
case '}':
--depthCurly;
if (depthCurly == 0)
{
buf->body.end = buf->ptr + 1;
++buf->body.count;
doFlush = true;
}
else
parseStatement(buf);
inBetween = true;
break;
case ';':
if (depthCurly == 0)
doFlush = true;
else
parseStatement(buf);
inBetween = true;
break;
case '\n':
case '\r':
isChar1 = true;
break;
default:
if (inBetween && !isspace(c))
{
if (depthCurly == 0)
buf->function.start = buf->ptr;
else
buf->statementStart = buf->ptr;
inBetween = false;
}
break;
}
}
/* check the first non-whitespace characters to see if
it's the start of a comment. If so, assume it's the
file's header comment and flag to handle it specially */
if (atStart && !isspace(c))
{
atStart = false;
if (inComment)
{
/* set flag to act at the end of the comment */
buf->fileComment = true;
}
else
{
/* it's not a comment, so insert a new file comment */
newFileComment(buf);
}
}
if (emitChar(buf, c) != 0)
{
/* buffer overflowed! hopefully this won't
happen very often... no choice but to flush */
doFlush = true;
}
if (doFlush)
{
doFlush = false;
flushBuffer(buf);
buf->fileComment = false;
}
/* if the currect character isn't whitespace, we're
not at the first character of the line any more. */
if (isChar1 && !isspace(c))
isChar1 = false;
prevc = c;
c = nextc;
} /* end while */
/* flush whatever may be left in the buffer */
flushBuffer(buf);
free(buf);
return 0;
}
bool
parseShaderComments(gfd::GFDVertexShader &shader,
std::vector<std::string> &comments)
{
for (auto &comment : comments) {
CommentKeyValue kv;
if (!parseComment(comment, kv)) {
continue;
}
std::transform(kv.obj.begin(), kv.obj.end(), kv.obj.begin(), ::toupper);
std::transform(kv.member.begin(), kv.member.end(), kv.member.begin(), ::toupper);
if (kv.obj == "SQ_PGM_RESOURCES_VS") {
ensureObject(kv);
parseRegisterValue(shader.regs.sq_pgm_resources_vs, kv.member, kv.value);
} else if (kv.obj == "VGT_PRIMITIVEID_EN") {
ensureObject(kv);
parseRegisterValue(shader.regs.vgt_primitiveid_en, kv.member, kv.value);
} else if (kv.obj == "SPI_VS_OUT_CONFIG") {
ensureObject(kv);
parseRegisterValue(shader.regs.spi_vs_out_config, kv.member, kv.value);
} else if (kv.obj == "NUM_SPI_VS_OUT_ID") {
ensureValue(kv);
shader.regs.num_spi_vs_out_id = parseValueNumber(kv.value);
} else if (kv.obj == "SPI_VS_OUT_ID") {
ensureArrayOfObjects(kv);
parseRegisterValue(shader.regs.spi_vs_out_id, std::stoul(kv.index), kv.member, kv.value);
} else if (kv.obj == "PA_CL_VS_OUT_CNTL") {
ensureObject(kv);
parseRegisterValue(shader.regs.pa_cl_vs_out_cntl, kv.member, kv.value);
} else if (kv.obj == "SQ_VTX_SEMANTIC_CLEAR") {
ensureValue(kv);
shader.regs.sq_vtx_semantic_clear = shader.regs.sq_vtx_semantic_clear
.CLEAR(parseValueNumber(kv.value));
} else if (kv.obj == "NUM_SQ_VTX_SEMANTIC") {
ensureValue(kv);
shader.regs.num_sq_vtx_semantic = parseValueNumber(kv.value);
} else if (kv.obj == "SQ_VTX_SEMANTIC") {
ensureArrayOfObjects(kv);
parseRegisterValue(shader.regs.sq_vtx_semantic, std::stoul(kv.index), kv.member, kv.value);
} else if (kv.obj == "VGT_STRMOUT_BUFFER_EN") {
ensureObject(kv);
parseRegisterValue(shader.regs.vgt_strmout_buffer_en, kv.member, kv.value);
} else if (kv.obj == "VGT_VERTEX_REUSE_BLOCK_CNTL") {
ensureObject(kv);
parseRegisterValue(shader.regs.vgt_vertex_reuse_block_cntl, kv.member, kv.value);
} else if (kv.obj == "VGT_HOS_REUSE_DEPTH") {
ensureObject(kv);
parseRegisterValue(shader.regs.vgt_hos_reuse_depth, kv.member, kv.value);
} else if (kv.obj == "ATTRIB_VARS") {
ensureArrayOfObjects(kv);
parseAttribVars(shader.attribVars, std::stoul(kv.index), kv.member, kv.value);
} else if (kv.obj == "MODE") {
ensureValue(kv);
shader.mode = parseShaderMode(kv.value);
} else if (kv.obj == "RING_ITEM_SIZE") {
ensureValue(kv);
shader.ringItemSize = parseValueNumber(kv.value);
} else if (kv.obj == "HAS_STREAM_OUT") {
ensureValue(kv);
shader.hasStreamOut = parseValueBool(kv.value);
} else if (kv.obj == "STREAM_OUT_STRIDE") {
ensureArrayOfValues(kv);
auto index = std::stoul(kv.index);
if (index >= shader.streamOutStride.size()) {
throw gfd_header_parse_exception { fmt::format("STREAM_OUT_STRIDE[{}] invalid index, max: {}", index, shader.streamOutStride.size()) };
}
shader.streamOutStride[index] = parseValueNumber(kv.value);
} else {
throw gfd_header_parse_exception { fmt::format("Unknown key {}", kv.obj) };
}
/*
TODO:
std::vector<GFDUniformBlock> uniformBlocks;
std::vector<GFDUniformVar> uniformVars;
std::vector<GFDUniformInitialValue> initialValues;
std::vector<GFDLoopVar> loopVars;
std::vector<GFDSamplerVar> samplerVars;
GFDRBuffer gx2rData;
*/
}
return true;
}
static UXMLNODE parseElement(struct UXMLPARSER *parser, UXMLNODE parent, int *type)
{
UXMLNODE node;
UXMLCHAR *name = parser->offset;
size_t nameLength;
int isEmpty;
if (!skipName(parser))
{
setError(parser, 0, "Unexpected end of input parsing stag name");
return NULL;
}
nameLength = (parser->offset - name);
switch (*name)
{
case '!':
{
if (stringCompare(name, "![CDATA[", 8))
{
*type = UXML_NT_CDATA;
return parseCDATA(parser, parent);
}
else if (stringCompare(name, "!--", 3))
{
*type = UXML_NT_COMMENT;
return parseComment(parser, parent);
}
else if (stringCompare(name, "!DOCTYPE", 8))
{
*type = UXML_NT_DOCTYPE;
return parseDocType(parser, parent);
}
else
{
setError(parser, 0, "Unexpected ! tag");
return NULL;
}
break;
}
case '?':
{
if (stringCompare(name, "?xml", 4))
{
*type = UXML_NT_PROLOG;
return parseProlog(parser, parent);
}
else
{
setError(parser, 0, "Unexpected prolog tag");
return NULL;
}
break;
}
default:
{
*type = UXML_NT_ELEMENT;
node = parser->createElement(parser, parent, name, nameLength);
if (!parseAttributes(parser, node, &isEmpty))
{
goto ERROR_DESTROY_NODE;
}
if (isEmpty)
{
parser->offset ++;
if (*(parser->offset) != '>')
{
setError(parser, 0, "Unexpected end of input parsing stag name");
goto ERROR_DESTROY_NODE;
}
parser->offset ++;
}
else
{
parser->offset ++;
if (!parseContent(parser, node, name, nameLength))
{
goto ERROR_DESTROY_NODE;
}
}
break;
}
}
return node;
ERROR_DESTROY_NODE:
parser->destroyNode(parser, node);
return NULL;
}
static int32_t parseGeneric(const struct Reader* reader,
const struct Allocator* allocator,
Object** output)
{
int ret = 0;
char firstChar;
for (;;) {
ret = reader->read(&firstChar, 0, reader);
switch (firstChar) {
case ' ':
case '\r':
case '\n':
case '\t':
reader->skip(1, reader);
continue;
case '/':;
if ((ret = parseComment(reader)) != 0) {
return ret;
}
continue;
default:
break;
}
if (ret) {
printf("Unexpected end of input\n");
return OUT_OF_CONTENT_TO_READ;
}
break;
}
Object* out = allocator->malloc(sizeof(Object), allocator);
switch (firstChar) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':;
// int64_t. Int is special because it is not a pointer but a int64_t.
int64_t bint;
ret = parseint64_t(reader, &bint);
out->type = Object_INTEGER;
out->as.number = bint;
break;
case '[':;
// List.
List* list = allocator->calloc(sizeof(List), 1, allocator);
ret = parseList(reader, allocator, list);
out->type = Object_LIST;
out->as.list = list;
break;
case '{':;
// Dictionary
Dict* dict = allocator->calloc(sizeof(Dict), 1, allocator);
ret = parseDictionary(reader, allocator, dict);
out->type = Object_DICT;
out->as.dictionary = dict;
break;
case '"':;
// String
String* string = NULL;
ret = parseString(reader, allocator, &string);
out->type = Object_STRING;
out->as.string = string;
break;
default:
printf("While looking for something to parse: "
"expected one of 0 1 2 3 4 5 6 7 8 9 [ { \", found '%c'\n", firstChar);
return UNPARSABLE;
}
if (ret != 0) {
// Something went wrong while parsing.
return ret;
}
*output = out;
return 0;
}
PgnStream::TokenType PgnStream::readNext()
{
if (m_phase == OutOfGame)
return NoToken;
m_tokenType = NoToken;
m_tokenString.clear();
char c;
while ((c = readChar()) != 0)
{
switch (c)
{
case ' ':
case '\t':
case '\n':
case '\r':
case '.':
break;
case '%':
// Escape mechanism (skip this line)
parseUntil("\n\r");
m_tokenString.clear();
break;
case '[':
if (m_phase != InTags)
{
rewindChar();
m_phase = OutOfGame;
return NoToken;
}
m_tokenType = PgnTag;
parseTag();
return m_tokenType;
case '(':
case '{':
m_tokenType = PgnComment;
parseComment(c);
return m_tokenType;
case ';':
m_tokenType = PgnLineComment;
parseUntil("\n\r");
return m_tokenType;
case '$':
// NAG (Numeric Annotation Glyph)
m_tokenType = PgnNag;
parseUntil(" \t\n\r");
return m_tokenType;
case '*':
// Unfinished game
m_tokenType = PgnResult;
m_tokenString = "*";
m_phase = OutOfGame;
return m_tokenType;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9': case '0':
// Move number or result
m_tokenString.append(c);
parseUntil(". \t\n\r");
if (m_tokenString == "1-0"
|| m_tokenString == "0-1"
|| m_tokenString == "1/2-1/2")
{
m_tokenType = PgnResult;
m_phase = OutOfGame;
}
else
{
if (m_tokenString.endsWith('.'))
m_tokenString.chop(1);
m_tokenType = PgnMoveNumber;
m_phase = InGame;
}
return m_tokenType;
default:
m_tokenType = PgnMove;
m_tokenString.append(c);
parseUntil(" \t\n\r");
m_phase = InGame;
return m_tokenType;
}
}
return NoToken;
}
/** @see BencSerializer.h */
static int32_t parseList(const struct Reader* reader,
const struct Allocator* allocator,
List* output)
{
char nextChar;
readUntil('[', reader);
Object* element;
struct List_Item* thisEntry = NULL;
struct List_Item** lastEntryPointer = output;
int ret;
for (;;) {
for (;;) {
if (reader->read(&nextChar, 0, reader) != 0) {
printf("Unterminated list\n");
return OUT_OF_CONTENT_TO_READ;
}
if (nextChar == '/') {
if ((ret = parseComment(reader)) != 0) {
return ret;
}
continue;
}
switch (nextChar) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '[':
case '{':
case '"':
break;
case ']':
reader->skip(1, reader);
return 0;
default:
// FIXME: silently skipping anything we don't understand
// might not be the best idea
reader->skip(1, reader);
continue;
}
break;
}
if ((ret = parseGeneric(reader, allocator, &element)) != 0) {
return ret;
}
thisEntry = allocator->malloc(sizeof(struct List_Item), allocator);
thisEntry->elem = element;
thisEntry->next = NULL;
// Read backwards so that the list reads out forward.
*lastEntryPointer = thisEntry;
lastEntryPointer = &(thisEntry->next);
}
}
int main(int argc, char *argv[])
{
int i;
int fd;
int ret;
int c;
const char *device;
const char *script_file;
int num_args = 0;
int args[MAX_COMMAND_ARGS];
char *line, *cmd, *arg;
while ((c = getopt (argc, argv, "t")) != -1) {
if (c=='t') {
print_actions = 1;
} else {
fprintf(stderr, "Unknown option: -%c\n", c);
}
}
if((argc - optind) != 2) {
fprintf(stderr, "Usage: %s [options] <device> <script file>\n\n"
"Options:\n"
" -t print event timings\n", argv[0]);
return 1;
}
device = argv[optind];
script_file = argv[optind + 1];
fd = open(device, O_RDWR);
if(fd < 0) {
fprintf(stderr, "could not open %s, %s\n", device, strerror(errno));
return 1;
}
uint32_t device_flags = figure_out_events_device_reports(fd);
FILE *f = fopen(script_file, "r");
if (!f) {
printf("Unable to read file %s", script_file);
return 1;
}
line = malloc(sizeof(char)*MAX_COMMAND_LEN);
int lineCount = 0;
while (fgets(line, MAX_COMMAND_LEN, f) != NULL) {
// Remove end-of-line comments.
char *comment = strstr(line, "#");
if (comment != NULL)
*comment = '\0';
lineCount += 1;
int hasNextCmd = 1;
char *tempLine = line;
commandLoop:
while (hasNextCmd) {
num_args = 0;
hasNextCmd = 0;
int errCode = 0;
// Parse {-} comments before command names.
do {
if ((cmd = strtok(tempLine, " \n")) == NULL)
goto commandLoop;
tempLine = NULL;
} while ((errCode = parseComment(cmd, lineCount)) == 1);
if (errCode < 0)
return 1;
while ((arg = strtok(NULL, " \n")) != NULL) {
// Parse comment {-} within arguments.
if ((errCode = parseComment(arg, lineCount)) != 0) {
if (errCode < 0)
return 1;
continue;
}
// If we enter a new command, we remember the position for the next iteration.
if (*arg == ';') {
hasNextCmd = 1;
break;
}
assert(num_args < MAX_COMMAND_ARGS);
args[num_args] = atoi(arg);
num_args++;
}
if (strcmp(cmd, "tap") == 0) {
checkArguments(cmd, num_args, 4, lineCount);
execute_tap(fd, device_flags, args[0], args[1], args[2], args[3]);
} else if (strcmp(cmd, "drag") == 0) {
checkArguments(cmd, num_args, 6, lineCount);
execute_drag(fd, device_flags, args[0], args[1], args[2],
args[3], args[4], args[5]);
} else if (strcmp(cmd, "sleep") == 0) {
checkArguments(cmd, num_args, 1, lineCount);
execute_sleep(args[0]);
} else if (strcmp(cmd, "pinch") == 0) {
checkArguments(cmd, num_args, 10, lineCount);
execute_pinch(fd, device_flags, args[0], args[1], args[2],
args[3], args[4], args[5], args[6], args[7], args[8],
args[9]);
} else if (strcmp(cmd, "keyup") == 0) {
checkArguments(cmd, num_args, 1, lineCount);
execute_keyup(fd, args[0]);
} else if (strcmp(cmd, "keydown") == 0) {
checkArguments(cmd, num_args, 1, lineCount);
execute_keydown(fd, args[0]);
} else {
printf("Unrecognized command at line %d: '%s'\n", lineCount, cmd);
return 1;
}
}
}
free(line);
return 0;
}
// parses the header, ie processing instructions and doctype tag
/// \todo parse <!doctype> tag
bool Parser::parseHeader(Document& doc, ContextPtr& context)
{
while(true)
{
++mTokenizer;
Token token1 = *mTokenizer;
if (token1 != '<')
{
throw CPPDOM_ERROR(xml_opentag_expected, "");
}
// token after opening < is a literal?
mTokenizer++;
Token token2 = *mTokenizer;
if (!token2.isLiteral())
{
// generic string encountered: assume no pi and doctype tags
mTokenizer.putBack();
mTokenizer.putBack(token1);
return false;
}
// now check for the literal
switch(token2.getLiteral())
{
// comment or doctype tag
case '!':
{
++mTokenizer;
Token token3 = *mTokenizer;
if (!token3.isLiteral())
{
// now a doctype tag or a comment may follow
if (token3.getGeneric().at(0) == '-' &&
token3.getGeneric().at(1) == '-')
{
// needed to correctly handle <!---->
Token temp_token(token3.getGeneric().substr(2));
mTokenizer.putBack(temp_token);
parseComment(context);
}
else
{
std::string doctypestr(token3.getGeneric());
std::transform(doctypestr.begin(), doctypestr.end(), doctypestr.begin(), toupper);
if (doctypestr == "DOCTYPE")
{
// \todo parse doctype tag
// read the complete tag till the closing >
while (*(mTokenizer++) != '>');
}
else
{
throw CPPDOM_ERROR(xml_unknown, "");
}
}
}
else
{
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
}
break;
}
case '?':
{
++mTokenizer;
Token token3 = *mTokenizer;
if (token3.isLiteral())
{
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
}
// parse processing instruction
Node pinode(context);
std::string tagname(token3.getGeneric());
pinode.mNodeNameHandle = context->insertTagname(tagname);
#ifdef CPPDOM_DEBUG
pinode.mNodeName_debug = tagname;
#endif
parseAttributes(pinode.attrib());
NodePtr nodeptr(new Node(pinode));
doc.mProcInstructions.push_back(nodeptr);
if (context->hasEventHandler())
{
context->getEventHandler().processingInstruction(pinode);
}
++mTokenizer;
if (*mTokenizer != '?')
{
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
}
++mTokenizer;
if (*mTokenizer != '>')
{
throw CPPDOM_ERROR(xml_closetag_expected, "");
}
break;
}
default:
// unknown literal encountered
throw CPPDOM_ERROR(xml_pi_doctype_expected, "");
} // end switch
} // end while
}
UINT CLiteHTMLReader::parseDocument(void)
{
ASSERT(m_lpszBuffer != NULL);
bool bAbort = false; // continue parsing or abort?
bool bIsClosingTag = false; // tag parsed is a closing tag?
bool bIsOpeningTag = false; // tag parsed is an opening tag?
CString strCharacters; // character data
CString strComment; // comment data
CString strT; // temporary storage
DWORD dwCharDataStart = 0L; // starting position of character data
DWORD dwCharDataLen = 0L; // length of character data
LONG lTemp = 0L; // temporary storage
TCHAR ch = 0; // character at current buffer position
CLiteHTMLTag oTag; // tag information
if ( (!m_lpszBuffer) || (!m_dwBufLen) )
return (0U);
// reset seek pointer to beginning
ResetSeekPointer();
// notify event handler about parsing startup
if (getEventNotify(notifyStartStop))
{
bAbort = false;
m_pEventHandler->BeginParse(m_dwAppData, bAbort);
if (bAbort) goto LEndParse;
}
// skip leading white-space characters
while (isWhiteSpace(ReadChar()))
;
ch = UngetChar();
while ((ch = ReadChar()) != NULL)
{
switch (ch)
{
// tag starting delimeter?
case _T('<'):
{
UngetChar();
strComment.Empty();
if (!parseComment(strComment))
{
bIsOpeningTag = false;
bIsClosingTag = false;
if (!parseTag(oTag, bIsOpeningTag, bIsClosingTag))
{
++dwCharDataLen;
// manually advance buffer position
// because the last call to UngetChar()
// moved it back one character
ch = ReadChar();
break;
}
}
// clear pending notifications
if ( (dwCharDataLen) || (strCharacters.GetLength()) )
{
strCharacters += CString(&m_lpszBuffer[dwCharDataStart], dwCharDataLen);
NormalizeCharacters(strCharacters);
if ( (strCharacters.GetLength()) &&
(getEventNotify(notifyCharacters)) )
{
bAbort = false;
m_pEventHandler->Characters(strCharacters, m_dwAppData, bAbort);
if (bAbort) goto LEndParse;
}
strCharacters.Empty();
}
dwCharDataLen = 0L;
dwCharDataStart = m_dwBufPos;
if (strComment.GetLength())
{
if (getEventNotify(notifyComment))
{
bAbort = false;
m_pEventHandler->Comment(strComment, m_dwAppData, bAbort);
if (bAbort) goto LEndParse;
}
}
else
{
if ( (bIsOpeningTag) && (getEventNotify(notifyTagStart)) )
{
bAbort = false;
m_pEventHandler->StartTag(&oTag, m_dwAppData, bAbort);
if (bAbort) goto LEndParse;
}
if ( (bIsClosingTag) && (getEventNotify(notifyTagEnd)) )
{
bAbort = false;
m_pEventHandler->EndTag(&oTag, m_dwAppData, bAbort);
if (bAbort) goto LEndParse;
}
}
break;
}
// entity reference beginning delimeter?
case _T('&'):
{
UngetChar();
lTemp = 0;
if (m_bResolveEntities)
lTemp = CLiteHTMLEntityResolver::resolveEntity(&m_lpszBuffer[m_dwBufPos], ch);
if (lTemp)
{
strCharacters += CString(&m_lpszBuffer[dwCharDataStart], dwCharDataLen) + ch;
m_dwBufPos += lTemp;
dwCharDataStart = m_dwBufPos;
dwCharDataLen = 0L;
}
else
{
ch = ReadChar();
++dwCharDataLen;
}
break;
}
// any other character
default:
{
++dwCharDataLen;
break;
}
}
}
// clear pending notifications
if ( (dwCharDataLen) || (strCharacters.GetLength()) )
{
strCharacters += CString(&m_lpszBuffer[dwCharDataStart], dwCharDataLen) + ch;
NormalizeCharacters(strCharacters);
strCharacters.TrimRight(); // explicit trailing white-space removal
if ( (strCharacters.GetLength()) &&
(getEventNotify(notifyCharacters)) )
{
bAbort = false;
m_pEventHandler->Characters(strCharacters, m_dwAppData, bAbort);
if (bAbort) goto LEndParse;
}
}
LEndParse:
// notify event handler about parsing completion
if (getEventNotify(notifyStartStop))
m_pEventHandler->EndParse(m_dwAppData, bAbort);
m_lpszBuffer = NULL;
m_dwBufLen = 0L;
return (m_dwBufPos);
}
void XMLDocumentParser::parse()
{
while (!isStopped() && !m_parserPaused && !m_stream.atEnd()) {
m_stream.readNext();
switch (m_stream.tokenType()) {
case QXmlStreamReader::StartDocument: {
startDocument();
}
break;
case QXmlStreamReader::EndDocument: {
endDocument();
}
break;
case QXmlStreamReader::StartElement: {
#if ENABLE(XHTMLMP)
if (document()->isXHTMLMPDocument() && !m_hasDocTypeDeclaration) {
handleError(fatal, "DOCTYPE declaration lost.", lineNumber(), columnNumber());
break;
}
#endif
parseStartElement();
}
break;
case QXmlStreamReader::EndElement: {
parseEndElement();
}
break;
case QXmlStreamReader::Characters: {
if (m_stream.isCDATA()) {
//cdata
parseCdata();
} else {
//characters
parseCharacters();
}
}
break;
case QXmlStreamReader::Comment: {
parseComment();
}
break;
case QXmlStreamReader::DTD: {
//qDebug()<<"------------- DTD";
parseDtd();
#if ENABLE(XHTMLMP)
m_hasDocTypeDeclaration = true;
#endif
}
break;
case QXmlStreamReader::EntityReference: {
//qDebug()<<"---------- ENTITY = "<<m_stream.name().toString()
// <<", t = "<<m_stream.text().toString();
if (isXHTMLDocument()
#if ENABLE(XHTMLMP)
|| isXHTMLMPDocument()
#endif
) {
QString entity = m_stream.name().toString();
UChar c = decodeNamedEntity(entity.toUtf8().constData());
if (!m_currentNode->isTextNode())
enterText();
ExceptionCode ec = 0;
String str(&c, 1);
// qDebug()<<" ------- adding entity "<<str;
static_cast<Text*>(m_currentNode)->appendData(str, ec);
}
}
break;
case QXmlStreamReader::ProcessingInstruction: {
parseProcessingInstruction();
}
break;
default: {
if (m_stream.error() != QXmlStreamReader::PrematureEndOfDocumentError) {
ErrorType type = (m_stream.error() == QXmlStreamReader::NotWellFormedError) ?
fatal : warning;
handleError(type, qPrintable(m_stream.errorString()), lineNumber(),
columnNumber());
}
}
break;
}
}
}
void Letterbox::loadFile()
{
if (m_filename.isEmpty())
return;
QString filename(m_filename.right(m_filename.length() - m_filename.lastIndexOf("/") - 1));
statusBar()->showMessage(tr("Loading %1...").arg(filename));
qApp->processEvents();
m_list.clear();
m_answers.clear();
m_clueResults.clear();
QFile file(m_filename);
if (!file.exists())
{
QMessageBox::critical(this, tr("Error Loading Letterbox List - Quackle Letterbox"), tr("Filename %1 does not exist").arg(m_filename));
return;
}
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
QMessageBox::critical(this, tr("Error Loading Letterbox List - Quackle Letterbox"), tr("%1 cannot be opened.").arg(filename));
return;
}
int startAt = 0;
QTextStream stream(&file);
QString line;
m_initializationChuu = true;
bool firstLine = true;
while (!stream.atEnd())
{
line = stream.readLine().trimmed().toUpper();
if (firstLine)
{
if (line.left(10) == "\" RESUME: ")
startAt = line.right(line.length() - 10).toInt();
firstLine = false;
}
line.remove('#');
QString letters = line;
QString comment;
int quoteMarkIndex = line.indexOf("\"");
if (quoteMarkIndex >= 0)
{
letters = line.left(quoteMarkIndex).trimmed();
comment = line.right(line.length() - quoteMarkIndex - 1).trimmed();
}
if (letters.isEmpty())
continue;
m_list += letters;
m_clueResults.append(parseComment(comment));
m_clueResults.last().clue = clueFor(letters);
}
file.close();
if (!dictCheck())
return;
jumpTo(startAt);
statusBar()->showMessage(tr("Loaded list `%1' of length %2.").arg(filename).arg(m_clueResults.count()));
setCaption(filename);
m_initializationChuu = false;
setModified(false);
prepareQuiz();
pause(true);
}
