13be6ef06SEitan Adler /* 23be6ef06SEitan Adler * Top users/processes display for Unix 33be6ef06SEitan Adler * Version 3 43be6ef06SEitan Adler * 53be6ef06SEitan Adler * This program may be freely redistributed, 63be6ef06SEitan Adler * but this entire comment MUST remain intact. 73be6ef06SEitan Adler * 83be6ef06SEitan Adler * Copyright (c) 1984, 1989, William LeFebvre, Rice University 93be6ef06SEitan Adler * Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University 103be6ef06SEitan Adler * 113be6ef06SEitan Adler * $FreeBSD$ 123be6ef06SEitan Adler */ 133be6ef06SEitan Adler 143be6ef06SEitan Adler /* 153be6ef06SEitan Adler * This file contains various handy utilities used by top. 163be6ef06SEitan Adler */ 173be6ef06SEitan Adler 183be6ef06SEitan Adler #include "top.h" 19caee4883SEitan Adler 20caee4883SEitan Adler #include <stdlib.h> 21caee4883SEitan Adler #include <stdio.h> 22caee4883SEitan Adler #include <string.h> 233be6ef06SEitan Adler 24b3c88c28SEitan Adler int 25b3c88c28SEitan Adler atoiwi(char *str) 263be6ef06SEitan Adler { 2798c299e0SEitan Adler int len; 283be6ef06SEitan Adler 293be6ef06SEitan Adler len = strlen(str); 303be6ef06SEitan Adler if (len != 0) 313be6ef06SEitan Adler { 323be6ef06SEitan Adler if (strncmp(str, "infinity", len) == 0 || 333be6ef06SEitan Adler strncmp(str, "all", len) == 0 || 343be6ef06SEitan Adler strncmp(str, "maximum", len) == 0) 353be6ef06SEitan Adler { 363be6ef06SEitan Adler return(Infinity); 373be6ef06SEitan Adler } 383be6ef06SEitan Adler else if (str[0] == '-') 393be6ef06SEitan Adler { 403be6ef06SEitan Adler return(Invalid); 413be6ef06SEitan Adler } 423be6ef06SEitan Adler else 433be6ef06SEitan Adler { 443be6ef06SEitan Adler return(atoi(str)); 453be6ef06SEitan Adler } 463be6ef06SEitan Adler } 473be6ef06SEitan Adler return(0); 483be6ef06SEitan Adler } 493be6ef06SEitan Adler 503be6ef06SEitan Adler /* 513be6ef06SEitan Adler * itoa - convert integer (decimal) to ascii string for positive numbers 523be6ef06SEitan Adler * only (we don't bother with negative numbers since we know we 533be6ef06SEitan Adler * don't use them). 543be6ef06SEitan Adler */ 553be6ef06SEitan Adler 563be6ef06SEitan Adler /* 573be6ef06SEitan Adler * How do we know that 16 will suffice? 583be6ef06SEitan Adler * Because the biggest number that we will 593be6ef06SEitan Adler * ever convert will be 2^32-1, which is 10 603be6ef06SEitan Adler * digits. 613be6ef06SEitan Adler */ 623be6ef06SEitan Adler _Static_assert(sizeof(int) <= 4, "buffer too small for this sized int"); 633be6ef06SEitan Adler 643be6ef06SEitan Adler char *itoa(val) 653be6ef06SEitan Adler 6698c299e0SEitan Adler int val; 673be6ef06SEitan Adler 683be6ef06SEitan Adler { 6998c299e0SEitan Adler char *ptr; 703be6ef06SEitan Adler static char buffer[16]; /* result is built here */ 713be6ef06SEitan Adler /* 16 is sufficient since the largest number 723be6ef06SEitan Adler we will ever convert will be 2^32-1, 733be6ef06SEitan Adler which is 10 digits. */ 743be6ef06SEitan Adler 753be6ef06SEitan Adler ptr = buffer + sizeof(buffer); 763be6ef06SEitan Adler *--ptr = '\0'; 773be6ef06SEitan Adler if (val == 0) 783be6ef06SEitan Adler { 793be6ef06SEitan Adler *--ptr = '0'; 803be6ef06SEitan Adler } 813be6ef06SEitan Adler else while (val != 0) 823be6ef06SEitan Adler { 833be6ef06SEitan Adler *--ptr = (val % 10) + '0'; 843be6ef06SEitan Adler val /= 10; 853be6ef06SEitan Adler } 863be6ef06SEitan Adler return(ptr); 873be6ef06SEitan Adler } 883be6ef06SEitan Adler 893be6ef06SEitan Adler /* 903be6ef06SEitan Adler * itoa7(val) - like itoa, except the number is right justified in a 7 913be6ef06SEitan Adler * character field. This code is a duplication of itoa instead of 923be6ef06SEitan Adler * a front end to a more general routine for efficiency. 933be6ef06SEitan Adler */ 943be6ef06SEitan Adler 953be6ef06SEitan Adler char *itoa7(val) 963be6ef06SEitan Adler 9798c299e0SEitan Adler int val; 983be6ef06SEitan Adler 993be6ef06SEitan Adler { 10098c299e0SEitan Adler char *ptr; 1013be6ef06SEitan Adler static char buffer[16]; /* result is built here */ 1023be6ef06SEitan Adler /* 16 is sufficient since the largest number 1033be6ef06SEitan Adler we will ever convert will be 2^32-1, 1043be6ef06SEitan Adler which is 10 digits. */ 1053be6ef06SEitan Adler 1063be6ef06SEitan Adler ptr = buffer + sizeof(buffer); 1073be6ef06SEitan Adler *--ptr = '\0'; 1083be6ef06SEitan Adler if (val == 0) 1093be6ef06SEitan Adler { 1103be6ef06SEitan Adler *--ptr = '0'; 1113be6ef06SEitan Adler } 1123be6ef06SEitan Adler else while (val != 0) 1133be6ef06SEitan Adler { 1143be6ef06SEitan Adler *--ptr = (val % 10) + '0'; 1153be6ef06SEitan Adler val /= 10; 1163be6ef06SEitan Adler } 1173be6ef06SEitan Adler while (ptr > buffer + sizeof(buffer) - 7) 1183be6ef06SEitan Adler { 1193be6ef06SEitan Adler *--ptr = ' '; 1203be6ef06SEitan Adler } 1213be6ef06SEitan Adler return(ptr); 1223be6ef06SEitan Adler } 1233be6ef06SEitan Adler 1243be6ef06SEitan Adler /* 1253be6ef06SEitan Adler * digits(val) - return number of decimal digits in val. Only works for 1263be6ef06SEitan Adler * positive numbers. If val <= 0 then digits(val) == 0. 1273be6ef06SEitan Adler */ 1283be6ef06SEitan Adler 1293be6ef06SEitan Adler int digits(val) 1303be6ef06SEitan Adler 1313be6ef06SEitan Adler int val; 1323be6ef06SEitan Adler 1333be6ef06SEitan Adler { 13498c299e0SEitan Adler int cnt = 0; 1353be6ef06SEitan Adler 1363be6ef06SEitan Adler while (val > 0) 1373be6ef06SEitan Adler { 1383be6ef06SEitan Adler cnt++; 1393be6ef06SEitan Adler val /= 10; 1403be6ef06SEitan Adler } 1413be6ef06SEitan Adler return(cnt); 1423be6ef06SEitan Adler } 1433be6ef06SEitan Adler 1443be6ef06SEitan Adler /* 1453be6ef06SEitan Adler * strecpy(to, from) - copy string "from" into "to" and return a pointer 1463be6ef06SEitan Adler * to the END of the string "to". 1473be6ef06SEitan Adler */ 1483be6ef06SEitan Adler 149b3c88c28SEitan Adler char * 150b3c88c28SEitan Adler strecpy(char *to, char *from) 1513be6ef06SEitan Adler { 1523be6ef06SEitan Adler while ((*to++ = *from++) != '\0'); 1533be6ef06SEitan Adler return(--to); 1543be6ef06SEitan Adler } 1553be6ef06SEitan Adler 1563be6ef06SEitan Adler /* 1573be6ef06SEitan Adler * string_index(string, array) - find string in array and return index 1583be6ef06SEitan Adler */ 1593be6ef06SEitan Adler 1603be6ef06SEitan Adler int string_index(string, array) 1613be6ef06SEitan Adler 1623be6ef06SEitan Adler char *string; 1633be6ef06SEitan Adler char **array; 1643be6ef06SEitan Adler 1653be6ef06SEitan Adler { 16698c299e0SEitan Adler int i = 0; 1673be6ef06SEitan Adler 1683be6ef06SEitan Adler while (*array != NULL) 1693be6ef06SEitan Adler { 1703be6ef06SEitan Adler if (strcmp(string, *array) == 0) 1713be6ef06SEitan Adler { 1723be6ef06SEitan Adler return(i); 1733be6ef06SEitan Adler } 1743be6ef06SEitan Adler array++; 1753be6ef06SEitan Adler i++; 1763be6ef06SEitan Adler } 1773be6ef06SEitan Adler return(-1); 1783be6ef06SEitan Adler } 1793be6ef06SEitan Adler 1803be6ef06SEitan Adler /* 1813be6ef06SEitan Adler * argparse(line, cntp) - parse arguments in string "line", separating them 1823be6ef06SEitan Adler * out into an argv-like array, and setting *cntp to the number of 1833be6ef06SEitan Adler * arguments encountered. This is a simple parser that doesn't understand 1843be6ef06SEitan Adler * squat about quotes. 1853be6ef06SEitan Adler */ 1863be6ef06SEitan Adler 1873be6ef06SEitan Adler char **argparse(line, cntp) 1883be6ef06SEitan Adler 1893be6ef06SEitan Adler char *line; 1903be6ef06SEitan Adler int *cntp; 1913be6ef06SEitan Adler 1923be6ef06SEitan Adler { 19398c299e0SEitan Adler char *from; 19498c299e0SEitan Adler char *to; 19598c299e0SEitan Adler int cnt; 19698c299e0SEitan Adler int ch; 1973be6ef06SEitan Adler int length; 1983be6ef06SEitan Adler int lastch; 19998c299e0SEitan Adler char **argv; 2003be6ef06SEitan Adler char **argarray; 2013be6ef06SEitan Adler char *args; 2023be6ef06SEitan Adler 2033be6ef06SEitan Adler /* unfortunately, the only real way to do this is to go thru the 2043be6ef06SEitan Adler input string twice. */ 2053be6ef06SEitan Adler 2063be6ef06SEitan Adler /* step thru the string counting the white space sections */ 2073be6ef06SEitan Adler from = line; 2083be6ef06SEitan Adler lastch = cnt = length = 0; 2093be6ef06SEitan Adler while ((ch = *from++) != '\0') 2103be6ef06SEitan Adler { 2113be6ef06SEitan Adler length++; 2123be6ef06SEitan Adler if (ch == ' ' && lastch != ' ') 2133be6ef06SEitan Adler { 2143be6ef06SEitan Adler cnt++; 2153be6ef06SEitan Adler } 2163be6ef06SEitan Adler lastch = ch; 2173be6ef06SEitan Adler } 2183be6ef06SEitan Adler 2193be6ef06SEitan Adler /* add three to the count: one for the initial "dummy" argument, 2203be6ef06SEitan Adler one for the last argument and one for NULL */ 2213be6ef06SEitan Adler cnt += 3; 2223be6ef06SEitan Adler 2233be6ef06SEitan Adler /* allocate a char * array to hold the pointers */ 2243be6ef06SEitan Adler argarray = (char **)malloc(cnt * sizeof(char *)); 2253be6ef06SEitan Adler 2263be6ef06SEitan Adler /* allocate another array to hold the strings themselves */ 2273be6ef06SEitan Adler args = (char *)malloc(length+2); 2283be6ef06SEitan Adler 2293be6ef06SEitan Adler /* initialization for main loop */ 2303be6ef06SEitan Adler from = line; 2313be6ef06SEitan Adler to = args; 2323be6ef06SEitan Adler argv = argarray; 2333be6ef06SEitan Adler lastch = '\0'; 2343be6ef06SEitan Adler 2353be6ef06SEitan Adler /* create a dummy argument to keep getopt happy */ 2363be6ef06SEitan Adler *argv++ = to; 2373be6ef06SEitan Adler *to++ = '\0'; 2383be6ef06SEitan Adler cnt = 2; 2393be6ef06SEitan Adler 2403be6ef06SEitan Adler /* now build argv while copying characters */ 2413be6ef06SEitan Adler *argv++ = to; 2423be6ef06SEitan Adler while ((ch = *from++) != '\0') 2433be6ef06SEitan Adler { 2443be6ef06SEitan Adler if (ch != ' ') 2453be6ef06SEitan Adler { 2463be6ef06SEitan Adler if (lastch == ' ') 2473be6ef06SEitan Adler { 2483be6ef06SEitan Adler *to++ = '\0'; 2493be6ef06SEitan Adler *argv++ = to; 2503be6ef06SEitan Adler cnt++; 2513be6ef06SEitan Adler } 2523be6ef06SEitan Adler *to++ = ch; 2533be6ef06SEitan Adler } 2543be6ef06SEitan Adler lastch = ch; 2553be6ef06SEitan Adler } 2563be6ef06SEitan Adler *to++ = '\0'; 2573be6ef06SEitan Adler 2583be6ef06SEitan Adler /* set cntp and return the allocated array */ 2593be6ef06SEitan Adler *cntp = cnt; 2603be6ef06SEitan Adler return(argarray); 2613be6ef06SEitan Adler } 2623be6ef06SEitan Adler 2633be6ef06SEitan Adler /* 2643be6ef06SEitan Adler * percentages(cnt, out, new, old, diffs) - calculate percentage change 2653be6ef06SEitan Adler * between array "old" and "new", putting the percentages i "out". 2663be6ef06SEitan Adler * "cnt" is size of each array and "diffs" is used for scratch space. 2673be6ef06SEitan Adler * The array "old" is updated on each call. 2683be6ef06SEitan Adler * The routine assumes modulo arithmetic. This function is especially 2693be6ef06SEitan Adler * useful on BSD mchines for calculating cpu state percentages. 2703be6ef06SEitan Adler */ 2713be6ef06SEitan Adler 2723be6ef06SEitan Adler long percentages(cnt, out, new, old, diffs) 2733be6ef06SEitan Adler 2743be6ef06SEitan Adler int cnt; 2753be6ef06SEitan Adler int *out; 27698c299e0SEitan Adler long *new; 27798c299e0SEitan Adler long *old; 2783be6ef06SEitan Adler long *diffs; 2793be6ef06SEitan Adler 2803be6ef06SEitan Adler { 28198c299e0SEitan Adler int i; 28298c299e0SEitan Adler long change; 28398c299e0SEitan Adler long total_change; 28498c299e0SEitan Adler long *dp; 2853be6ef06SEitan Adler long half_total; 2863be6ef06SEitan Adler 2873be6ef06SEitan Adler /* initialization */ 2883be6ef06SEitan Adler total_change = 0; 2893be6ef06SEitan Adler dp = diffs; 2903be6ef06SEitan Adler 2913be6ef06SEitan Adler /* calculate changes for each state and the overall change */ 2923be6ef06SEitan Adler for (i = 0; i < cnt; i++) 2933be6ef06SEitan Adler { 2943be6ef06SEitan Adler if ((change = *new - *old) < 0) 2953be6ef06SEitan Adler { 2963be6ef06SEitan Adler /* this only happens when the counter wraps */ 2973be6ef06SEitan Adler change = (int) 2983be6ef06SEitan Adler ((unsigned long)*new-(unsigned long)*old); 2993be6ef06SEitan Adler } 3003be6ef06SEitan Adler total_change += (*dp++ = change); 3013be6ef06SEitan Adler *old++ = *new++; 3023be6ef06SEitan Adler } 3033be6ef06SEitan Adler 3043be6ef06SEitan Adler /* avoid divide by zero potential */ 3053be6ef06SEitan Adler if (total_change == 0) 3063be6ef06SEitan Adler { 3073be6ef06SEitan Adler total_change = 1; 3083be6ef06SEitan Adler } 3093be6ef06SEitan Adler 3103be6ef06SEitan Adler /* calculate percentages based on overall change, rounding up */ 3113be6ef06SEitan Adler half_total = total_change / 2l; 3123be6ef06SEitan Adler 3133be6ef06SEitan Adler /* Do not divide by 0. Causes Floating point exception */ 3143be6ef06SEitan Adler if(total_change) { 3153be6ef06SEitan Adler for (i = 0; i < cnt; i++) 3163be6ef06SEitan Adler { 3173be6ef06SEitan Adler *out++ = (int)((*diffs++ * 1000 + half_total) / total_change); 3183be6ef06SEitan Adler } 3193be6ef06SEitan Adler } 3203be6ef06SEitan Adler 3213be6ef06SEitan Adler /* return the total in case the caller wants to use it */ 3223be6ef06SEitan Adler return(total_change); 3233be6ef06SEitan Adler } 3243be6ef06SEitan Adler 3253be6ef06SEitan Adler /* format_time(seconds) - format number of seconds into a suitable 3263be6ef06SEitan Adler * display that will fit within 6 characters. Note that this 3273be6ef06SEitan Adler * routine builds its string in a static area. If it needs 3283be6ef06SEitan Adler * to be called more than once without overwriting previous data, 3293be6ef06SEitan Adler * then we will need to adopt a technique similar to the 3303be6ef06SEitan Adler * one used for format_k. 3313be6ef06SEitan Adler */ 3323be6ef06SEitan Adler 3333be6ef06SEitan Adler /* Explanation: 3343be6ef06SEitan Adler We want to keep the output within 6 characters. For low values we use 3353be6ef06SEitan Adler the format mm:ss. For values that exceed 999:59, we switch to a format 3363be6ef06SEitan Adler that displays hours and fractions: hhh.tH. For values that exceed 3373be6ef06SEitan Adler 999.9, we use hhhh.t and drop the "H" designator. For values that 3383be6ef06SEitan Adler exceed 9999.9, we use "???". 3393be6ef06SEitan Adler */ 3403be6ef06SEitan Adler 3413be6ef06SEitan Adler char *format_time(seconds) 3423be6ef06SEitan Adler 3433be6ef06SEitan Adler long seconds; 3443be6ef06SEitan Adler 3453be6ef06SEitan Adler { 3463be6ef06SEitan Adler static char result[10]; 3473be6ef06SEitan Adler 3483be6ef06SEitan Adler /* sanity protection */ 3493be6ef06SEitan Adler if (seconds < 0 || seconds > (99999l * 360l)) 3503be6ef06SEitan Adler { 3513be6ef06SEitan Adler strcpy(result, " ???"); 3523be6ef06SEitan Adler } 3533be6ef06SEitan Adler else if (seconds >= (1000l * 60l)) 3543be6ef06SEitan Adler { 3553be6ef06SEitan Adler /* alternate (slow) method displaying hours and tenths */ 3563be6ef06SEitan Adler sprintf(result, "%5.1fH", (double)seconds / (double)(60l * 60l)); 3573be6ef06SEitan Adler 3583be6ef06SEitan Adler /* It is possible that the sprintf took more than 6 characters. 3593be6ef06SEitan Adler If so, then the "H" appears as result[6]. If not, then there 3603be6ef06SEitan Adler is a \0 in result[6]. Either way, it is safe to step on. 3613be6ef06SEitan Adler */ 3623be6ef06SEitan Adler result[6] = '\0'; 3633be6ef06SEitan Adler } 3643be6ef06SEitan Adler else 3653be6ef06SEitan Adler { 3663be6ef06SEitan Adler /* standard method produces MMM:SS */ 3673be6ef06SEitan Adler /* we avoid printf as must as possible to make this quick */ 3683be6ef06SEitan Adler sprintf(result, "%3ld:%02ld", 3693be6ef06SEitan Adler (long)(seconds / 60), (long)(seconds % 60)); 3703be6ef06SEitan Adler } 3713be6ef06SEitan Adler return(result); 3723be6ef06SEitan Adler } 3733be6ef06SEitan Adler 3743be6ef06SEitan Adler /* 3753be6ef06SEitan Adler * format_k(amt) - format a kilobyte memory value, returning a string 3763be6ef06SEitan Adler * suitable for display. Returns a pointer to a static 3773be6ef06SEitan Adler * area that changes each call. "amt" is converted to a 3783be6ef06SEitan Adler * string with a trailing "K". If "amt" is 10000 or greater, 3793be6ef06SEitan Adler * then it is formatted as megabytes (rounded) with a 3803be6ef06SEitan Adler * trailing "M". 3813be6ef06SEitan Adler */ 3823be6ef06SEitan Adler 3833be6ef06SEitan Adler /* 3843be6ef06SEitan Adler * Compromise time. We need to return a string, but we don't want the 3853be6ef06SEitan Adler * caller to have to worry about freeing a dynamically allocated string. 3863be6ef06SEitan Adler * Unfortunately, we can't just return a pointer to a static area as one 3873be6ef06SEitan Adler * of the common uses of this function is in a large call to sprintf where 3883be6ef06SEitan Adler * it might get invoked several times. Our compromise is to maintain an 3893be6ef06SEitan Adler * array of strings and cycle thru them with each invocation. We make the 3903be6ef06SEitan Adler * array large enough to handle the above mentioned case. The constant 3913be6ef06SEitan Adler * NUM_STRINGS defines the number of strings in this array: we can tolerate 3923be6ef06SEitan Adler * up to NUM_STRINGS calls before we start overwriting old information. 3933be6ef06SEitan Adler * Keeping NUM_STRINGS a power of two will allow an intelligent optimizer 3943be6ef06SEitan Adler * to convert the modulo operation into something quicker. What a hack! 3953be6ef06SEitan Adler */ 3963be6ef06SEitan Adler 3973be6ef06SEitan Adler #define NUM_STRINGS 8 3983be6ef06SEitan Adler 3993be6ef06SEitan Adler char *format_k(amt) 4003be6ef06SEitan Adler 4013be6ef06SEitan Adler int amt; 4023be6ef06SEitan Adler 4033be6ef06SEitan Adler { 4043be6ef06SEitan Adler static char retarray[NUM_STRINGS][16]; 4053be6ef06SEitan Adler static int index = 0; 40698c299e0SEitan Adler char *p; 40798c299e0SEitan Adler char *ret; 40898c299e0SEitan Adler char tag = 'K'; 4093be6ef06SEitan Adler 4103be6ef06SEitan Adler p = ret = retarray[index]; 4113be6ef06SEitan Adler index = (index + 1) % NUM_STRINGS; 4123be6ef06SEitan Adler 4133be6ef06SEitan Adler if (amt >= 10000) 4143be6ef06SEitan Adler { 4153be6ef06SEitan Adler amt = (amt + 512) / 1024; 4163be6ef06SEitan Adler tag = 'M'; 4173be6ef06SEitan Adler if (amt >= 10000) 4183be6ef06SEitan Adler { 4193be6ef06SEitan Adler amt = (amt + 512) / 1024; 4203be6ef06SEitan Adler tag = 'G'; 4213be6ef06SEitan Adler } 4223be6ef06SEitan Adler } 4233be6ef06SEitan Adler 4243be6ef06SEitan Adler p = strecpy(p, itoa(amt)); 4253be6ef06SEitan Adler *p++ = tag; 4263be6ef06SEitan Adler *p = '\0'; 4273be6ef06SEitan Adler 4283be6ef06SEitan Adler return(ret); 4293be6ef06SEitan Adler } 4303be6ef06SEitan Adler 4313be6ef06SEitan Adler char *format_k2(amt) 4323be6ef06SEitan Adler 4333be6ef06SEitan Adler unsigned long long amt; 4343be6ef06SEitan Adler 4353be6ef06SEitan Adler { 4363be6ef06SEitan Adler static char retarray[NUM_STRINGS][16]; 4373be6ef06SEitan Adler static int index = 0; 43898c299e0SEitan Adler char *p; 43998c299e0SEitan Adler char *ret; 44098c299e0SEitan Adler char tag = 'K'; 4413be6ef06SEitan Adler 4423be6ef06SEitan Adler p = ret = retarray[index]; 4433be6ef06SEitan Adler index = (index + 1) % NUM_STRINGS; 4443be6ef06SEitan Adler 4453be6ef06SEitan Adler if (amt >= 100000) 4463be6ef06SEitan Adler { 4473be6ef06SEitan Adler amt = (amt + 512) / 1024; 4483be6ef06SEitan Adler tag = 'M'; 4493be6ef06SEitan Adler if (amt >= 100000) 4503be6ef06SEitan Adler { 4513be6ef06SEitan Adler amt = (amt + 512) / 1024; 4523be6ef06SEitan Adler tag = 'G'; 4533be6ef06SEitan Adler } 4543be6ef06SEitan Adler } 4553be6ef06SEitan Adler 4563be6ef06SEitan Adler p = strecpy(p, itoa((int)amt)); 4573be6ef06SEitan Adler *p++ = tag; 4583be6ef06SEitan Adler *p = '\0'; 4593be6ef06SEitan Adler 4603be6ef06SEitan Adler return(ret); 4613be6ef06SEitan Adler } 462