Lines Matching refs:val
382 const char *limit, uint64_t *val) {
395 *val = out;
401 const char *limit, uint64_t *val) {
403 *val = (uint8_t)*ptr;
406 return decode_longvarint64(d, ptr, limit, val);
411 const char *limit, uint32_t *val) {
415 *val = (uint32_t)u64;
419 static void decode_munge(int type, wireval *val) {
422 val->bool_val = val->uint64_val != 0;
425 uint32_t n = val->uint32_val;
426 val->int32_val = (n >> 1) ^ -(int32_t)(n & 1);
430 uint64_t n = val->uint64_val;
431 val->int64_val = (n >> 1) ^ -(int64_t)(n & 1);
461 const upb_msglayout_field *field, upb_strview val) {
465 d->limit = val.data + val.size;
466 decode_msg(d, val.data, submsg, subl);
492 const upb_msglayout_field *field, wireval val,
514 memcpy(mem, &val, 1 << op);
517 decode_verifyutf8(d, val.str_val.data, val.str_val.size);
524 memcpy(mem, &val, sizeof(upb_strview));
535 decode_tosubmsg(d, submsg, layout, field, val.str_val);
544 size_t count = val.str_val.size >> lg2;
545 if ((val.str_val.size & mask) != 0) {
551 memcpy(mem, val.str_val.data, val.str_val.size);
560 const char *ptr = val.str_val.data;
561 const char *end = ptr + val.str_val.size;
584 const upb_msglayout_field *field, wireval val) {
609 ent.v.val.val = (uint64_t)_upb_msg_new(entry->submsgs[0], d->arena);
612 decode_tosubmsg(d, &ent.k, layout, field, val.str_val);
620 const upb_msglayout_field *field, wireval val,
649 decode_tosubmsg(d, submsg, layout, field, val.str_val);
654 decode_verifyutf8(d, val.str_val.data, val.str_val.size);
657 memcpy(mem, &val, sizeof(upb_strview));
660 memcpy(mem, &val, 8);
663 memcpy(mem, &val, 4);
666 memcpy(mem, &val, 1);
683 wireval val;
694 ptr = decode_varint64(d, ptr, d->limit, &val.uint64_val);
696 decode_munge(field->descriptortype, &val);
700 memcpy(&val, ptr, 4);
707 memcpy(&val, ptr, 8);
720 val.str_val.data = ptr;
721 val.str_val.size = size;
727 val.int32_val = field_number;
743 ptr = decode_toarray(d, ptr, msg, layout, field, val, op);
746 decode_tomap(d, msg, layout, field, val);
749 ptr = decode_tomsg(d, ptr, msg, layout, field, val, op);
803 static size_t upb_encode_varint(uint64_t val, char *buf) {
805 if (val < 128) { buf[0] = val; return 1; }
807 while (val) {
808 uint8_t byte = val & 0x7fU;
809 val >>= 7;
810 if (val) byte |= 0x80U;
867 static bool upb_put_fixed64(upb_encstate *e, uint64_t val) {
869 return upb_put_bytes(e, &val, sizeof(uint64_t));
872 static bool upb_put_fixed32(upb_encstate *e, uint32_t val) {
874 return upb_put_bytes(e, &val, sizeof(uint32_t));
877 static bool upb_put_varint(upb_encstate *e, uint64_t val) {
881 len = upb_encode_varint(val, e->ptr);
932 ctype val = *(ctype*)field_mem; \
933 if (skip_zero_value && val == 0) { \
942 CASE(double, double, UPB_WIRE_TYPE_64BIT, val);
944 CASE(float, float, UPB_WIRE_TYPE_32BIT, val);
947 CASE(uint64_t, varint, UPB_WIRE_TYPE_VARINT, val);
949 CASE(uint32_t, varint, UPB_WIRE_TYPE_VARINT, val);
952 CASE(int32_t, varint, UPB_WIRE_TYPE_VARINT, (int64_t)val);
955 CASE(uint64_t, fixed64, UPB_WIRE_TYPE_64BIT, val);
958 CASE(uint32_t, fixed32, UPB_WIRE_TYPE_32BIT, val);
960 CASE(bool, varint, UPB_WIRE_TYPE_VARINT, val);
962 CASE(int32_t, varint, UPB_WIRE_TYPE_VARINT, upb_zzencode_32(val));
964 CASE(int64_t, varint, UPB_WIRE_TYPE_VARINT, upb_zzencode_64(val));
1125 const upb_value val = upb_strtable_iter_value(&i);
1128 _upb_map_fromvalue(val, &ent.v, map->val_size);
1530 _upb_value_setval(v, e->val.val);
1540 upb_value val, uint32_t hash,
1580 our_e->val.val = val.val;
1584 static bool rm(upb_table *t, lookupkey_t key, upb_value *val,
1591 if (val) _upb_value_setval(val, chain->val.val);
1611 if (val) _upb_value_setval(val, chain->next->val.val);
1728 upb_value *val, upb_alloc *alloc) {
1731 if (rm(&t->t, strkey2(key, len), val, &tabkey, hash, &streql)) {
1770 return _upb_value_val(str_tabent(i)->val.val);
1807 return e ? &e->val : NULL;
1866 bool upb_inttable_insert2(upb_inttable *t, uintptr_t key, upb_value val,
1869 tabval.val = val.val;
1875 mutable_array(t)[key].val = val.val;
1891 _upb_value_setval(&v, e->val.val);
1901 insert(&t->t, intkey(key), key, val, upb_inthash(key), &inthash, &inteql);
1910 if (v) _upb_value_setval(v, table_v->val);
1914 bool upb_inttable_replace(upb_inttable *t, uintptr_t key, upb_value val) {
1917 table_v->val = val.val;
1921 bool upb_inttable_remove(upb_inttable *t, uintptr_t key, upb_value *val) {
1927 if (val) {
1928 _upb_value_setval(val, t->array[key].val);
1936 success = rm(&t->t, intkey(key), val, NULL, upb_inthash(key), &inteql);
1942 bool upb_inttable_insertptr2(upb_inttable *t, const void *key, upb_value val,
1944 return upb_inttable_insert2(t, (uintptr_t)key, val, a);
1952 bool upb_inttable_removeptr(upb_inttable *t, const void *key, upb_value *val) {
1953 return upb_inttable_remove(t, (uintptr_t)key, val);
2066 i->array_part ? i->t->array[i->index].val : int_tabent(i)->val.val);
4070 upb_value val;
4071 return upb_inttable_lookup32(&m->itof, i, &val) ?
4072 upb_value_getconstptr(val) : NULL;
4077 upb_value val;
4079 if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
4083 return unpack_def(val, UPB_DEFTYPE_FIELD);
4088 upb_value val;
4090 if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
4094 return unpack_def(val, UPB_DEFTYPE_ONEOF);
4099 upb_value val;
4101 if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
4105 *o = unpack_def(val, UPB_DEFTYPE_ONEOF);
4106 *f = unpack_def(val, UPB_DEFTYPE_FIELD);
4112 upb_value val;
4115 if (!upb_strtable_lookup2(&m->ntof, name, len, &val)) {
4119 f = unpack_def(val, UPB_DEFTYPE_FIELD);
4120 if (!f) f = unpack_def(val, UPB_DEFTYPE_FIELD_JSONNAME);
4253 upb_value val;
4254 return upb_strtable_lookup2(&o->ntof, name, length, &val) ?
4255 upb_value_getptr(val) : NULL;
4259 upb_value val;
4260 return upb_inttable_lookup32(&o->itof, num, &val) ?
4261 upb_value_getptr(val) : NULL;
4380 const upb_fielddef *val = upb_msgdef_itof(m, 2);
4388 fields[1].descriptortype = upb_fielddef_descriptortype(val);
4393 if (upb_fielddef_type(val) == UPB_TYPE_MESSAGE) {
4394 submsgs[0] = upb_fielddef_msgsubdef(val)->layout;
4719 long val = strtol(str, &end, 0);
4720 CHK(val <= INT32_MAX && val >= INT32_MIN && errno != ERANGE && !*end);
4721 f->defaultval.sint = val;
4726 int32_t val;
4727 CHK(upb_enumdef_ntoi(e, str, len, &val));
4728 f->defaultval.sint = val;
4733 int64_t val = strtol(str, &end, 0);
4734 CHK(val <= INT64_MAX && val >= INT64_MIN && errno != ERANGE && !*end);
4735 f->defaultval.sint = val;
4739 unsigned long val = strtoul(str, &end, 0);
4740 CHK(val <= UINT32_MAX && errno != ERANGE && !*end);
4741 f->defaultval.uint = val;
4746 uint64_t val = strtoul(str, &end, 0);
4747 CHK(val <= UINT64_MAX && errno != ERANGE && !*end);
4748 f->defaultval.uint = val;
4752 double val = strtod(str, &end);
4754 f->defaultval.dbl = val;
4759 float val = strtod(str, &end);
4761 f->defaultval.flt = val;
5637 upb_msgval val = {0};
5638 memcpy(&val, mem, get_field_size(field));
5639 return val;
5682 upb_msgval val = {0};
5686 val.int32_val = upb_fielddef_defaultint32(f);
5689 val.int64_val = upb_fielddef_defaultint64(f);
5692 val.uint32_val = upb_fielddef_defaultuint32(f);
5695 val.uint64_val = upb_fielddef_defaultuint64(f);
5698 val.float_val = upb_fielddef_defaultfloat(f);
5701 val.double_val = upb_fielddef_defaultdouble(f);
5704 val.double_val = upb_fielddef_defaultbool(f);
5708 val.str_val.data = upb_fielddef_defaultstr(f, &val.str_val.size);
5711 val.msg_val = NULL;
5714 return val;
5752 void upb_msg_set(upb_msg *msg, const upb_fielddef *f, upb_msgval val,
5757 memcpy(mem, &val, get_field_size(field));
5792 upb_msgval val = _upb_msg_getraw(msg, f);
5798 upb_msgval test = val;
5814 *out_val = val;
5826 upb_msgval val;
5833 while (upb_msg_next(msg, m, NULL /*ext_pool*/, &f, &val, &iter)) {
5839 upb_map *map = (upb_map*)val.map_val;
5851 const upb_array *arr = val.array_val;
5860 if (!_upb_msg_discardunknown((upb_msg*)val.msg_val, subm, depth)) {
5892 void upb_array_set(upb_array *arr, size_t i, upb_msgval val) {
5896 memcpy(data + (i << lg2), &val, 1 << lg2);
5899 bool upb_array_append(upb_array *arr, upb_msgval val, upb_arena *arena) {
5904 upb_array_set(arr, arr->len - 1, val);
5924 bool upb_map_get(const upb_map *map, upb_msgval key, upb_msgval *val) {
5925 return _upb_map_get(map, &key, map->key_size, val, map->val_size);
5928 bool upb_map_set(upb_map *map, upb_msgval key, upb_msgval val,
5930 return _upb_map_set(map, &key, map->key_size, &val, map->val_size, arena);
6254 double val = strtod(start, &end);
6257 /* Currently the min/max-val conformance tests fail if we check this. Does
6266 if (val > DBL_MAX || val < -DBL_MAX) {
6270 return val;
6515 int32_t val = -1;
6519 val = jsondec_base64_tablelookup(ptr[0]) << 18 |
6521 out[0] = val >> 16;
6525 val = jsondec_base64_tablelookup(ptr[0]) << 18 |
6528 out[0] = val >> 16;
6529 out[1] = (val >> 8) & 0xff;
6534 if (val < 0) {
6550 int val = jsondec_base64_tablelookup(ptr[0]) << 18 |
6555 if (val < 0) {
6567 out[0] = val >> 16;
6568 out[1] = (val >> 8) & 0xff;
6569 out[2] = val & 0xff;
6586 const char *end, uint64_t *val) {
6599 *val = u64;
6604 const char *end, int64_t *val) {
6618 *val = neg ? -u64 : u64;
6644 upb_msgval val;
6652 val.int64_val = dbl; /* must be guarded, overflow here is UB */
6653 if (val.int64_val != dbl) {
6655 val.int64_val);
6661 val.int64_val = jsondec_strtoint64(d, str);
6669 if (val.int64_val > INT32_MAX || val.int64_val < INT32_MIN) {
6672 val.int32_val = (int32_t)val.int64_val;
6675 return val;
6680 upb_msgval val;
6688 val.uint64_val = dbl; /* must be guarded, overflow here is UB */
6689 if (val.uint64_val != dbl) {
6691 val.uint64_val);
6697 val.uint64_val = jsondec_strtouint64(d, str);
6705 if (val.uint64_val > UINT32_MAX) {
6708 val.uint32_val = (uint32_t)val.uint64_val;
6711 return val;
6717 upb_msgval val;
6721 val.double_val = jsondec_number(d);
6726 val.double_val = UPB_NAN;
6728 val.double_val = UPB_INFINITY;
6730 val.double_val = -UPB_INFINITY;
6732 val.double_val = strtod(str.data, NULL);
6740 if (val.double_val != UPB_INFINITY && val.double_val != -UPB_INFINITY &&
6741 (val.double_val > FLT_MAX || val.double_val < -FLT_MAX)) {
6744 val.float_val = val.double_val;
6747 return val;
6752 upb_msgval val;
6753 val.str_val = jsondec_string(d);
6755 val.str_val.size = jsondec_base64(d, val.str_val);
6757 return val;
6764 upb_msgval val;
6765 if (!upb_enumdef_ntoi(e, str.data, str.size, &val.int32_val)) {
6767 val.int32_val = 0;
6773 return val;
6782 upb_msgval val;
6787 val.bool_val = true;
6789 val.bool_val = false;
6796 val.bool_val = true;
6800 val.bool_val = false;
6808 return val;
6832 upb_msgval key, val;
6835 val = jsondec_value(d, val_f);
6836 upb_map_set(map, key, val, d->arena);
6852 upb_msgval val;
6855 val.msg_val = msg;
6856 return val;
6906 upb_msgval val = jsondec_value(d, f);
6907 upb_msg_set(msg, f, val, d->arena);
6950 uint64_t val;
6957 if (jsondec_buftouint64(d, p, end, &val) != end ||
6962 UPB_ASSERT(val < INT_MAX);
6965 return (int)val;
7129 upb_msgval val;
7137 val.double_val = jsondec_number(d);
7142 val.str_val = jsondec_string(d);
7147 val.bool_val = false;
7153 val.bool_val = true;
7159 val.int32_val = 0;
7179 upb_msg_set(msg, f, val, d->arena);
7221 upb_msgval val;
7226 val.str_val = jsondec_mask(d, ptr, elem_end);
7229 val.str_val = jsondec_mask(d, ptr, end);
7232 upb_array_append(arr, val, d->arena);
7260 upb_msgval val;
7262 val.str_val = type_url;
7263 upb_msg_set(msg, type_url_f, val, d->arena);
7347 upb_msgval val = jsondec_value(d, value_f);
7348 upb_msg_set(msg, value_f, val, d->arena);
7435 static void jsonenc_scalar(jsonenc *e, upb_msgval val, const upb_fielddef *f);
7574 static void jsonenc_enum(int32_t val, const upb_fielddef *f, jsonenc *e) {
7576 const char *name = upb_enumdef_iton(e_def, val);
7581 jsonenc_printf(e, "%" PRId32, val);
7671 static void jsonenc_double(jsonenc *e, const char *fmt, double val) {
7672 if (val == UPB_INFINITY) {
7674 } else if (val == -UPB_INFINITY) {
7676 } else if (val != val) {
7679 jsonenc_printf(e, fmt, val);
7686 upb_msgval val = upb_msg_get(msg, val_f);
7687 jsonenc_scalar(e, val, val_f);
7818 upb_msgval val = upb_mapiter_value(fields, iter);
7823 jsonenc_value(e, val.msg_val, upb_fielddef_msgsubdef(value_f));
7857 upb_msgval val;
7859 if (!upb_msg_next(msg, m, NULL, &f, &val, &iter)) {
7868 jsonenc_double(e, "%.17g", val.double_val);
7871 jsonenc_string(e, val.str_val);
7874 jsonenc_putstr(e, val.bool_val ? "true" : "false");
7877 jsonenc_struct(e, val.msg_val, upb_fielddef_msgsubdef(f));
7880 jsonenc_listvalue(e, val.msg_val, upb_fielddef_msgsubdef(f));
7926 static void jsonenc_scalar(jsonenc *e, upb_msgval val, const upb_fielddef *f) {
7929 jsonenc_putstr(e, val.bool_val ? "true" : "false");
7932 jsonenc_double(e, "%.9g", val.float_val);
7935 jsonenc_double(e, "%.17g", val.double_val);
7938 jsonenc_printf(e, "%" PRId32, val.int32_val);
7941 jsonenc_printf(e, "%" PRIu32, val.uint32_val);
7944 jsonenc_printf(e, "\"%" PRId64 "\"", val.int64_val);
7947 jsonenc_printf(e, "\"%" PRIu64 "\"", val.uint64_val);
7950 jsonenc_string(e, val.str_val);
7953 jsonenc_bytes(e, val.str_val);
7956 jsonenc_enum(val.int32_val, f, e);
7959 jsonenc_msgfield(e, val.msg_val, upb_fielddef_msgsubdef(f));
7964 static void jsonenc_mapkey(jsonenc *e, upb_msgval val, const upb_fielddef *f) {
7969 jsonenc_putstr(e, val.bool_val ? "true" : "false");
7972 jsonenc_printf(e, "%" PRId32, val.int32_val);
7975 jsonenc_printf(e, "%" PRIu32, val.uint32_val);
7978 jsonenc_printf(e, "%" PRId64, val.int64_val);
7981 jsonenc_printf(e, "%" PRIu64, val.uint64_val);
7984 jsonenc_stringbody(e, val.str_val);
8028 upb_msgval val, bool *first) {
8041 jsonenc_map(e, val.map_val, f);
8043 jsonenc_array(e, val.array_val, f);
8045 jsonenc_scalar(e, val, f);
8051 upb_msgval val;
8066 while (upb_msg_next(msg, m, e->ext_pool, &f, &val, &iter)) {
8067 jsonenc_fieldval(e, f, val, &first);