static bool skipEndOfLine(B& in) { // skip newline AND trailing comment/empty lines if (*in == '\n') ++in; else return false; skipComments(in); return true; }
PackageSPtr ParserMixin::parsePackage(const ParseContextSPtr& context) { TokenizerPtr& tokenizer = context->tokenizer; PackageSPtr pPackage = boost::make_shared<Package>(); initilizeObject(context, pPackage); std::vector<std::string> short_elements; do { tokenizer->shift(); skipComments(context); if ( tokenizer->expect(Token::TYPE_IDENTIFIER) || tokenizer->expect(Token::TYPE_ASTERISK)) { short_elements.push_back(tokenizer->current()->text()); } else { context->mMessageCollector->addMessage(errorMessage(context, Message::p_expectStatementName) << Message::Statement("package")); return PackageSPtr(); } tokenizer->shift(); skipComments(context); } while (tokenizer->expect(Token::TYPE_DOT)); std::vector<std::string> levels_elements; if (tokenizer->check(Token::TYPE_BITWISE_OPERATOR, "|")) { do { tokenizer->shift(); skipComments(context); if ( tokenizer->expect(Token::TYPE_IDENTIFIER) || tokenizer->expect(Token::TYPE_ASTERISK)) { levels_elements.push_back(tokenizer->current()->text()); } else { context->mMessageCollector->addMessage(errorMessage(context, Message::p_expectStatementName) << Message::Statement("package")); return PackageSPtr(); } tokenizer->shift(); skipComments(context); } while (tokenizer->expect(Token::TYPE_DOT)); } else { levels_elements = short_elements; } if (!tokenizer->expect(Token::TYPE_DELIMITER, ";")) { context->mMessageCollector->addMessage(errorMessage(context, Message::p_expectSemicolon)); return PackageSPtr(); } std::vector<PackageElementSPtr> short_; if (!convertStringElementsToPackageElements(context, short_elements, short_)) return PackageSPtr(); std::vector<PackageElementSPtr> levels; if (!convertStringElementsToPackageElements(context, levels_elements, levels)) return PackageSPtr(); pPackage->set_short(short_); pPackage->set_levels(levels); return pPackage; }
bool XMLParser::parse() { if (_stream == 0) return parserError("XML stream not ready for reading."); // Make sure we are at the start of the stream. _stream->seek(0, SEEK_SET); if (_XMLkeys == 0) buildLayout(); while (!_activeKey.empty()) freeNode(_activeKey.pop()); cleanup(); bool activeClosure = false; bool activeHeader = false; bool selfClosure; _state = kParserNeedHeader; _activeKey.clear(); _char = _stream->readByte(); while (_char && _state != kParserError) { if (skipSpaces()) continue; if (skipComments()) continue; switch (_state) { case kParserNeedHeader: case kParserNeedKey: if (_char != '<') { parserError("Parser expecting key start."); break; } if ((_char = _stream->readByte()) == 0) { parserError("Unexpected end of file."); break; } if (_state == kParserNeedHeader) { if (_char != '?') { parserError("Expecting XML header."); break; } _char = _stream->readByte(); activeHeader = true; } else if (_char == '/') { _char = _stream->readByte(); activeClosure = true; } else if (_char == '?') { parserError("Unexpected header. There may only be one XML header per file."); break; } _state = kParserNeedKeyName; break; case kParserNeedKeyName: if (!parseToken()) { parserError("Invalid key name."); break; } if (activeClosure) { if (_activeKey.empty() || _token != _activeKey.top()->name) { parserError("Unexpected closure."); break; } } else { ParserNode *node = allocNode(); //new ParserNode; node->name = _token; node->ignore = false; node->header = activeHeader; node->depth = _activeKey.size(); node->layout = 0; _activeKey.push(node); } _state = kParserNeedPropertyName; break; case kParserNeedPropertyName: if (activeClosure) { if (!closeKey()) { parserError("Missing data when closing key '" + _activeKey.top()->name + "'."); break; } activeClosure = false; if (_char != '>') parserError("Invalid syntax in key closure."); else _state = kParserNeedKey; _char = _stream->readByte(); break; } selfClosure = false; if (_char == '/' || (_char == '?' && activeHeader)) { selfClosure = true; _char = _stream->readByte(); } if (_char == '>') { if (activeHeader && !selfClosure) { parserError("XML Header must be self-closed."); } else if (parseActiveKey(selfClosure)) { _char = _stream->readByte(); _state = kParserNeedKey; } activeHeader = false; break; } if (selfClosure) parserError("Expecting key closure after '/' symbol."); else if (!parseToken()) parserError("Error when parsing key value."); else _state = kParserNeedPropertyOperator; break; case kParserNeedPropertyOperator: if (_char != '=') parserError("Syntax error after key name."); else _state = kParserNeedPropertyValue; _char = _stream->readByte(); break; case kParserNeedPropertyValue: if (!parseKeyValue(_token)) parserError("Invalid key value."); else _state = kParserNeedPropertyName; break; default: break; } } if (_state == kParserError) return false; if (_state != kParserNeedKey || !_activeKey.empty()) return parserError("Unexpected end of file."); return true; }
ImageReaderPNM::ImageReaderPNM(IO::FilePtr sFile) :ImageReader(sFile), done(false) { /* Attach a value source to the file to read the ASCII file header: */ IO::ValueSource header(file); header.skipWs(); /* Read the magic field including the image type indicator: */ int magic=header.getChar(); imageType=header.getChar(); if(magic!='P'||imageType<'1'||imageType>'6') Misc::throwStdErr("Images::ImageReaderPNM: Invalid PNM header"); header.skipWs(); /* Read the image width, height, and maximal pixel component value: */ skipComments(header); imageSpec.size[0]=header.readUnsignedInteger(); if(imageType=='1'||imageType=='4') // PBM files don't have the maxValue field { skipComments(header); header.setWhitespace(""); // Disable all whitespace to read the last header field imageSpec.size[1]=header.readUnsignedInteger(); maxValue=1; } else { skipComments(header); imageSpec.size[1]=header.readUnsignedInteger(); skipComments(header); header.setWhitespace(""); // Disable all whitespace to read the last header field maxValue=header.readUnsignedInteger(); } /* Read the single (whitespace) character separating the header from the image data: */ header.getChar(); /* Fill in the rest of the image specification: */ for(int i=0;i<2;++i) canvasSize[i]=imageSpec.size[i]; imageSpec.offset[0]=imageSpec.offset[1]=0U; switch(imageType) { case '1': // ASCII bitmap case '4': // Binary bitmap imageSpec.colorSpace=Grayscale; imageSpec.hasAlpha=false; imageSpec.numChannels=1; imageSpec.channelSpecs=new ChannelSpec[1]; imageSpec.channelSpecs[0].valueType=UnsignedInt; imageSpec.channelSpecs[0].numFieldBits=1U; imageSpec.channelSpecs[0].numValueBits=1U; break; case '2': // ASCII grayscale image case '5': // Binary grayscale image imageSpec.colorSpace=Grayscale; imageSpec.hasAlpha=false; imageSpec.numChannels=1; imageSpec.channelSpecs=new ChannelSpec[1]; imageSpec.channelSpecs[0].valueType=UnsignedInt; if(maxValue<256U) { /* 8-bit channel width: */ imageSpec.channelSpecs[0].numFieldBits=8U; imageSpec.channelSpecs[0].numValueBits=8U; } else { /* 16-bit channel width: */ imageSpec.channelSpecs[0].numFieldBits=16U; imageSpec.channelSpecs[0].numValueBits=16U; } break; case '3': // ASCII RGB image case '6': // Binary RGB image { imageSpec.colorSpace=RGB; imageSpec.hasAlpha=false; imageSpec.numChannels=3; imageSpec.channelSpecs=new ChannelSpec[3]; for(int i=0;i<3;++i) { imageSpec.channelSpecs[i].valueType=UnsignedInt; if(maxValue<256U) { /* 8-bit channel width: */ imageSpec.channelSpecs[i].numFieldBits=8U; imageSpec.channelSpecs[i].numValueBits=8U; } else { /* 16-bit channel width: */ imageSpec.channelSpecs[i].numFieldBits=16U; imageSpec.channelSpecs[i].numValueBits=16U; } } break; } } }