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