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