static PyObject*
decode_json(JSONData *jsondata)
{
PyObject *object;
skipSpaces(jsondata);
switch(*jsondata->ptr) {
case 0:
PyErr_SetString(JSON_DecodeError, "empty JSON description");
return NULL;
case '{':
object = decode_object(jsondata);
break;
case '[':
object = decode_array(jsondata);
break;
case '"':
object = decode_string(jsondata);
break;
case 't':
case 'f':
object = decode_bool(jsondata);
break;
case 'n':
object = decode_null(jsondata);
break;
case 'N':
object = decode_nan(jsondata);
break;
case 'I':
object = decode_inf(jsondata);
break;
case '+':
case '-':
if (*(jsondata->ptr+1) == 'I') {
object = decode_inf(jsondata);
} else {
object = decode_number(jsondata);
}
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
object = decode_number(jsondata);
break;
default:
PyErr_SetString(JSON_DecodeError, "cannot parse JSON description");
return NULL;
}
return object;
}
int php_deserialize( rabbit * r, rawbuffer * buf, TValue * tv )
{
if(!buf || !tv) {
return -1;
}
setnilvalue(tv);
int c = decode_read_byte( buf );
switch( c ) {
case PHP_NULL:
// kLOG(r, 0,"php decode nil\n");
return decode_null( r, buf, tv );
case PHP_INT:
// kLOG(r, 0,"php decode int\n");
return decode_int( r, buf, tv );
case PHP_DOUBLE:
// kLOG(r, 0,"php decode double\n");
return decode_double(r, buf, tv);
case PHP_STRING:
// kLOG(r, 0,"php decode string\n");
return decode_string(r, buf, tv);
case PHP_ARRAY:
// kLOG(r, 0,"php decode array\n");
return decode_array(r, buf, tv);
case PHP_BOOL:
return decode_bool(r, buf, tv);
default:
kLOG(r, 0, "php decode unknow:%c\n",c);
break;
}
return -1;
}
prop_t* decode_prop(CBitRead& entityBitBuffer, FlattenedPropEntry* pFlattenedProp, uint32_t uClass, int nFieldIndex) {
const CSVCMsg_SendTable::sendprop_t* pSendProp = pFlattenedProp->m_prop;
prop_t* pResult = 0;
if(pSendProp->type() != DPT_Array && pSendProp->type() != DPT_DataTable) {
pResult = new prop_t((send_prop_type_t)(pSendProp->type()));
}
switch(pSendProp->type()) {
case DPT_Int:
pResult->m_value.m_int = decode_int(entityBitBuffer, pSendProp);
break;
case DPT_Float:
pResult->m_value.m_float = decode_float(entityBitBuffer, pSendProp);
break;
case DPT_Vector:
decode_vector_xyz(entityBitBuffer, pSendProp, pResult->m_value.m_vector);
break;
case DPT_VectorXY:
decode_vector_xy(entityBitBuffer, pSendProp, pResult->m_value.m_vector);
break;
case DPT_String:
pResult->m_value.m_pString = decode_string(entityBitBuffer, pSendProp);
break;
case DPT_Array:
pResult = decode_array(entityBitBuffer, pFlattenedProp, pSendProp->num_elements(), uClass, nFieldIndex);
break;
case DPT_DataTable:
break;
case DPT_Int64:
pResult->m_value.m_int64 = decode_int64(entityBitBuffer, pSendProp);
break;
}
return pResult;
}
void
read_weights (unsigned total, wfa_t *wfa, bitfile_t *input)
/*
* Read #'total' weights from input stream 'input' and
* update transitions of the WFA states with corresponding weights.
*
* No return value.
*
* Side effects:
* 'wfa->weights' are filled with the decoded values
*/
{
unsigned state;
unsigned label;
unsigned edge; /* current edge */
unsigned *weights_array; /* array of weights to encode */
unsigned *level_array; /* array of corresponding levels */
unsigned offset1, offset2; /* prob. model offsets. */
unsigned offset3, offset4; /* prob. model offsets. */
bool_t delta_approx = NO; /* true if delta has been used */
/*
* Check whether delta approximation has been used
*/
for (state = wfa->basis_states; state < wfa->states; state++)
if (wfa->delta_state [state])
{
delta_approx = YES;
break;
}
/*
* Generate array of corresponding levels (context of probability model)
*/
{
int min_level, max_level; /* min and max range level */
int d_min_level, d_max_level; /* min and max range level (delta) */
unsigned *lptr; /* pointer to current corresp. level */
int domain; /* current domain */
bool_t dc, d_dc; /* indicates whether DC is used */
/*
* Compute minimum and maximum level of delta and normal approximations
*/
min_level = d_min_level = MAXLEVEL;
max_level = d_max_level = 0;
dc = d_dc = NO;
for (state = wfa->basis_states; state < wfa->states; state++)
for (label = 0; label < MAXLABELS; label++)
if (isrange (wfa->tree [state][label]))
{
if (delta_approx && wfa->delta_state [state])
{
d_min_level = min (d_min_level,
wfa->level_of_state [state] - 1);
d_max_level = max (d_max_level,
wfa->level_of_state [state] - 1);
if (wfa->into [state][label][0] == 0)
d_dc = YES;
}
else
{
min_level = min (min_level, wfa->level_of_state [state] - 1);
max_level = max (max_level, wfa->level_of_state [state] - 1);
if (wfa->into [state][label][0] == 0)
dc = YES;
}
}
if (min_level > max_level) /* no lc found */
max_level = min_level - 1;
if (d_min_level > d_max_level)
d_max_level = d_min_level - 1;
offset1 = dc ? 1 : 0;
offset2 = offset1 + (d_dc ? 1 : 0);
offset3 = offset2 + (max_level - min_level + 1);
offset4 = offset3 + (d_max_level - d_min_level + 1);
lptr = level_array = Calloc (total, sizeof (int));
for (state = wfa->basis_states; state < wfa->states; state++)
for (label = 0; label < MAXLABELS; label++)
if (isrange (wfa->tree[state][label]))
for (edge = 0; isedge (domain = wfa->into[state][label][edge]);
edge++)
{
if ((unsigned) (lptr - level_array) >= total)
error ("Can't read more than %d weights.", total);
if (domain)
{
if (delta_approx && wfa->delta_state [state])
*lptr++ = offset3 + wfa->level_of_state [state]
- 1 - d_min_level;
else
*lptr++ = offset2 + wfa->level_of_state [state]
- 1 - min_level;
}
else
*lptr++ = delta_approx && wfa->delta_state [state]
? offset1 : 0;
}
}
/*
* Decode the list of weights with an arithmetic decoder
*/
{
unsigned i;
unsigned *c_symbols = Calloc (offset4, sizeof (unsigned));
const unsigned scale = 500; /* scaling of probability model */
c_symbols [0] = 1 << (wfa->wfainfo->dc_rpf->mantissa_bits + 1);
if (offset1 != offset2)
c_symbols [offset1] = 1 << (wfa->wfainfo->d_dc_rpf->mantissa_bits
+ 1);
for (i = offset2; i < offset3; i++)
c_symbols [i] = 1 << (wfa->wfainfo->rpf->mantissa_bits + 1);
for (; i < offset4; i++)
c_symbols [i] = 1 << (wfa->wfainfo->d_rpf->mantissa_bits + 1);
weights_array = decode_array (input, level_array, c_symbols,
offset4, total, scale);
Free (c_symbols);
}
Free (level_array);
/*
* Update transitions with decoded weights
*/
{
unsigned *wptr = weights_array; /* pointer to current weight */
int domain; /* current domain */
for (state = wfa->basis_states; state < wfa->states; state++)
for (label = 0; label < MAXLABELS; label++)
if (isrange (wfa->tree[state][label]))
for (edge = 0; isedge (domain = wfa->into[state][label][edge]);
edge++)
{
if (domain) /* not DC component */
{
if (delta_approx && wfa->delta_state [state])
wfa->weight [state][label][edge]
= btor (*wptr++, wfa->wfainfo->d_rpf);
else
wfa->weight [state][label][edge]
= btor (*wptr++, wfa->wfainfo->rpf);
}
else
{
if (delta_approx && wfa->delta_state [state])
wfa->weight [state][label][edge]
= btor (*wptr++, wfa->wfainfo->d_dc_rpf);
else
wfa->weight [state][label][edge]
= btor (*wptr++, wfa->wfainfo->dc_rpf);
}
wfa->int_weight [state][label][edge]
= wfa->weight [state][label][edge] * 512 + 0.5;
}
}
Free (weights_array);
}
