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;
}
}
}
