struct timespec dtotimespec (double sec) { double min_representable = TYPE_MINIMUM (time_t); double max_representable = ((TYPE_MAXIMUM (time_t) * (double) TIMESPEC_RESOLUTION + (TIMESPEC_RESOLUTION - 1)) / TIMESPEC_RESOLUTION); if (! (min_representable < sec)) return make_timespec (TYPE_MINIMUM (time_t), 0); else if (! (sec < max_representable)) return make_timespec (TYPE_MAXIMUM (time_t), TIMESPEC_RESOLUTION - 1); else { time_t s = sec; double frac = TIMESPEC_RESOLUTION * (sec - s); long ns = frac; ns += ns < frac; s += ns / TIMESPEC_RESOLUTION; ns %= TIMESPEC_RESOLUTION; if (ns < 0) { s--; ns += TIMESPEC_RESOLUTION; } return make_timespec (s, ns); } }
struct timespec dtotimespec (double sec) { if (! (TYPE_MINIMUM (time_t) < sec)) return make_timespec (TYPE_MINIMUM (time_t), 0); else if (! (sec < 1.0 + TYPE_MAXIMUM (time_t))) return make_timespec (TYPE_MAXIMUM (time_t), TIMESPEC_RESOLUTION - 1); else { time_t s = sec; double frac = TIMESPEC_RESOLUTION * (sec - s); long ns = frac; ns += ns < frac; s += ns / TIMESPEC_RESOLUTION; ns %= TIMESPEC_RESOLUTION; if (ns < 0) { s--; ns += TIMESPEC_RESOLUTION; } return make_timespec (s, ns); } }
/* Read incremental snapshot format 2 */ static void read_incr_db_2 (void) { struct obstack stk; char offbuf[INT_BUFSIZE_BOUND (off_t)]; obstack_init (&stk); read_timespec (listed_incremental_stream, &newer_mtime_option); for (;;) { intmax_t i; struct timespec mtime; dev_t dev; ino_t ino; bool nfs; char *name; char *content; size_t s; if (! read_num (listed_incremental_stream, "nfs", 0, 1, &i)) return; /* Normal return */ nfs = i; read_timespec (listed_incremental_stream, &mtime); if (! read_num (listed_incremental_stream, "dev", TYPE_MINIMUM (dev_t), TYPE_MAXIMUM (dev_t), &i)) break; dev = i; if (! read_num (listed_incremental_stream, "ino", TYPE_MINIMUM (ino_t), TYPE_MAXIMUM (ino_t), &i)) break; ino = i; if (read_obstack (listed_incremental_stream, &stk, &s)) break; name = obstack_finish (&stk); while (read_obstack (listed_incremental_stream, &stk, &s) == 0 && s > 1) ; if (getc (listed_incremental_stream) != 0) FATAL_ERROR ((0, 0, _("%s: byte %s: %s"), quotearg_colon (listed_incremental_option), offtostr (ftello (listed_incremental_stream), offbuf), _("Missing record terminator"))); content = obstack_finish (&stk); note_directory (name, mtime, dev, ino, nfs, false, content); obstack_free (&stk, content); } FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (listed_incremental_option), _("Unexpected EOF in snapshot file"))); }
/* Read incremental snapshot format 2 */ static void read_incr_db_2 () { uintmax_t u; struct obstack stk; obstack_init (&stk); read_timespec (listed_incremental_stream, &newer_mtime_option); for (;;) { struct timespec mtime; dev_t dev; ino_t ino; bool nfs; char *name; char *content; size_t s; if (read_num (listed_incremental_stream, 1, &u)) return; /* Normal return */ nfs = u; read_timespec (listed_incremental_stream, &mtime); if (read_num (listed_incremental_stream, TYPE_MAXIMUM (dev_t), &u)) break; dev = u; if (read_num (listed_incremental_stream, TYPE_MAXIMUM (ino_t), &u)) break; ino = u; if (read_obstack (listed_incremental_stream, &stk, &s)) break; name = obstack_finish (&stk); while (read_obstack (listed_incremental_stream, &stk, &s) == 0 && s > 1) ; if (getc (listed_incremental_stream) != 0) FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (listed_incremental_option), _("Missing record terminator"))); content = obstack_finish (&stk); note_directory (name, mtime, dev, ino, nfs, false, content); obstack_free (&stk, content); } FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (listed_incremental_option), _("Unexpected EOF in snapshot file"))); }
static void read_timespec (FILE *fp, struct timespec *pval) { int c = getc (fp); intmax_t i; uintmax_t u; if (c == '-') { read_negative_num (fp, TYPE_MINIMUM (time_t), &i); c = 0; pval->tv_sec = i; } else { c = read_unsigned_num (c, fp, TYPE_MAXIMUM (time_t), &u); pval->tv_sec = u; } if (c || read_num (fp, BILLION - 1, &u)) FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (listed_incremental_option), _("Unexpected EOF in snapshot file"))); pval->tv_nsec = u; }
struct atimer * start_atimer (enum atimer_type type, struct timespec timestamp, atimer_callback fn, void *client_data) { struct atimer *t; sigset_t oldset; /* Round TIME up to the next full second if we don't have itimers. */ #ifndef HAVE_SETITIMER if (timestamp.tv_nsec != 0 && timestamp.tv_sec < TYPE_MAXIMUM (time_t)) timestamp = make_timespec (timestamp.tv_sec + 1, 0); #endif /* not HAVE_SETITIMER */ /* Get an atimer structure from the free-list, or allocate a new one. */ if (free_atimers) { t = free_atimers; free_atimers = t->next; } else t = xmalloc (sizeof *t); /* Fill the atimer structure. */ memset (t, 0, sizeof *t); t->type = type; t->fn = fn; t->client_data = client_data; block_atimers (&oldset); /* Compute the timer's expiration time. */ switch (type) { case ATIMER_ABSOLUTE: t->expiration = timestamp; break; case ATIMER_RELATIVE: t->expiration = timespec_add (current_timespec (), timestamp); break; case ATIMER_CONTINUOUS: t->expiration = timespec_add (current_timespec (), timestamp); t->interval = timestamp; break; } /* Insert the timer in the list of active atimers. */ schedule_atimer (t); unblock_atimers (&oldset); /* Arrange for a SIGALRM at the time the next atimer is ripe. */ set_alarm (); return t; }
/* Output incremental data for the directory ENTRY to the file DATA. Return nonzero if successful, preserving errno on write failure. */ static bool write_directory_file_entry (void *entry, void *data) { struct directory const *directory = entry; FILE *fp = data; if (DIR_IS_FOUND (directory)) { char buf[SYSINT_BUFSIZE]; char const *s; s = DIR_IS_NFS (directory) ? "1" : "0"; fwrite (s, 2, 1, fp); s = sysinttostr (directory->mtime.tv_sec, TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t), buf); fwrite (s, strlen (s) + 1, 1, fp); s = imaxtostr (directory->mtime.tv_nsec, buf); fwrite (s, strlen (s) + 1, 1, fp); s = sysinttostr (directory->device_number, TYPE_MINIMUM (dev_t), TYPE_MAXIMUM (dev_t), buf); fwrite (s, strlen (s) + 1, 1, fp); s = sysinttostr (directory->inode_number, TYPE_MINIMUM (ino_t), TYPE_MAXIMUM (ino_t), buf); fwrite (s, strlen (s) + 1, 1, fp); fwrite (directory->name, strlen (directory->name) + 1, 1, fp); if (directory->dump) { const char *p; struct dumpdir_iter *itr; for (p = dumpdir_first (directory->dump, 0, &itr); p; p = dumpdir_next (itr)) fwrite (p, strlen (p) + 1, 1, fp); free (itr); } fwrite ("\0\0", 2, 1, fp); } return ! ferror (fp); }
struct timespec timespec_add (struct timespec a, struct timespec b) { time_t rs = a.tv_sec; time_t bs = b.tv_sec; int ns = a.tv_nsec + b.tv_nsec; int nsd = ns - TIMESPEC_RESOLUTION; int rns = ns; if (0 <= nsd) { rns = nsd; if (rs == TYPE_MAXIMUM (time_t)) { if (0 <= bs) goto high_overflow; bs++; } else rs++; } if (INT_ADD_OVERFLOW (rs, bs)) { if (rs < 0) { rs = TYPE_MINIMUM (time_t); rns = 0; } else { high_overflow: rs = TYPE_MAXIMUM (time_t); rns = TIMESPEC_RESOLUTION - 1; } } else rs += bs; return make_timespec (rs, rns); }
int nanosleep (const struct timespec *requested_delay, struct timespec *remaining_delay) # undef nanosleep { /* nanosleep mishandles large sleeps due to internal overflow problems. The worst known case of this is Linux 2.6.9 with glibc 2.3.4, which can't sleep more than 24.85 days (2^31 milliseconds). Similarly, cygwin 1.5.x, which can't sleep more than 49.7 days (2^32 milliseconds). Solve this by breaking the sleep up into smaller chunks. */ if (requested_delay->tv_nsec < 0 || BILLION <= requested_delay->tv_nsec) { errno = EINVAL; return -1; } { /* Verify that time_t is large enough. */ verify (TYPE_MAXIMUM (time_t) / 24 / 24 / 60 / 60); const time_t limit = 24 * 24 * 60 * 60; time_t seconds = requested_delay->tv_sec; struct timespec intermediate; intermediate.tv_nsec = 0; while (limit < seconds) { int result; intermediate.tv_sec = limit; result = nanosleep (&intermediate, remaining_delay); seconds -= limit; if (result) { if (remaining_delay) { remaining_delay->tv_sec += seconds; remaining_delay->tv_nsec += requested_delay->tv_nsec; if (BILLION <= requested_delay->tv_nsec) { remaining_delay->tv_sec++; remaining_delay->tv_nsec -= BILLION; } } return result; } } intermediate.tv_sec = seconds; intermediate.tv_nsec = requested_delay->tv_nsec; return nanosleep (&intermediate, remaining_delay); } }
/* Hash some device info. */ static size_t dev_info_hash (void const *x, size_t table_size) { struct fs_res const *p = x; /* Beware signed arithmetic gotchas. */ if (TYPE_SIGNED (dev_t) && SIZE_MAX < MAX (INT_MAX, TYPE_MAXIMUM (dev_t))) { uintmax_t dev = p->dev; return dev % table_size; } return p->dev % table_size; }
static void print_context_label (char const *mark, struct file_data *inf, char const *name, char const *label) { if (label) fprintf (outfile, "%s %s\n", mark, label); else { char buf[MAX (INT_STRLEN_BOUND (int) + 32, INT_STRLEN_BOUND (time_t) + 11)]; struct tm const *tm = localtime (&inf->stat.st_mtime); int nsec = get_stat_mtime_ns (&inf->stat); if (! (tm && nstrftime (buf, sizeof buf, time_format, tm, 0, nsec))) { verify (TYPE_IS_INTEGER (time_t)); if (LONG_MIN <= TYPE_MINIMUM (time_t) && TYPE_MAXIMUM (time_t) <= LONG_MAX) { long int sec = inf->stat.st_mtime; sprintf (buf, "%ld.%.9d", sec, nsec); } else if (TYPE_MAXIMUM (time_t) <= INTMAX_MAX) { intmax_t sec = inf->stat.st_mtime; sprintf (buf, "%"PRIdMAX".%.9d", sec, nsec); } else { uintmax_t sec = inf->stat.st_mtime; sprintf (buf, "%"PRIuMAX".%.9d", sec, nsec); } } fprintf (outfile, "%s %s\t%s\n", mark, name, buf); } }
static int my_usleep (const struct timespec *ts_delay) { struct timeval tv_delay; tv_delay.tv_sec = ts_delay->tv_sec; tv_delay.tv_usec = (ts_delay->tv_nsec + 999) / 1000; if (tv_delay.tv_usec == 1000000) { if (tv_delay.tv_sec == TYPE_MAXIMUM (time_t)) tv_delay.tv_usec = 1000000 - 1; /* close enough */ else { tv_delay.tv_sec++; tv_delay.tv_usec = 0; } } return select (0, NULL, NULL, NULL, &tv_delay); }
static bool decode_time (struct timespec *ts, char const *arg, char const *keyword) { switch (_decode_time (ts, arg, keyword)) { case decode_time_success: return true; case decode_time_bad_header: ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"), keyword, arg)); return false; case decode_time_range: out_of_range_header (keyword, arg, - (uintmax_t) TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t)); return false; } return true; }
static void read_timespec (FILE *fp, struct timespec *pval) { intmax_t s, ns; if (read_num (fp, "sec", TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t), &s) && read_num (fp, "nsec", 0, BILLION - 1, &ns)) { pval->tv_sec = s; pval->tv_nsec = ns; } else { FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (listed_incremental_option), _("Unexpected EOF in snapshot file"))); } }
struct timespec timespec_add (struct timespec a, struct timespec b) { time_t rs = a.tv_sec; time_t bs = b.tv_sec; int ns = a.tv_nsec + b.tv_nsec; int nsd = ns - TIMESPEC_RESOLUTION; int rns = ns; time_t tmin = TYPE_MINIMUM (time_t); time_t tmax = TYPE_MAXIMUM (time_t); if (0 <= nsd) { rns = nsd; if (bs < tmax) bs++; else if (rs < 0) rs++; else goto high_overflow; } /* INT_ADD_WRAPV is not appropriate since time_t might be unsigned. In theory time_t might be narrower than int, so plain INT_ADD_OVERFLOW does not suffice. */ if (! INT_ADD_OVERFLOW (rs, bs) && tmin <= rs + bs && rs + bs <= tmax) rs += bs; else { if (rs < 0) { rs = tmin; rns = 0; } else { high_overflow: rs = tmax; rns = TIMESPEC_RESOLUTION - 1; } } return make_timespec (rs, rns); }
struct timespec timespec_sub (struct timespec a, struct timespec b) { struct timespec r; time_t rs = a.tv_sec; time_t bs = b.tv_sec; int ns = a.tv_nsec - b.tv_nsec; int rns = ns; if (ns < 0) { rns = ns + 1000000000; if (rs == TYPE_MINIMUM (time_t)) { if (bs <= 0) goto low_overflow; bs--; } else rs--; } if (INT_SUBTRACT_OVERFLOW (rs, bs)) { if (rs < 0) { low_overflow: rs = TYPE_MINIMUM (time_t); rns = 0; } else { rs = TYPE_MAXIMUM (time_t); rns = 999999999; } } else rs -= bs; r.tv_sec = rs; r.tv_nsec = rns; return r; }
static bool decode_time (struct timespec *ts, char const *arg, char const *keyword) { char *arg_lim; struct timespec t = decode_timespec (arg, &arg_lim, true); if (! valid_timespec (t)) { if (arg < arg_lim && !*arg_lim) out_of_range_header (keyword, arg, TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t)); else ERROR ((0, 0, _("Malformed extended header: invalid %s=%s"), keyword, arg)); return false; } *ts = t; return true; }
struct timespec timespec_sub (struct timespec a, struct timespec b) { time_t rs = a.tv_sec; time_t bs = b.tv_sec; int ns = a.tv_nsec - b.tv_nsec; int rns = ns; if (ns < 0) { rns = ns + TIMESPEC_RESOLUTION; if (rs == TYPE_MINIMUM (time_t)) { if (bs <= 0) goto low_overflow; bs--; } else rs--; } if (INT_SUBTRACT_OVERFLOW (rs, bs)) { if (rs < 0) { low_overflow: rs = TYPE_MINIMUM (time_t); rns = 0; } else { rs = TYPE_MAXIMUM (time_t); rns = TIMESPEC_RESOLUTION - 1; } } else rs -= bs; return make_timespec (rs, rns); }
double calculate_percent(uintmax_t value, uintmax_t total) { double pct = -1; /* I don't understand the below, but it is taken from coreutils' df */ /* Seems to be calculating pct, in the best possible way */ if (value <= TYPE_MAXIMUM(uintmax_t) / 100 && total != 0) { uintmax_t u100 = value * 100; pct = u100 / total + (u100 % total != 0); } else { /* Possible rounding errors - see coreutils' df for more explanation */ double u = value; double t = total; if (t) { long int lipct = pct = u * 100 / t; double ipct = lipct; /* Like 'pct = ceil (dpct);', but without ceil - from coreutils again */ if (ipct - 1 < pct && pct <= ipct + 1) pct = ipct + (ipct < pct); } } return pct; }
/* Read incremental snapshot formats 0 and 1 */ static void read_incr_db_01 (int version, const char *initbuf) { int n; uintmax_t u; time_t sec; long int nsec; char *buf = NULL; size_t bufsize = 0; char *ebuf; long lineno = 1; if (version == 1) { if (getline (&buf, &bufsize, listed_incremental_stream) <= 0) { read_error (listed_incremental_option); free (buf); return; } ++lineno; } else { buf = strdup (initbuf); bufsize = strlen (buf) + 1; } sec = TYPE_MINIMUM (time_t); nsec = -1; errno = 0; u = strtoumax (buf, &ebuf, 10); if (!errno && TYPE_MAXIMUM (time_t) < u) errno = ERANGE; if (errno || buf == ebuf) ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid time stamp"))); else { sec = u; if (version == 1 && *ebuf) { char const *buf_ns = ebuf + 1; errno = 0; u = strtoumax (buf_ns, &ebuf, 10); if (!errno && BILLION <= u) errno = ERANGE; if (errno || buf_ns == ebuf) { ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid time stamp"))); sec = TYPE_MINIMUM (time_t); } else nsec = u; } else { /* pre-1 incremental format does not contain nanoseconds */ nsec = 0; } } newer_mtime_option.tv_sec = sec; newer_mtime_option.tv_nsec = nsec; while (0 < (n = getline (&buf, &bufsize, listed_incremental_stream))) { dev_t dev; ino_t ino; bool nfs = buf[0] == '+'; char *strp = buf + nfs; struct timespec mtime; lineno++; if (buf[n - 1] == '\n') buf[n - 1] = '\0'; if (version == 1) { errno = 0; u = strtoumax (strp, &ebuf, 10); if (!errno && TYPE_MAXIMUM (time_t) < u) errno = ERANGE; if (errno || strp == ebuf || *ebuf != ' ') { ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid modification time (seconds)"))); sec = (time_t) -1; } else sec = u; strp = ebuf; errno = 0; u = strtoumax (strp, &ebuf, 10); if (!errno && BILLION <= u) errno = ERANGE; if (errno || strp == ebuf || *ebuf != ' ') { ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid modification time (nanoseconds)"))); nsec = -1; } else nsec = u; mtime.tv_sec = sec; mtime.tv_nsec = nsec; strp = ebuf; } else memset (&mtime, 0, sizeof mtime); errno = 0; u = strtoumax (strp, &ebuf, 10); if (!errno && TYPE_MAXIMUM (dev_t) < u) errno = ERANGE; if (errno || strp == ebuf || *ebuf != ' ') { ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid device number"))); dev = (dev_t) -1; } else dev = u; strp = ebuf; errno = 0; u = strtoumax (strp, &ebuf, 10); if (!errno && TYPE_MAXIMUM (ino_t) < u) errno = ERANGE; if (errno || strp == ebuf || *ebuf != ' ') { ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid inode number"))); ino = (ino_t) -1; } else ino = u; strp = ebuf; strp++; unquote_string (strp); note_directory (strp, mtime, dev, ino, nfs, false, NULL); } free (buf); }
static enum profiler_cpu_running setup_cpu_timer (Lisp_Object sampling_interval) { struct sigaction action; struct itimerval timer; struct timespec interval; int billion = 1000000000; if (! RANGED_INTEGERP (1, sampling_interval, (TYPE_MAXIMUM (time_t) < EMACS_INT_MAX / billion ? ((EMACS_INT) TYPE_MAXIMUM (time_t) * billion + (billion - 1)) : EMACS_INT_MAX))) return NOT_RUNNING; current_sampling_interval = XINT (sampling_interval); interval = make_timespec (current_sampling_interval / billion, current_sampling_interval % billion); emacs_sigaction_init (&action, deliver_profiler_signal); sigaction (SIGPROF, &action, 0); #ifdef HAVE_ITIMERSPEC if (! profiler_timer_ok) { /* System clocks to try, in decreasing order of desirability. */ static clockid_t const system_clock[] = { #ifdef CLOCK_THREAD_CPUTIME_ID CLOCK_THREAD_CPUTIME_ID, #endif #ifdef CLOCK_PROCESS_CPUTIME_ID CLOCK_PROCESS_CPUTIME_ID, #endif #ifdef CLOCK_MONOTONIC CLOCK_MONOTONIC, #endif CLOCK_REALTIME }; int i; struct sigevent sigev; sigev.sigev_value.sival_ptr = &profiler_timer; sigev.sigev_signo = SIGPROF; sigev.sigev_notify = SIGEV_SIGNAL; for (i = 0; i < ARRAYELTS (system_clock); i++) if (timer_create (system_clock[i], &sigev, &profiler_timer) == 0) { profiler_timer_ok = 1; break; } } if (profiler_timer_ok) { struct itimerspec ispec; ispec.it_value = ispec.it_interval = interval; if (timer_settime (profiler_timer, 0, &ispec, 0) == 0) return TIMER_SETTIME_RUNNING; } #endif #ifdef HAVE_SETITIMER timer.it_value = timer.it_interval = make_timeval (interval); if (setitimer (ITIMER_PROF, &timer, 0) == 0) return SETITIMER_RUNNING; #endif return NOT_RUNNING; }
with any changes made to the read_num() calls in the parsing loop inside read_incr_db_2(). (This function is invoked via the --show-snapshot-field-ranges command line option.) */ struct field_range { char const *fieldname; intmax_t min_val; uintmax_t max_val; }; static struct field_range const field_ranges[] = { { "nfs", 0, 1 }, { "timestamp_sec", TYPE_MINIMUM (time_t), TYPE_MAXIMUM (time_t) }, { "timestamp_nsec", 0, BILLION - 1 }, { "dev", TYPE_MINIMUM (dev_t), TYPE_MAXIMUM (dev_t) }, { "ino", TYPE_MINIMUM (ino_t), TYPE_MAXIMUM (ino_t) }, { NULL, 0, 0 } }; void show_snapshot_field_ranges (void) { struct field_range const *p; char minbuf[SYSINT_BUFSIZE]; char maxbuf[SYSINT_BUFSIZE]; printf("This tar's snapshot file field ranges are\n"); printf (" (%-15s => [ %s, %s ]):\n\n", "field name", "min", "max");
static enum decode_time_status _decode_time (struct timespec *ts, char const *arg, char const *keyword) { time_t s; unsigned long int ns = 0; char *p; char *arg_lim; bool negative = *arg == '-'; errno = 0; if (ISDIGIT (arg[negative])) { if (negative) { intmax_t i = strtoimax (arg, &arg_lim, 10); if (TYPE_SIGNED (time_t) ? i < TYPE_MINIMUM (time_t) : i < 0) return decode_time_range; s = i; } else { uintmax_t i = strtoumax (arg, &arg_lim, 10); if (TYPE_MAXIMUM (time_t) < i) return decode_time_range; s = i; } p = arg_lim; if (errno == ERANGE) return decode_time_range; if (*p == '.') { int digits = 0; bool trailing_nonzero = false; while (ISDIGIT (*++p)) if (digits < LOG10_BILLION) { ns = 10 * ns + (*p - '0'); digits++; } else trailing_nonzero |= *p != '0'; while (digits++ < LOG10_BILLION) ns *= 10; if (negative) { /* Convert "-1.10000000000001" to s == -2, ns == 89999999. I.e., truncate time stamps towards minus infinity while converting them to internal form. */ ns += trailing_nonzero; if (ns != 0) { if (s == TYPE_MINIMUM (time_t)) return decode_time_range; s--; ns = BILLION - ns; } } } if (! *p) { ts->tv_sec = s; ts->tv_nsec = ns; return decode_time_success; } } return decode_time_bad_header; }
Lisp_Object get_doc_string (Lisp_Object filepos, bool unibyte, bool definition) { char *from, *to, *name, *p, *p1; int fd; ptrdiff_t minsize; int offset; EMACS_INT position; Lisp_Object file, tem; USE_SAFE_ALLOCA; if (INTEGERP (filepos)) { file = Vdoc_file_name; position = XINT (filepos); } else if (CONSP (filepos)) { file = XCAR (filepos); position = XINT (XCDR (filepos)); } else return Qnil; if (position < 0) position = - position; if (!STRINGP (Vdoc_directory)) return Qnil; if (!STRINGP (file)) return Qnil; /* Put the file name in NAME as a C string. If it is relative, combine it with Vdoc_directory. */ tem = Ffile_name_absolute_p (file); file = ENCODE_FILE (file); if (NILP (tem)) { Lisp_Object docdir = ENCODE_FILE (Vdoc_directory); minsize = SCHARS (docdir); /* sizeof ("../etc/") == 8 */ if (minsize < 8) minsize = 8; name = SAFE_ALLOCA (minsize + SCHARS (file) + 8); strcpy (name, SSDATA (docdir)); strcat (name, SSDATA (file)); } else { name = SSDATA (file); } fd = emacs_open (name, O_RDONLY, 0); if (fd < 0) { #ifndef CANNOT_DUMP if (!NILP (Vpurify_flag)) { /* Preparing to dump; DOC file is probably not installed. So check in ../etc. */ strcpy (name, "../etc/"); strcat (name, SSDATA (file)); fd = emacs_open (name, O_RDONLY, 0); } #endif if (fd < 0) error ("Cannot open doc string file \"%s\"", name); } /* Seek only to beginning of disk block. */ /* Make sure we read at least 1024 bytes before `position' so we can check the leading text for consistency. */ offset = min (position, max (1024, position % (8 * 1024))); if (TYPE_MAXIMUM (off_t) < position || lseek (fd, position - offset, 0) < 0) { emacs_close (fd); error ("Position %"pI"d out of range in doc string file \"%s\"", position, name); } SAFE_FREE (); /* Read the doc string into get_doc_string_buffer. P points beyond the data just read. */ p = get_doc_string_buffer; while (1) { ptrdiff_t space_left = (get_doc_string_buffer_size - 1 - (p - get_doc_string_buffer)); int nread; /* Allocate or grow the buffer if we need to. */ if (space_left <= 0) { ptrdiff_t in_buffer = p - get_doc_string_buffer; get_doc_string_buffer = xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size, 16 * 1024, -1, 1); p = get_doc_string_buffer + in_buffer; space_left = (get_doc_string_buffer_size - 1 - (p - get_doc_string_buffer)); } /* Read a disk block at a time. If we read the same block last time, maybe skip this? */ if (space_left > 1024 * 8) space_left = 1024 * 8; nread = emacs_read (fd, p, space_left); if (nread < 0) { emacs_close (fd); error ("Read error on documentation file"); } p[nread] = 0; if (!nread) break; if (p == get_doc_string_buffer) p1 = strchr (p + offset, '\037'); else p1 = strchr (p, '\037'); if (p1) { *p1 = 0; p = p1; break; } p += nread; } emacs_close (fd); /* Sanity checking. */ if (CONSP (filepos)) { int test = 1; if (get_doc_string_buffer[offset - test++] != ' ') return Qnil; while (get_doc_string_buffer[offset - test] >= '0' && get_doc_string_buffer[offset - test] <= '9') test++; if (get_doc_string_buffer[offset - test++] != '@' || get_doc_string_buffer[offset - test] != '#') return Qnil; } else { int test = 1; if (get_doc_string_buffer[offset - test++] != '\n') return Qnil; while (get_doc_string_buffer[offset - test] > ' ') test++; if (get_doc_string_buffer[offset - test] != '\037') return Qnil; } /* Scan the text and perform quoting with ^A (char code 1). ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */ from = get_doc_string_buffer + offset; to = get_doc_string_buffer + offset; while (from != p) { if (*from == 1) { int c; from++; c = *from++; if (c == 1) *to++ = c; else if (c == '0') *to++ = 0; else if (c == '_') *to++ = 037; else { unsigned char uc = c; error ("\ Invalid data in documentation file -- %c followed by code %03o", 1, uc); } } else *to++ = *from++; } /* If DEFINITION, read from this buffer the same way we would read bytes from a file. */ if (definition) { read_bytecode_pointer = (unsigned char *) get_doc_string_buffer + offset; return Fread (Qlambda); } if (unibyte) return make_unibyte_string (get_doc_string_buffer + offset, to - (get_doc_string_buffer + offset)); else { /* The data determines whether the string is multibyte. */ ptrdiff_t nchars = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer + offset), to - (get_doc_string_buffer + offset)); return make_string_from_bytes (get_doc_string_buffer + offset, nchars, to - (get_doc_string_buffer + offset)); } }
/* Read incremental snapshot formats 0 and 1 */ static void read_incr_db_01 (int version, const char *initbuf) { int n; uintmax_t u; char *buf = NULL; size_t bufsize = 0; char *ebuf; long lineno = 1; if (version == 1) { if (getline (&buf, &bufsize, listed_incremental_stream) <= 0) { read_error (listed_incremental_option); free (buf); return; } ++lineno; } else { buf = strdup (initbuf); bufsize = strlen (buf) + 1; } newer_mtime_option = decode_timespec (buf, &ebuf, false); if (! valid_timespec (newer_mtime_option)) ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid time stamp"))); else { if (version == 1 && *ebuf) { char const *buf_ns = ebuf + 1; errno = 0; u = strtoumax (buf_ns, &ebuf, 10); if (!errno && BILLION <= u) errno = ERANGE; if (errno || buf_ns == ebuf) { ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid time stamp"))); newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t); newer_mtime_option.tv_nsec = -1; } else newer_mtime_option.tv_nsec = u; } } while (0 < (n = getline (&buf, &bufsize, listed_incremental_stream))) { dev_t dev; ino_t ino; bool nfs = buf[0] == '+'; char *strp = buf + nfs; struct timespec mtime; lineno++; if (buf[n - 1] == '\n') buf[n - 1] = '\0'; if (version == 1) { mtime = decode_timespec (strp, &ebuf, false); strp = ebuf; if (!valid_timespec (mtime) || *strp != ' ') ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid modification time"))); errno = 0; u = strtoumax (strp, &ebuf, 10); if (!errno && BILLION <= u) errno = ERANGE; if (errno || strp == ebuf || *ebuf != ' ') { ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid modification time (nanoseconds)"))); mtime.tv_nsec = -1; } else mtime.tv_nsec = u; strp = ebuf; } else mtime.tv_sec = mtime.tv_nsec = 0; dev = strtosysint (strp, &ebuf, TYPE_MINIMUM (dev_t), TYPE_MAXIMUM (dev_t)); strp = ebuf; if (errno || *strp != ' ') ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid device number"))); ino = strtosysint (strp, &ebuf, TYPE_MINIMUM (ino_t), TYPE_MAXIMUM (ino_t)); strp = ebuf; if (errno || *strp != ' ') ERROR ((0, errno, "%s:%ld: %s", quotearg_colon (listed_incremental_option), lineno, _("Invalid inode number"))); strp++; unquote_string (strp); note_directory (strp, mtime, dev, ino, nfs, false, NULL); } free (buf); }
static int current_lock_owner (lock_info_type *owner, char *lfname) { int ret; ptrdiff_t len; lock_info_type local_owner; intmax_t n; char *at, *dot, *colon; char readlink_buf[READLINK_BUFSIZE]; char *lfinfo = emacs_readlink (lfname, readlink_buf); /* If nonexistent lock file, all is well; otherwise, got strange error. */ if (!lfinfo) return errno == ENOENT ? 0 : -1; /* Even if the caller doesn't want the owner info, we still have to read it to determine return value. */ if (!owner) owner = &local_owner; /* Parse [email protected]:BOOT_TIME. If can't parse, return -1. */ /* The USER is everything before the last @. */ at = strrchr (lfinfo, '@'); dot = strrchr (lfinfo, '.'); if (!at || !dot) { if (lfinfo != readlink_buf) xfree (lfinfo); return -1; } len = at - lfinfo; owner->user = xmalloc (len + 1); memcpy (owner->user, lfinfo, len); owner->user[len] = 0; /* The PID is everything from the last `.' to the `:'. */ errno = 0; n = strtoimax (dot + 1, NULL, 10); owner->pid = ((0 <= n && n <= TYPE_MAXIMUM (pid_t) && (TYPE_MAXIMUM (pid_t) < INTMAX_MAX || errno != ERANGE)) ? n : 0); colon = strchr (dot + 1, ':'); /* After the `:', if there is one, comes the boot time. */ n = 0; if (colon) { errno = 0; n = strtoimax (colon + 1, NULL, 10); } owner->boot_time = ((0 <= n && n <= TYPE_MAXIMUM (time_t) && (TYPE_MAXIMUM (time_t) < INTMAX_MAX || errno != ERANGE)) ? n : 0); /* The host is everything in between. */ len = dot - at - 1; owner->host = xmalloc (len + 1); memcpy (owner->host, at + 1, len); owner->host[len] = 0; /* We're done looking at the link info. */ if (lfinfo != readlink_buf) xfree (lfinfo); /* On current host? */ if (STRINGP (Fsystem_name ()) && strcmp (owner->host, SSDATA (Fsystem_name ())) == 0) { if (owner->pid == getpid ()) ret = 2; /* We own it. */ else if (owner->pid > 0 && (kill (owner->pid, 0) >= 0 || errno == EPERM) && (owner->boot_time == 0 || within_one_second (owner->boot_time, get_boot_time ()))) ret = 1; /* An existing process on this machine owns it. */ /* The owner process is dead or has a strange pid (<=0), so try to zap the lockfile. */ else if (unlink (lfname) < 0) ret = -1; else ret = 0; } else { /* If we wanted to support the check for stale locks on remote machines, here's where we'd do it. */ ret = 1; } /* Avoid garbage. */ if (owner == &local_owner || ret <= 0) { FREE_LOCK_INFO (*owner); } return ret; }
struct timespec decode_timespec (char const *arg, char **arg_lim, bool parse_fraction) { time_t s = TYPE_MINIMUM (time_t); int ns = -1; char const *p = arg; bool negative = *arg == '-'; struct timespec r; if (! ISDIGIT (arg[negative])) errno = EINVAL; else { errno = 0; if (negative) { intmax_t i = strtoimax (arg, arg_lim, 10); if (TYPE_SIGNED (time_t) ? TYPE_MINIMUM (time_t) <= i : 0 <= i) s = i; else errno = ERANGE; } else { uintmax_t i = strtoumax (arg, arg_lim, 10); if (i <= TYPE_MAXIMUM (time_t)) s = i; else errno = ERANGE; } p = *arg_lim; ns = 0; if (parse_fraction && *p == '.') { int digits = 0; bool trailing_nonzero = false; while (ISDIGIT (*++p)) if (digits < LOG10_BILLION) digits++, ns = 10 * ns + (*p - '0'); else trailing_nonzero |= *p != '0'; while (digits < LOG10_BILLION) digits++, ns *= 10; if (negative) { /* Convert "-1.10000000000001" to s == -2, ns == 89999999. I.e., truncate time stamps towards minus infinity while converting them to internal form. */ ns += trailing_nonzero; if (ns != 0) { if (s == TYPE_MINIMUM (time_t)) ns = -1; else { s--; ns = BILLION - ns; } } } } if (errno == ERANGE) ns = -1; } *arg_lim = (char *) p; r.tv_sec = s; r.tv_nsec = ns; return r; }
#if __GNUC__ >= 2 && DO_PEDANTIC # define verify_same_types(expr1,expr2) \ extern void _verify_func(__LINE__) (__typeof__ (expr1) *); \ extern void _verify_func(__LINE__) (__typeof__ (expr2) *); # define _verify_func(line) _verify_func2(line) # define _verify_func2(line) verify_func_ ## line #else # define verify_same_types(expr1,expr2) extern void verify_func (int) #endif /* 7.18.1.1. Exact-width integer types */ /* 7.18.2.1. Limits of exact-width integer types */ int8_t a1[3] = { INT8_C (17), INT8_MIN, INT8_MAX }; verify (TYPE_MINIMUM (int8_t) == INT8_MIN); verify (TYPE_MAXIMUM (int8_t) == INT8_MAX); verify_same_types (INT8_MIN, (int8_t) 0 + 0); verify_same_types (INT8_MAX, (int8_t) 0 + 0); int16_t a2[3] = { INT16_C (17), INT16_MIN, INT16_MAX }; verify (TYPE_MINIMUM (int16_t) == INT16_MIN); verify (TYPE_MAXIMUM (int16_t) == INT16_MAX); verify_same_types (INT16_MIN, (int16_t) 0 + 0); verify_same_types (INT16_MAX, (int16_t) 0 + 0); int32_t a3[3] = { INT32_C (17), INT32_MIN, INT32_MAX }; verify (TYPE_MINIMUM (int32_t) == INT32_MIN); verify (TYPE_MAXIMUM (int32_t) == INT32_MAX); verify_same_types (INT32_MIN, (int32_t) 0 + 0); verify_same_types (INT32_MAX, (int32_t) 0 + 0);
size_t EGexecute (char const *buf, size_t size, size_t *match_size, char const *start_ptr) { char const *buflim, *beg, *end, *match, *best_match, *mb_start; char eol = eolbyte; int backref; regoff_t start; size_t len, best_len; struct kwsmatch kwsm; size_t i, ret_val; mb_len_map_t *map = NULL; if (MB_CUR_MAX > 1) { if (match_icase) { /* mbtolower adds a NUL byte at the end. That will provide space for the sentinel byte dfaexec may add. */ char *case_buf = mbtolower (buf, &size, &map); if (start_ptr) start_ptr = case_buf + (start_ptr - buf); buf = case_buf; } } mb_start = buf; buflim = buf + size; for (beg = end = buf; end < buflim; beg = end) { if (!start_ptr) { /* We don't care about an exact match. */ if (kwset) { /* Find a possible match using the KWset matcher. */ size_t offset = kwsexec (kwset, beg, buflim - beg, &kwsm); if (offset == (size_t) -1) goto failure; beg += offset; /* Narrow down to the line containing the candidate, and run it through DFA. */ if ((end = memchr(beg, eol, buflim - beg)) != NULL) end++; else end = buflim; match = beg; while (beg > buf && beg[-1] != eol) --beg; if (kwsm.index < kwset_exact_matches) { if (!MBS_SUPPORT) goto success; if (mb_start < beg) mb_start = beg; if (MB_CUR_MAX == 1 || !is_mb_middle (&mb_start, match, buflim, kwsm.size[0])) goto success; } if (dfaexec (dfa, beg, (char *) end, 0, NULL, &backref) == NULL) continue; } else { /* No good fixed strings; start with DFA. */ char const *next_beg = dfaexec (dfa, beg, (char *) buflim, 0, NULL, &backref); /* If there's no match, or if we've matched the sentinel, we're done. */ if (next_beg == NULL || next_beg == buflim) break; /* Narrow down to the line we've found. */ beg = next_beg; if ((end = memchr(beg, eol, buflim - beg)) != NULL) end++; else end = buflim; while (beg > buf && beg[-1] != eol) --beg; } /* Successful, no backreferences encountered! */ if (!backref) goto success; } else { /* We are looking for the leftmost (then longest) exact match. We will go through the outer loop only once. */ beg = start_ptr; end = buflim; } /* If the "line" is longer than the maximum regexp offset, die as if we've run out of memory. */ if (TYPE_MAXIMUM (regoff_t) < end - buf - 1) xalloc_die (); /* If we've made it to this point, this means DFA has seen a probable match, and we need to run it through Regex. */ best_match = end; best_len = 0; for (i = 0; i < pcount; i++) { patterns[i].regexbuf.not_eol = 0; start = re_search (&(patterns[i].regexbuf), buf, end - buf - 1, beg - buf, end - beg - 1, &(patterns[i].regs)); if (start < -1) xalloc_die (); else if (0 <= start) { len = patterns[i].regs.end[0] - start; match = buf + start; if (match > best_match) continue; if (start_ptr && !match_words) goto assess_pattern_match; if ((!match_lines && !match_words) || (match_lines && len == end - beg - 1)) { match = beg; len = end - beg; goto assess_pattern_match; } /* If -w, check if the match aligns with word boundaries. We do this iteratively because: (a) the line may contain more than one occurrence of the pattern, and (b) Several alternatives in the pattern might be valid at a given point, and we may need to consider a shorter one to find a word boundary. */ if (match_words) while (match <= best_match) { regoff_t shorter_len = 0; if ((match == buf || !WCHAR ((unsigned char) match[-1])) && (start + len == end - buf - 1 || !WCHAR ((unsigned char) match[len]))) goto assess_pattern_match; if (len > 0) { /* Try a shorter length anchored at the same place. */ --len; patterns[i].regexbuf.not_eol = 1; shorter_len = re_match (&(patterns[i].regexbuf), buf, match + len - beg, match - buf, &(patterns[i].regs)); if (shorter_len < -1) xalloc_die (); } if (0 < shorter_len) len = shorter_len; else { /* Try looking further on. */ if (match == end - 1) break; match++; patterns[i].regexbuf.not_eol = 0; start = re_search (&(patterns[i].regexbuf), buf, end - buf - 1, match - buf, end - match - 1, &(patterns[i].regs)); if (start < 0) { if (start < -1) xalloc_die (); break; } len = patterns[i].regs.end[0] - start; match = buf + start; } } /* while (match <= best_match) */ continue; assess_pattern_match: if (!start_ptr) { /* Good enough for a non-exact match. No need to look at further patterns, if any. */ goto success; } if (match < best_match || (match == best_match && len > best_len)) { /* Best exact match: leftmost, then longest. */ best_match = match; best_len = len; } } /* if re_search >= 0 */ } /* for Regex patterns. */ if (best_match < end) { /* We have found an exact match. We were just waiting for the best one (leftmost then longest). */ beg = best_match; len = best_len; goto success_in_len; } } /* for (beg = end ..) */ failure: ret_val = -1; goto out; success: len = end - beg; success_in_len:; size_t off = beg - buf; mb_case_map_apply (map, &off, &len); *match_size = len; ret_val = off; out: return ret_val; }
Lisp_Object get_doc_string (Lisp_Object filepos, bool unibyte, bool definition) { char *from, *to, *name, *p, *p1; int fd; int offset; EMACS_INT position; Lisp_Object file, tem, pos; ptrdiff_t count; USE_SAFE_ALLOCA; if (INTEGERP (filepos)) { file = Vdoc_file_name; pos = filepos; } else if (CONSP (filepos)) { file = XCAR (filepos); pos = XCDR (filepos); } else return Qnil; position = eabs (XINT (pos)); if (!STRINGP (Vdoc_directory)) return Qnil; if (!STRINGP (file)) return Qnil; /* Put the file name in NAME as a C string. If it is relative, combine it with Vdoc_directory. */ tem = Ffile_name_absolute_p (file); file = ENCODE_FILE (file); Lisp_Object docdir = NILP (tem) ? ENCODE_FILE (Vdoc_directory) : empty_unibyte_string; ptrdiff_t docdir_sizemax = SBYTES (docdir) + 1; #ifndef CANNOT_DUMP docdir_sizemax = max (docdir_sizemax, sizeof sibling_etc); #endif name = SAFE_ALLOCA (docdir_sizemax + SBYTES (file)); lispstpcpy (lispstpcpy (name, docdir), file); fd = emacs_open (name, O_RDONLY, 0); if (fd < 0) { #ifndef CANNOT_DUMP if (!NILP (Vpurify_flag)) { /* Preparing to dump; DOC file is probably not installed. So check in ../etc. */ lispstpcpy (stpcpy (name, sibling_etc), file); fd = emacs_open (name, O_RDONLY, 0); } #endif if (fd < 0) { if (errno == EMFILE || errno == ENFILE) report_file_error ("Read error on documentation file", file); SAFE_FREE (); AUTO_STRING (cannot_open, "Cannot open doc string file \""); AUTO_STRING (quote_nl, "\"\n"); return concat3 (cannot_open, file, quote_nl); } } count = SPECPDL_INDEX (); record_unwind_protect_int (close_file_unwind, fd); /* Seek only to beginning of disk block. */ /* Make sure we read at least 1024 bytes before `position' so we can check the leading text for consistency. */ offset = min (position, max (1024, position % (8 * 1024))); if (TYPE_MAXIMUM (off_t) < position || lseek (fd, position - offset, 0) < 0) error ("Position %"pI"d out of range in doc string file \"%s\"", position, name); /* Read the doc string into get_doc_string_buffer. P points beyond the data just read. */ p = get_doc_string_buffer; while (1) { ptrdiff_t space_left = (get_doc_string_buffer_size - 1 - (p - get_doc_string_buffer)); int nread; /* Allocate or grow the buffer if we need to. */ if (space_left <= 0) { ptrdiff_t in_buffer = p - get_doc_string_buffer; get_doc_string_buffer = xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size, 16 * 1024, -1, 1); p = get_doc_string_buffer + in_buffer; space_left = (get_doc_string_buffer_size - 1 - (p - get_doc_string_buffer)); } /* Read a disk block at a time. If we read the same block last time, maybe skip this? */ if (space_left > 1024 * 8) space_left = 1024 * 8; nread = emacs_read (fd, p, space_left); if (nread < 0) report_file_error ("Read error on documentation file", file); p[nread] = 0; if (!nread) break; if (p == get_doc_string_buffer) p1 = strchr (p + offset, '\037'); else p1 = strchr (p, '\037'); if (p1) { *p1 = 0; p = p1; break; } p += nread; } unbind_to (count, Qnil); SAFE_FREE (); /* Sanity checking. */ if (CONSP (filepos)) { int test = 1; /* A dynamic docstring should be either at the very beginning of a "#@ comment" or right after a dynamic docstring delimiter (in case we pack several such docstrings within the same comment). */ if (get_doc_string_buffer[offset - test] != '\037') { if (get_doc_string_buffer[offset - test++] != ' ') return Qnil; while (get_doc_string_buffer[offset - test] >= '0' && get_doc_string_buffer[offset - test] <= '9') test++; if (get_doc_string_buffer[offset - test++] != '@' || get_doc_string_buffer[offset - test] != '#') return Qnil; } } else { int test = 1; if (get_doc_string_buffer[offset - test++] != '\n') return Qnil; while (get_doc_string_buffer[offset - test] > ' ') test++; if (get_doc_string_buffer[offset - test] != '\037') return Qnil; } /* Scan the text and perform quoting with ^A (char code 1). ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */ from = get_doc_string_buffer + offset; to = get_doc_string_buffer + offset; while (from != p) { if (*from == 1) { int c; from++; c = *from++; if (c == 1) *to++ = c; else if (c == '0') *to++ = 0; else if (c == '_') *to++ = 037; else { unsigned char uc = c; error ("\ Invalid data in documentation file -- %c followed by code %03o", 1, uc); } } else *to++ = *from++; } /* If DEFINITION, read from this buffer the same way we would read bytes from a file. */ if (definition) { read_bytecode_pointer = (unsigned char *) get_doc_string_buffer + offset; return Fread (Qlambda); } if (unibyte) return make_unibyte_string (get_doc_string_buffer + offset, to - (get_doc_string_buffer + offset)); else { /* The data determines whether the string is multibyte. */ ptrdiff_t nchars = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer + offset), to - (get_doc_string_buffer + offset)); return make_string_from_bytes (get_doc_string_buffer + offset, nchars, to - (get_doc_string_buffer + offset)); } }