Lines Matching defs:end
302 const char *limit; /* End of delimited region or end of buffer. */
509 const char *end = ptr + val.str_val.size;
511 while (ptr < end) {
513 ptr = decode_varint64(d, ptr, end, &elem.uint64_val);
522 if (ptr != end) decode_err(d);
781 /* We want previous data at the end, realloc() put it at the beginning. */
2354 a->head.end = (char*)block + size;
2411 * itself at the end. */
2428 a->head.end = NULL;
4231 char *end;
4256 long val = strtol(str, &end, 0);
4257 CHK(val <= INT32_MAX && val >= INT32_MIN && errno != ERANGE && !*end);
4270 int64_t val = strtol(str, &end, 0);
4271 CHK(val <= INT64_MAX && val >= INT64_MIN && errno != ERANGE && !*end);
4276 unsigned long val = strtoul(str, &end, 0);
4277 CHK(val <= UINT32_MAX && errno != ERANGE && !*end);
4283 uint64_t val = strtoul(str, &end, 0);
4284 CHK(val <= UINT64_MAX && errno != ERANGE && !*end);
4289 double val = strtod(str, &end);
4290 CHK(errno != ERANGE && !*end);
4296 float val = strtod(str, &end);
4297 CHK(errno != ERANGE && !*end);
6350 static void dumpbc(uint32_t *p, uint32_t *end, FILE *f) {
6354 while (p < end) {
6751 * fields and check for the end of the message. */
6753 /* Check for end-of-message. */
6763 /* Insert both a label and a dispatch table entry for this end-of-msg. */
6962 "Submessage end extends past enclosing submessage.";
7037 /* How many bytes can be safely read from d->ptr without reading past end-of-buf
7038 * or past the current delimited end. */
7044 /* How many bytes are available before end-of-buffer. */
7046 return d->end - d->ptr;
7054 /* How many bytes are available before the end of this delimited region. */
7065 static bool in_buf(const char *p, const char *buf, const char *end) {
7066 return p >= buf && p <= end;
7077 if (delim_ofs <= (size_t)(d->end - d->buf)) {
7081 d->data_end = d->end;
7086 static void switchtobuf(upb_pbdecoder *d, const char *buf, const char *end) {
7089 d->end = end;
7095 d->bufstart_ofs += (d->end - d->buf);
7128 d->bufstart_ofs += (d->end - d->buf);
7152 * calculate a d->end or use our normal functions like curbufleft(). */
7209 size_t ret = d->size_param - (d->end - d->checkpoint);
7225 /* We hit end-of-buffer before we could parse a full value.
7414 static bool decoder_push(upb_pbdecoder *d, uint64_t end) {
7417 if (end > fr->end_ofs) {
7426 fr->end_ofs = end;
7434 /* While we expect to see an "end" tag (either ENDGROUP or a non-sequence
7435 * field number) prior to hitting any enclosing submessage end, pushing our
7436 * existing delim end prevents us from continuing to parse values from a
7542 * instruction for the end of message. */
7576 * can re-check the delimited end. */
7637 (int)(d->end - d->ptr),
7700 seterr(d, "Tried to skip past end of string.");
7831 uint64_t end;
7849 /* The user's end() call indicates that the message ends here. */
7850 end = offset(d);
7851 d->top->end_ofs = end;
7855 d->stack->end_ofs = end;
7895 d->end = d->residual;
8035 ** and lengths. When the top-level submessage ends, we can go beginning to end,
8238 /* Call to indicate the end of a delimited region. We now know the length of
8601 const char *end = buf + len;
8608 for (; buf < end; buf++) {
9058 static bool end(void *closure, const void *hd);
9158 * should end as soon as the value is parsed. */
9652 * the end. */
9723 /* This is called at the end of each input buffer (ie. when we have hit a
9905 char *end;
9924 long val = strtol(buf, &end, 0);
9925 if (errno == ERANGE || end != bufend) {
9935 unsigned long val = strtoul(buf, &end, 0);
9936 if (end != bufend) {
9948 long val = strtol(buf, &end, 0);
9949 if (errno == ERANGE || end != bufend) {
9957 unsigned long val = strtoul(p->accumulated, &end, 0);
9958 if (end != bufend) {
9982 val = strtod(buf, &end);
9983 if (errno == ERANGE || end != bufend) {
10230 * them all at once at the end. */
10411 char *end;
10428 /* Find out base end. The maximus duration is 315576000000, which cannot be
10436 seconds = strtol(seconds_buf, &end, 10);
10437 if (errno == ERANGE || end != seconds_buf + fraction_start) {
10460 val = strtod(nanos_buf, &end);
10461 if (errno == ERANGE || end != nanos_buf + len - fraction_start + 1) {
10596 char *end;
10618 val = strtod(nanos_buf, &end);
10620 if (errno == ERANGE || end != nanos_buf + len + 1) {
10862 * is invoked from end_membername(), at the end of the map entry's key string,
10867 * end the mapentry message. */
10877 * value field is parsed, and also set a flag to end the frame after the
10967 /* If we just parsed a map-entry value, end that frame too. */
11302 if (!end(p->top->any_frame->parser, NULL)) {
12207 static bool end(void *closure, const void *hd) {
12260 upb_byteshandler_setendstr(&m->input_handler_, end, m);
13026 * key/value pair once at the end of the submessage. If we don't do this, we