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);
}
bool Parser::parseAttributeValue( std::string &attValue )
{
if( !isInSet( "\"'", current ) )
return false;
char quoteChar = current;
std::string value;
readChar( false );
while( current != quoteChar )
{
if( current == '<' )
reportError( "Invalid character '<' in attribute value" );
else if( current == '&' )
current = parseReference();
value += current;
readChar( false );
}
attValue = value;
readChar( false ); // Skip Quote
return true;
}
void Document::_processInlineHtmlAndReferences() {
TokenGroup processed;
token::Container *tokens=dynamic_cast<token::Container*>(mTokenContainer.get());
assert(tokens!=0);
for (TokenGroup::const_iterator ii=tokens->subTokens().begin(),
iie=tokens->subTokens().end(); ii!=iie; ++ii)
{
if ((*ii)->text()) {
if (processed.empty() || processed.back()->isBlankLine()) {
optional<TokenPtr> inlineHtml=parseInlineHtml(ii, iie);
if (inlineHtml) {
processed.push_back(*inlineHtml);
if (ii==iie) break;
continue;
}
}
if (parseReference(ii, iie, *mIdTable)) {
if (ii==iie) break;
continue;
}
// If it gets down here, just store it in its current (raw text)
// form. We'll group the raw text lines into paragraphs in a
// later pass, since we can't easily tell where paragraphs
// end until then.
}
processed.push_back(*ii);
}
tokens->swapSubtokens(processed);
}
void BaseEntityParser::parse()
{
while(! text.eof()){
if (*text == '&') {
parseReference();
} else {
parsePureText();
}
}
}
Object * parseRange(Collector * c, Tokenizer * tt, Coord * ref1) {
Coord * ref2 = NULL;
TokenType t = tokenizerNext(tt); if (t != TOK_CELLID) goto fail;
ref2 = parseReference(c, tt); if (!ref2) goto fail;
return (Object *) newRange(c, ref1, ref2);
fail:
return NULL;
}
Object * parseReferenceOrRange(Collector * c, Tokenizer * tt) {
Coord * ref = NULL;
ref = parseReference(c, tt); if (!ref) goto fail;
char * sp = tt->bp;
TokenType t = tokenizerNext(tt);
if (t == TOK_COLON) {
return parseRange(c, tt, ref);
} else {
tokenizerSet(tt, sp);
}
return (Object *) ref;
fail:
return NULL;
}
char *OpenDDLParser::parseProperty( char *in, char *end, Property **prop ) {
*prop = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
return in;
}
in = lookForNextToken( in, end );
Text *id( ddl_nullptr );
in = parseIdentifier( in, end, &id );
if( ddl_nullptr != id ) {
in = lookForNextToken( in, end );
if( *in == '=' ) {
++in;
in = getNextToken( in, end );
Value *primData( ddl_nullptr );
if( isInteger( in, end ) ) {
in = parseIntegerLiteral( in, end, &primData );
createPropertyWithData( id, primData, prop );
} else if( isFloat( in, end ) ) {
in = parseFloatingLiteral( in, end, &primData );
createPropertyWithData( id, primData, prop );
} else if( isStringLiteral( *in ) ) { // string data
in = parseStringLiteral( in, end, &primData );
createPropertyWithData( id, primData, prop );
} else { // reference data
std::vector<Name*> names;
in = parseReference( in, end, names );
if( !names.empty() ) {
Reference *ref = new Reference( names.size(), &names[ 0 ] );
( *prop ) = new Property( id );
( *prop )->m_ref = ref;
}
}
} else {
delete id;
}
}
return in;
}
VariableValue* PHPVariableParser::parseValue(PHPVariable* var)
{
PHPArrayValue* arrayValue;
PHPObjectValue* objectValue;
PHPScalarValue* scalarValue;
int index;
switch(m_raw.at(m_index).latin1())
{
case 'b':
scalarValue = new PHPScalarValue(var);
scalarValue->setType(PHPScalarValue::Boolean);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->set(parseBool());
return scalarValue;
//break;
case 's':
scalarValue = new PHPScalarValue(var);
scalarValue->setType(PHPScalarValue::String);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->set(QString("\"") + parseString() + QString("\""));
return scalarValue;
//break;
case 'a':
arrayValue = new PHPArrayValue(var);
arrayValue->setScalar(false);
//var->setValue(arrayValue);
m_indexedVarList.append(arrayValue);
arrayValue->setList(parseArray(var));
return arrayValue;
//break;
case 'O':
objectValue = new PHPObjectValue(var);
objectValue->setScalar(false);
//var->setValue(objectValue);
m_indexedVarList.append(objectValue);
objectValue->setClassType(parseClassType());
objectValue->setList(parseObjectMembers(var));
return objectValue;
//break;
case 'i':
scalarValue = new PHPScalarValue(var);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Integer);
scalarValue->set(parseInt());
return scalarValue;
//break;
case 'r':
index = parseSoftReference();
var->setValueShared(true);
//var->setValue(m_indexedVarList.at(index-2));
return m_indexedVarList.at(index-1);
//break;
case 'R':
index = parseReference();
var->setValueShared(true);
var->setReference(true);
return m_indexedVarList.at(index-1);
//var->setValue(m_indexedVarList.at(index-2));
break;
case 'N':
scalarValue = new PHPScalarValue(var);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Undefined);
scalarValue->set("null");
m_index+=2; //eats the 'N;'
return scalarValue;
//break;
case 'd':
scalarValue = new PHPScalarValue(var);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Double);
scalarValue->set(parseDouble());
return scalarValue;
case 'z':
scalarValue = new PHPScalarValue(var);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Resource);
scalarValue->set(parseResource());
return scalarValue;
case '?':
scalarValue = new PHPScalarValue(var);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Undefined);
scalarValue->set("?");
m_index += 2;
return scalarValue;
default:
kdDebug() << "+++++ Bug on PHPVariableParser! > " << m_index << endl;
kdDebug() << m_raw.mid(0, 200) << endl;
return 0;
}
}
char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type, Value **data,
size_t &numValues, Reference **refs, size_t &numRefs ) {
*data = ddl_nullptr;
numValues = numRefs = 0;
if( ddl_nullptr == in || in == end ) {
return in;
}
in = lookForNextToken( in, end );
if( *in == '{' ) {
++in;
Value *current( ddl_nullptr ), *prev( ddl_nullptr );
while( '}' != *in ) {
current = ddl_nullptr;
in = lookForNextToken( in, end );
if ( Value::ddl_ref == type ) {
std::vector<Name*> names;
in = parseReference( in, end, names );
if ( !names.empty() ) {
Reference *ref = new Reference( names.size(), &names[ 0 ] );
*refs = ref;
numRefs = names.size();
}
} else if ( Value::ddl_none == type ) {
if (isInteger( in, end )) {
in = parseIntegerLiteral( in, end, ¤t );
} else if (isFloat( in, end )) {
in = parseFloatingLiteral( in, end, ¤t );
} else if (isStringLiteral( *in )) {
in = parseStringLiteral( in, end, ¤t );
} else if (isHexLiteral( in, end )) {
in = parseHexaLiteral( in, end, ¤t );
}
} else {
switch(type){
case Value::ddl_int8:
case Value::ddl_int16:
case Value::ddl_int32:
case Value::ddl_int64:
case Value::ddl_unsigned_int8:
case Value::ddl_unsigned_int16:
case Value::ddl_unsigned_int32:
case Value::ddl_unsigned_int64:
in = parseIntegerLiteral( in, end, ¤t, type);
break;
case Value::ddl_half:
case Value::ddl_float:
case Value::ddl_double:
in = parseFloatingLiteral( in, end, ¤t, type);
break;
case Value::ddl_string:
in = parseStringLiteral( in, end, ¤t );
break;
default:
break;
}
}
if( ddl_nullptr != current ) {
if( ddl_nullptr == *data ) {
*data = current;
prev = current;
} else {
prev->setNext( current );
prev = current;
}
++numValues;
}
in = getNextSeparator( in, end );
if( ',' != *in && Grammar::CloseBracketToken[ 0 ] != *in && !isSpace( *in ) ) {
break;
}
}
++in;
}
return in;
}
std::string Attributes::getXLinkValue()
{
return parseReference(getAttribute("xlink:href", ""), m_logger, getDocumentLocation());
}
