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