std::ostream& operator<<( std::ostream& flux, const UnknownProperties& unknownProperties )
{
flux << separator << " Unknown stream " << separator << std::endl;
PropertyVector properties = unknownProperties.getPropertiesAsVector();
for( PropertyVector::iterator it = properties.begin(); it != properties.end(); ++it )
{
flux << std::setw( keyWidth ) << it->first << ": " << it->second << std::endl;
}
return flux;
}
std::ostream& operator<<(std::ostream& flux, const SubtitleProperties& subtitleProperties)
{
flux << detail::separator << " Subtitle stream " << detail::separator << std::endl;
PropertyVector properties = subtitleProperties.asVector();
for(PropertyVector::iterator it = properties.begin(); it != properties.end(); ++it)
{
flux << std::setw(detail::keyWidth) << it->first << ": " << it->second << std::endl;
}
return flux;
}
std::ostream& operator<<( std::ostream& flux, const FileProperties& fileProperties )
{
flux << std::left;
flux << separator << " Wrapper " << separator << std::endl;
PropertyVector properties = fileProperties.getPropertiesAsVector();
for( PropertyVector::iterator it = properties.begin(); it != properties.end(); ++it )
{
flux << std::setw( keyWidth ) << it->first << ": " << it->second << std::endl;
}
return flux;
}
void PropertyVectorList::setPyObject(PyObject *value)
{
if (PyList_Check(value)) {
Py_ssize_t nSize = PyList_Size(value);
std::vector<Base::Vector3d> values;
values.resize(nSize);
for (Py_ssize_t i=0; i<nSize;++i) {
PyObject* item = PyList_GetItem(value, i);
PropertyVector val;
val.setPyObject( item );
values[i] = val.getValue();
}
setValues(values);
}
else if (PyObject_TypeCheck(value, &(VectorPy::Type))) {
Base::VectorPy *pcObject = static_cast<Base::VectorPy*>(value);
Base::Vector3d* val = pcObject->getVectorPtr();
setValue(*val);
}
else if (PyTuple_Check(value) && PyTuple_Size(value) == 3) {
PropertyVector val;
val.setPyObject( value );
setValue( val.getValue() );
}
else {
std::string error = std::string("type must be 'Vector' or list of 'Vector', not ");
error += value->ob_type->tp_name;
throw Base::TypeError(error);
}
}
inline bool
JSONParserBase::finishObject(MutableHandleValue vp, PropertyVector& properties)
{
MOZ_ASSERT(&properties == &stack.back().properties());
JSObject* obj = ObjectGroup::newPlainObject(cx, properties.begin(), properties.length(), GenericObject);
if (!obj)
return false;
vp.setObject(*obj);
if (!freeProperties.append(&properties))
return false;
stack.popBack();
if (!stack.empty() && stack.back().state == FinishArrayElement) {
const ElementVector& elements = stack.back().elements();
if (!CombinePlainObjectPropertyTypes(cx, obj, elements.begin(), elements.length()))
return false;
}
return true;
}
bool
JSONParser::parse(MutableHandleValue vp)
{
RootedValue value(cx);
JS_ASSERT(stack.empty());
vp.setUndefined();
Token token;
ParserState state = JSONValue;
while (true) {
switch (state) {
case FinishObjectMember: {
PropertyVector &properties = stack.back().properties();
properties.back().value = value;
token = advanceAfterProperty();
if (token == ObjectClose) {
if (!finishObject(&value, properties))
return false;
break;
}
if (token != Comma) {
if (token == OOM)
return false;
if (token != Error)
error("expected ',' or '}' after property-value pair in object literal");
return errorReturn();
}
token = advancePropertyName();
/* FALL THROUGH */
}
JSONMember:
if (token == String) {
jsid id = AtomToId(atomValue());
PropertyVector &properties = stack.back().properties();
if (!properties.append(IdValuePair(id)))
return false;
token = advancePropertyColon();
if (token != Colon) {
JS_ASSERT(token == Error);
return errorReturn();
}
goto JSONValue;
}
if (token == OOM)
return false;
if (token != Error)
error("property names must be double-quoted strings");
return errorReturn();
case FinishArrayElement: {
ElementVector &elements = stack.back().elements();
if (!elements.append(value.get()))
return false;
token = advanceAfterArrayElement();
if (token == Comma)
goto JSONValue;
if (token == ArrayClose) {
if (!finishArray(&value, elements))
return false;
break;
}
JS_ASSERT(token == Error);
return errorReturn();
}
JSONValue:
case JSONValue:
token = advance();
JSONValueSwitch:
switch (token) {
case String:
value = stringValue();
break;
case Number:
value = numberValue();
break;
case True:
value = BooleanValue(true);
break;
case False:
value = BooleanValue(false);
break;
case Null:
value = NullValue();
break;
case ArrayOpen: {
ElementVector *elements;
if (!freeElements.empty()) {
elements = freeElements.popCopy();
elements->clear();
} else {
elements = cx->new_<ElementVector>(cx);
if (!elements)
return false;
}
if (!stack.append(elements))
return false;
token = advance();
if (token == ArrayClose) {
if (!finishArray(&value, *elements))
return false;
break;
}
goto JSONValueSwitch;
}
case ObjectOpen: {
PropertyVector *properties;
if (!freeProperties.empty()) {
properties = freeProperties.popCopy();
properties->clear();
} else {
properties = cx->new_<PropertyVector>(cx);
if (!properties)
return false;
}
if (!stack.append(properties))
return false;
token = advanceAfterObjectOpen();
if (token == ObjectClose) {
if (!finishObject(&value, *properties))
return false;
break;
}
goto JSONMember;
}
case ArrayClose:
case ObjectClose:
case Colon:
case Comma:
// Move the current pointer backwards so that the position
// reported in the error message is correct.
--current;
error("unexpected character");
return errorReturn();
case OOM:
return false;
case Error:
return errorReturn();
}
break;
}
if (stack.empty())
break;
state = stack.back().state;
}
for (; current < end; current++) {
if (!IsJSONWhitespace(*current)) {
error("unexpected non-whitespace character after JSON data");
return errorReturn();
}
}
JS_ASSERT(end == current);
JS_ASSERT(stack.empty());
vp.set(value);
return true;
}
