 |
mxLib.c |
/* mxLib.c */
void bcopy(const void *s, void *d, unsigned long n)
/* byte-weises Kopieren, vom Compiler zur Optimierung benutzt */
{
const char *chars = s;
char *chard = d;
if (chars > chard)
while (n--) {
*chard++ = *chars++;
}
else
{
chars += n;
chard += n;
while (n--)
*--chard = *--chars;
}
}
void *memcpy(void *t, const void *f, unsigned long n)
/* Ersatz fuer libc-memcpy (nicht 100% POSIX oder ANSI) */
{
char *p = t;
bcopy(f, t, n);
return (p);
} /* memcpy */
void *memset (void *s, int c, unsigned long n)
/* Ersatz fuer libc-memset (nicht 100% POSIX oder ANSI) */
{
char *p = s;
while (n--) *p++ = (char)c;
return s;
}
char *strcpy(char *d, const char *s)
/* einen String kopieren */
{
char *rval = d;
while((*d++ = *s++));
return(rval);
} /* strcpy */
char *strncpy(char *d, const char *s, int len)
/* genau n Zeichen kopieren, ggf. Nullen auffüllen */
{
char *rval = d;
while(len-- > 0 && (*d++ = *s++));
while(len-- > 0) *d++ = 0;
return(rval);
} /* strcpy */
int strcmp(const char *dest, const char *src)
/* zwei Strings vergleichen */
{
while (*dest && (*dest == *src)) {
dest++;
src++;
}
return(*dest - *src);
} /* strcpy */
int strncmp(const char *dest, const char *src, int n)
/* zwei Strings vergleichen, max. n Bytes oder bis '\0' */
{
while (--n > 0 && *dest && (*dest == *src)) {
dest++;
src++;
}
return(*dest - *src);
} /* strncmp */
int strlen(const char *s)
/* Laenge eines Strings bestimmen */
{
register int n;
for(n = 0; *s++; n++);
return(n);
}
int atoi(const char *s)
/* Dezimalzahl in int wandeln */
{
unsigned val = 0;
int neg = 0;
while (*s == ' ' || *s == '\t') s++;
if (*s == '-') s++, neg = 1;
while (*s >= '0' && *s <= '9') val = 10 * val + (*s++ - '0');
return neg? -(int)val : (int)val;
}
static int unsigned_to_str(char *s, int maxlen, unsigned value, int base)
/*
* unsigned_to_str - konvertiere den unsigned-Wert `value' mit der Basis
* `base' in einen String, der mit maximal `maxlen' Zeichen in
* dem array abgelegt wird, auf das `s' zeigt. Der String, auf den
* `s' zeigt, wird nicht null-terminiert.
* Rueckgabewert ist die Anzahl der Zeichen, die in `s'
* gespeichert wurden.
*/
{
char field[32]; /* Zwischenspeicher */
char *orig_s = s; /* zur Berechnung der konvertierten Zeichen */
char *limit = s + maxlen; /* zeigt hinter das letzte benutzbare Zeichen */
char *f = field + sizeof(field); /* zeigt hinter das Ende von `field' */
char c;
if (value == 0) /* bei Wert == 0 ist die Konvertierung simpel */
{
if (maxlen > 0)
{
*s = '0';
return 1;
}
else
return 0;
}
else
{
while (value > 0) /* die konvertierten Zeichen werden vom Ende */
{ /* her in `field' geschrieben */
c = value % base;
value /= base;
if (c <= 9)
*--f = c + '0';
else
*--f = c - 10 + 'a';
}
while (f < field + sizeof(field) && s < limit) /* nun werden die Zeichen an den Anfang von `s' */
*s++ = *f++; /* kopiert */
return s - orig_s; /* Anzahl der Zeichen zurueckgeben */
}
}
static void pad_string(char **dest, char *last, int count, int filler)
/*
* pad_string - schreibt `count'-mal das Zeichen `filler' in den
* String, auf den `*dest' zeigt und erhoeht `*dest' um den
* entsprechenden Betrag. Maximal werden aber soviele Zeichen
* geschrieben, dass `*dest' nicht hinter `last' zeigt.
*/
{
char *s = *dest;
while (count > 0 && s < last)
{
*s++ = filler;
count--;
}
*dest = s;
}
int vsnprintf(char *dest, int maxlen, char *format, int *argp)
/*
* vsnprintf - Dies ist das Arbeitstier der printf-Familie.
* `dest' ist der String, in den die formatierte Ausgabe
* geschrieben wird, dabei werden maximal `maxlen' Zeichen
* geschrieben, einschliesslich eines abschliessenden Nullbytes.
* `format' ist der Formatstring und `argp' zeigt auf das erste
* Argument der variablen Parameterliste hinter dem Formatstring.
* Rueckgabewert ist die Anzahl der insgesamt geschriebenen
* Zeichen, einschliesslich des Nullbytes am Ende. Der
* Ergebnisstring ist immer Null-terminiert.
*/
{
char field[32]; /* zum Formatieren der Zahlen */
char *orig_dest = dest; /* zur Berechnug der Zeichenanzahl */
char *last = dest + (maxlen - 1); /* letzte benutzbare Speicherstelle */
char c; /* zum Speichern eines char-Parameters */
char *s; /* Laufvariable */
int len; /* temp. Variable */
int width; /* Breite der Ausgabe */
int d; /* zum Speichern eines int-Parameters */
int u; /* zum Speichern eines unsigned-Parameters */
int left_justify; /* linksbuendige Ausgabe */
int filler; /* Zeichen zur buendigen Ausgabe */
int alternate; /* Alternative Darstellung (man -s 3s printf) */
int use_sign; /* immer Vorzeichen drucken */
while (*format)
{
switch (*format)
{
case '%':
format++; /* Formatanweisung ueberspringen */
if (*format == '#') /* alternative Darstellungsform */
{
alternate = 1;
format++;
}
else
alternate = 0;
if (!*format) /* Abruch der Schleife */
continue;
if (*format == '-') /* linksbuendige Ausgabe */
{
left_justify = 1;
format++;
}
else
left_justify = 0;
if (!*format) /* Abruch der Schleife */
continue;
if (*format == '+') /* immer Vorzeichen ausgeben */
{
use_sign = 1;
format++;
}
else
use_sign = 0;
if (!*format) /* Abruch der Schleife */
continue;
if (*format == '0') /* fuehrende Nullen fuer's padding */
{
filler = '0';
format++;
}
else
filler = ' ';
if (!*format) /* Abruch der Schleife */
continue;
if (*format >= '0' && *format <= '9') /* Breite der Ausgabe */
{
width = *format - '0';
format++;
while (*format >= '0' && *format <= '9')
{
width = width * 10 + (*format - '0');
format++;
}
}
else
width = 0;
if (!*format) /* Abbruch der Schleife */
continue;
switch (*format)
{
case 'c': /* character */
c = (char) *argp;
argp++;
width--;
if (!left_justify)
pad_string(&dest, last, width, ' ');
if (dest < last)
*dest++ = c;
if (left_justify)
pad_string(&dest, last, width, ' ');
break;
case 's': /* string */
s = (char *) *argp;
argp++;
len = strlen(s);
width -= len;
if (!left_justify)
pad_string(&dest, last, width, ' ');
while (*s && dest < last)
*dest++ = *s++;
if (left_justify)
pad_string(&dest, last, width, ' ');
break;
case 'd': /* signed integer */
case 'i':
d = (int) *argp;
argp++;
if (dest < last)
{
if (d < 0)
{
*dest++ = '-';
d = -d;
width--;
}
else if (use_sign)
{
*dest++ = '+';
width--;
}
len = unsigned_to_str(field, sizeof(field) - 1, d, 10);
field[len] = '\0';
width -= len;
if (!left_justify)
pad_string(&dest, last, width, filler);
s = field;
while (*s && dest < last)
*dest++ = *s++;
if (left_justify)
pad_string(&dest, last, width, filler);
}
break;
case 'u': /* unsigned integer */
u = (unsigned int) *argp;
argp++;
len = unsigned_to_str(field, sizeof(field) - 1, u, 10);
field[len] = '\0';
width -= len;
if (!left_justify)
pad_string(&dest, last, width, filler);
s = field;
while (*s && dest < last)
*dest++ = *s++;
if (left_justify)
pad_string(&dest, last, width, filler);
break;
case 'o': /* integer, Oktaldarstellung */
u = (int) *argp;
argp++;
len = unsigned_to_str(field, sizeof(field) - 1, u, 8);
field[len] = '\0';
width -= len;
if (alternate)
width--;
if (!left_justify)
pad_string(&dest, last, width, filler);
if (alternate)
if (dest < last)
*dest++ = '0';
s = field;
while (*s && dest < last)
*dest++ = *s++;
if (left_justify)
pad_string(&dest, last, width, filler);
break;
case 'p': /* pointer */
filler = '0';
width = 10;
alternate = 1; /* FALLTHRU!!! */
case 'x': /* integer, Hexdarstellung */
d = (int) *argp;
argp++;
len = unsigned_to_str(field, sizeof(field) - 1, d, 16);
field[len] = '\0';
width -= len;
if (alternate)
{
width -= 2;
if (dest < last)
*dest++ = '0';
if (dest < last)
*dest++ = 'x';
}
if (!left_justify)
pad_string(&dest, last, width, filler);
s = field;
while (*s && dest < last)
*dest++ = *s++;
if (left_justify)
pad_string(&dest, last, width, filler);
break;
default: /* alle anderen Formatangaben einfach kopieren, */
if (dest < last) /* z.B. bei `%%' */
*dest++ = *format;
break;
}
break;
default: /* Zeichen ohne `%' normal kopieren */
if (dest < last)
*dest++ = *format;
break;
}
format++;
}
*dest++ = '\0'; /* String terminieren */
return dest - orig_dest; /* Anzahl der konvertierten Zeichen zurueck */
}
int sprintf(char *dest, char *format, ...)
/*
* sprintf - formatiert den Formatstring `format' und die Argumente
* in der variablen Parameterliste in den String `dest'.
* ACHTUNG: sprintf() ist nicht sicher, es kann leicht zu
* buffer overflows kommen. Besser snprintf() (s.u.)
* benutzen
*/
{
return vsnprintf(dest, 1024 * 4, format, ((int *) &format) + 1);
}
int snprintf(char *dest, int maxlen, char *format, ...)
/*
* sprintf - formatiert den Formatstring `format' und die Argumente
* in der variablen Parameterliste in den String `dest', wobei
* maximal `maxlen' Zeichen in `dest' belegt werden.
*/
{
return vsnprintf(dest, maxlen, format, ((int *) &format) + 1);
}
int atexit(void (*function)(void))
{
(*function)(); /* Ruft die Destruktorenfunktion der libgcc auf */
return 0;
}
Bei Problemen mit der Seite bitte eine Mail an Marek
Converted with C2HTML V0.669 by Iluvatar
Prozeßdatenverarbeitung