QPpsAttribute QPpsObjectPrivate::decodeData(pps_decoder_t *decoder)
{
pps_node_type_t nodeType = pps_decoder_type(decoder, 0);
switch (nodeType) {
case PPS_TYPE_BOOL:
return decodeBool(decoder);
case PPS_TYPE_NUMBER:
return decodeNumber(decoder);
case PPS_TYPE_STRING:
return decodeString(decoder);
case PPS_TYPE_ARRAY:
return decodeNestedData(&QPpsObjectPrivate::decodeArray, decoder);
case PPS_TYPE_OBJECT:
return decodeNestedData(&QPpsObjectPrivate::decodeObject, decoder);
case PPS_TYPE_DELETED: {
// This should create an attribute with the flags set to PpsAttribute::Deleted.
// However, we need to create a valid QPpsAttribute while doing so. To do this,
// I'll create an empty map as a sentinel. Note that the readFlags() call with produce
// the correct set of flags. While I suspect that there will never be any other flags
// set in conjunction with this one, I'd rather not be surprised later.
QPpsAttributeMap emptyMap;
QPpsAttribute::Flags flags = readFlags(decoder);
QPpsAttribute returnVal = QPpsAttributePrivate::createPpsAttribute(emptyMap, flags);
return returnVal;
}
case PPS_TYPE_NULL:
case PPS_TYPE_NONE:
case PPS_TYPE_UNKNOWN:
default:
qWarning() << "QPpsObjectPrivate::decodeData: invalid pps_node_type";
return QPpsAttribute();
}
}
PGF readPGF(char *filename) {
FILE *f = fopen(filename, "rb");
if (f == NULL)
return NULL;
int maj_ver = readInt16(f);
int min_ver = readInt16(f);
Flags flags = readFlags(f);
struct _Abstract abstr;
readAbstr(f, &abstr);
int nConcr = readInt(f);
PGF pgf = (PGF) malloc(sizeof(struct _PGF)+sizeof(Concrete)*nConcr);
pgf->flags = flags;
pgf->abstract = abstr;
pgf->nConcr = nConcr;
int i;
// for (i = 0; i < nConcr; i++) {
// readConcr(f, &pgf->concretes[i]);
// }
fclose(f);
return pgf;
}
void DebugOptimTab::setReleaseOptions()
{
QStringList sl = QStringList::split(",", "'-$O+','-$Y-','-$D-','-$L-'");
readFlags(&sl);
gdb->setChecked(false);
namespacedb->setChecked(false);
symboldb->setChecked(false);
}
void DebugOptimTab::setDebugOptions()
{
QStringList sl = QStringList::split(",", "-g,-gl,-gh,-gc");
readFlags(&sl);
m_default->setChecked(true);
m_default2->setChecked(true);
// m_default3->setChecked(true);
}
void DebugOptimTab::setReleaseOptions()
{
m_default->setChecked(true);
m_default2->setChecked(true);
// m_default3->setChecked(true);
QStringList sl = QStringList::split(",", "-!g,-!gd,-!gl,-!gh,-!gc,-!pg,-!Ou,-!Or");
readFlags(&sl);
optim1->setChecked(true);
optim2->setChecked(true);
}
QPpsAttribute QPpsObjectPrivate::decodeBool(pps_decoder_t *decoder)
{
bool value;
pps_decoder_error_t error = pps_decoder_get_bool(decoder, 0, &value);
if (error != PPS_DECODER_OK) {
qWarning() << "QPpsObjectPrivate::decodeBool: pps_decoder_get_bool failed";
return QPpsAttribute();
}
QPpsAttribute::Flags flags = readFlags(decoder);
return QPpsAttributePrivate::createPpsAttribute(value, flags);
}
QPpsAttribute QPpsObjectPrivate::decodeString(pps_decoder_t *decoder)
{
const char *value = 0;
pps_decoder_error_t error = pps_decoder_get_string(decoder, 0, &value);
if (error != PPS_DECODER_OK) {
qWarning() << "QPpsObjectPrivate::decodeString: PPS_DECODER_GET_STRING failed";
return QPpsAttribute();
}
QPpsAttribute::Flags flags = readFlags(decoder);
return QPpsAttributePrivate::createPpsAttribute(QString::fromUtf8(value), flags);
}
QPpsAttribute QPpsObjectPrivate::decodeNumber(pps_decoder_t *decoder)
{
// In order to support more number types, we have to do something stupid because the PPS
// library won't let us work any other way. Basically, we have to probe the encoded type in
// order to try to get exactly what we want.
int64_t llValue;
double dValue;
int iValue;
QPpsAttribute::Flags flags;
if (pps_decoder_is_integer(decoder, 0)) {
pps_decoder_error_t error = pps_decoder_get_int(decoder, 0, &iValue);
switch (error) {
case PPS_DECODER_OK:
flags = readFlags(decoder);
return QPpsAttributePrivate::createPpsAttribute(iValue, flags);
case PPS_DECODER_CONVERSION_FAILED:
error = pps_decoder_get_int64(decoder, 0, &llValue);
if (error != PPS_DECODER_OK) {
qWarning() << "QPpsObjectPrivate::decodeNumber: failed to decode integer";
return QPpsAttribute();
}
flags = readFlags(decoder);
return QPpsAttributePrivate::createPpsAttribute(static_cast<long long>(llValue), flags);
default:
qWarning() << "QPpsObjectPrivate::decodeNumber: pps_decoder_get_int failed";
return QPpsAttribute();
}
} else {
pps_decoder_error_t error = pps_decoder_get_double(decoder, 0, &dValue);
if (error != PPS_DECODER_OK) {
qWarning() << "QPpsObjectPrivate::decodeNumber: pps_decoder_get_double failed";
return QPpsAttribute();
}
flags = readFlags(decoder);
return QPpsAttributePrivate::createPpsAttribute(dValue, flags);
}
}
QPpsAttribute QPpsObjectPrivate::decodeNestedData(T (*decodeFunction)(pps_decoder_t *, bool *),
pps_decoder_t *decoder)
{
// We must read the flags before we push into the object,
// otherwise we'll get the flags for the first element in the object.
QPpsAttribute::Flags flags = readFlags(decoder);
if (!decoderPush(decoder))
return QPpsAttribute();
bool ok = false;
T attributeContainer = decodeFunction(decoder, &ok);
if (!ok)
return QPpsAttribute();
QPpsAttribute returnVal = QPpsAttributePrivate::createPpsAttribute(attributeContainer, flags);
if (!decoderPop(decoder))
return QPpsAttribute();
return returnVal;
}
void BasicExternalizableMessage::read(AmfReader *stream)
{
int byteN = 0;
foreach(quint8 flag, readFlags(stream)){
int bits = 0;
if(byteN == 0){
if((flag & BODY_FLAG) != 0)
body = stream->readAmf3Next();
if((flag & CLIENT_ID_FLAG) != 0)
clientId = stream->readAmf3Next().toString();
if((flag & DESTINATION_FLAG) != 0)
dest = stream->readAmf3Next().toString();
if((flag & HEADERS_FLAG) != 0)
headers = stream->readAmf3Next();
if((flag & MESSAGE_ID_FLAG) != 0)
messageId = stream->readAmf3Next().toString();
if((flag & TIMESTAMP_FLAG) != 0)
timestamp = stream->readAmf3Next().toLongLong();
if((flag & TIME_TO_LIVE_FLAG) != 0)
timestamp = stream->readAmf3Next().toLongLong();
bits = 7;
} else if(byteN == 1){
if((flag & CLIENT_ID_BYTES_FLAG) != 0)
clientIdBytes = stream->readAmf3Next().toByteArray();
if((flag & MESSAGE_ID_BYTES_FLAG) != 0)
messageIdBytes = stream->readAmf3Next().toByteArray();
bits = 2;
}
discardRemaining(stream, flag, bits);
++byteN;
}
void TranslatorAction::init() {
readFlags();
MemoryManager& mm = getJITInstanceContext().getGlobalMemoryManager();
irbAction = (IRBuilderAction*)createAuxAction(mm, IRBUILDER_ACTION_NAME, "irbuilder");
irbAction->init();
}
void DebugOptimTab::setDebugOptions()
{
QStringList sl = QStringList::split(",", "'-$O-','-$Y+','-$D+','-$L+',-V,-VN");
readFlags(&sl);
}
static void readConcr(FILE *f, Concrete concr) {
concr->name = readCId(f);
concr->flags = readFlags(f);
}
static void readAbstr(FILE *f, Abstract abstr) {
abstr->name = readCId(f);
abstr->flags = readFlags(f);
abstr->funs = readAbsFuns(f);
abstr->cats = readAbsCats(f);
}
