// Copy and shrink string by inserting an ellipsis in the middle (if necessary), given destination pointer, maximum destination
// length (excluding the trailing null), source pointer, and source length. Destination buffer is assumed to be at least
// maxlen + 1 bytes in size. If source length is zero, source string is assumed to be null terminated. Return dest.
char *strfit(char *destp,size_t maxlen,char *srcp,size_t srclen) {
size_t slen,len,cutsize;
char *strp,*ellipsis;
// Check for minimum shrinking parameters.
slen = (srclen == 0) ? strlen(srcp) : srclen;
if(maxlen < 5 || slen <= maxlen)
// Dest or source too short, so just copy the maximum.
(void) stplcpy(destp,srcp,(slen < maxlen ? slen : maxlen) + 1);
else {
// Determine maximum number of characters can copy from source.
if(maxlen < 30) {
ellipsis = ".."; // Use shorter ellipsis for small dest.
len = 2;
}
else {
ellipsis = "...";
len = 3;
}
cutsize = slen - maxlen + len; // Number of characters to leave out of middle of source.
len = (slen - cutsize) / 2; // Length of initial segment (half of what will be copied).
// Include white space at end first segment if present.
if(((strp = srcp + len)[0] == ' ' || strp[0] == '\t') && strp[-1] != ' ' && strp[-1] != '\t')
++len;
strp = stplcpy(destp,srcp,len + 1); // Copy initial segment.
strp = stpcpy(strp,ellipsis); // Add ellipsis.
// Copy last segment.
stplcpy(strp,srcp + cutsize + len,slen - cutsize - len + 1);
}
return destp;
}
// Check string for an identifier or keyword. If found, set *srcpp to first invalid character, set *lenp to word length (if
// lenp not NULL), and return symbol; otherwise, return s_nil.
enum e_sym getident(char **srcpp,ushort *lenp) {
int i;
ushort len;
enum e_sym sym;
char *srcp,*srcp0 = *srcpp;
if(!isident1(*srcp0))
return s_nil;
// Valid identifier found; find terminator.
srcp = srcp0 + strspn(srcp0,identchars);
// Query type?
if(*srcp == TKC_QUERY) {
*srcpp = srcp + 1;
if(lenp != NULL)
*lenp = *srcpp - srcp0;
return s_identq;
}
// Check if keyword.
sym = s_ident;
char idbuf[(len = srcp - srcp0) + 1];
stplcpy(idbuf,srcp0,len + 1);
if((i = binary(idbuf,kwname,NKEYWORDS)) >= 0) {
sym = kwtab[i].s;
if(lenp != NULL)
*lenp = len;
}
// Return results.
*srcpp = srcp;
return sym;
}
void _start(void)
{
struct utsname name;
const char text_sysname[] = "sysname: ";
const char text_nodename[] = "nodename: ";
const char text_release[] = "release: ";
const char text_version[] = "version: ";
const char text_machine[] = "machine: ";
const char text_domainname[] = "domainname: ";
char buffer[sizeof(text_sysname) + sizeof(name.sysname) +
sizeof(text_nodename) + sizeof(name.nodename) +
sizeof(text_release) + sizeof(name.release) +
sizeof(text_version) + sizeof(name.version) +
sizeof(text_machine) + sizeof(name.machine) +
sizeof(text_domainname) + sizeof(name.domainname) + 1];
char *ptr;
if (_uname(&name) < 0) {
write_string(2, "Error: uname failed\n");
exit(1);
}
ptr = buffer;
ptr = stplcpy(ptr, text_sysname, sizeof(text_sysname) - 1);
ptr = stplcpy(ptr, name.sysname, sizeof(name.sysname));
*ptr++ = '\n';
ptr = stplcpy(ptr, text_nodename, sizeof(text_nodename) - 1);
ptr = stplcpy(ptr, name.nodename, sizeof(name.nodename));
*ptr++ = '\n';
ptr = stplcpy(ptr, text_release, sizeof(text_release) - 1);
ptr = stplcpy(ptr, name.release, sizeof(name.release));
*ptr++ = '\n';
ptr = stplcpy(ptr, text_version, sizeof(text_version) - 1);
ptr = stplcpy(ptr, name.version, sizeof(name.version));
*ptr++ = '\n';
ptr = stplcpy(ptr, text_machine, sizeof(text_machine) - 1);
ptr = stplcpy(ptr, name.machine, sizeof(name.machine));
*ptr++ = '\n';
ptr = stplcpy(ptr, text_domainname, sizeof(text_domainname) - 1);
ptr = stplcpy(ptr, name.domainname, sizeof(name.domainname));
*ptr++ = '\n';
write_all(1, buffer, (size_t)(ptr - buffer));
exit(0);
}
