This is utils.c in view mode; [Download] [Up]
/* $Id: utils.c,v 2.7 1993/06/04 14:46:52 klute Exp klute $ */
/*
* Copyright 1993 Rainer Klute <klute@irb.informatik.uni-dortmund.de>
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation. The author makes no representations about the suitability
* of this software for any purpose. It is provided "as is" without express
* or implied warranty.
*
*/
#include <ctype.h>
#ifdef __NeXT__
#include <stdlib.h>
#include <stdio.h>
#include <strings.h>
#else
#include <malloc.h>
#endif
#include "message.h"
#include "utils.h"
#ifdef __NeXT__
/*
* strdup
*/
char *strdup (char *s)
{
char *r = malloc (strlen (s) + 1);
if (r == (char *) 0)
return r;
strcpy (r, s);
return r;
}
#endif
/*
* strreplace
*/
static char *strreplace (char *s, int from, int length, char *replacement)
{
char *r = malloc (strlen (s) + 1 + strlen (replacement) + 1);
if (r == (char *) 0)
return r;
strncpy (r, s, from);
r[from] = '\0';
strcat (r, replacement);
strcat (r, s + from + length);
return r;
}
/*
* AbkuerzungenExpandieren
*/
char *AbkuerzungenExpandieren (char *strasse, Shortcut *abk)
{
Boolean done = False;
char *p;
char *s = strdup (strasse);
char *sn;
Shortcut *a;
if (s == (char *) 0)
return s;
while (!done)
{
done = True;
for (a = abk; a->str_short != (char *) 0 && a->str_long != (char *) 0;
a++)
{
p = strstr (s, a->str_short);
if (p != (char *) 0)
{
done = False;
sn = strreplace (s, p - s, strlen (a->str_short), a->str_long);
free (s);
s = sn;
}
}
}
return s;
}
/*
* ColumnReplace
*/
char *ColumnReplace (char* record, int column, char separator,
char*replacement)
{
int numFields;
int i;
char *s;
char *result = (char *) malloc (strlen (record) + strlen (replacement) + 1);
if (result == (char *) 0)
return result;
for (numFields = 1, s = record; *s; s++)
if (*s == separator)
numFields++;
result[0] = '\0';
for (i = 1; i <= numFields; i++)
{
if (i != column)
{
s = ReadSeparatedField (record, i, separator);
strcat (result, s);
free (s);
}
else
strcat (result, replacement);
if (i < numFields)
sprintf (result, "%s%c", result, separator);
}
return result;
}
/*
* "CStringToFixed" konvertiert einen C-String in einen Satz fester Länge. Der
* Ergebnisstring sollte nach Gebrauch mittels "free" wieder freigegeben
* werden.
*/
char *CStringToFixed (char *s, int length)
{
char *result = (char *) malloc (length + 1);
char *r = result;
if (result == (char *) 0)
{
OutOfMemory ("CStringToFixed");
return (char *) 0;
}
for (; *s && length > 0; length--)
*r++ = *s++;
for (; length > 0; length--)
*r++ = ' ';
*r = '\0';
return result;
}
#if defined (HANDLE_BROKEN_DATAFILES)
/*
* "IbmAndBrokenToIso" konvertiert einen C-String mit IBM-Umlauten (und solchen
* vom Atari ST) nach ISO-8859-1. Die Funktion akzeptiert auch die
* "verkrüppelte 7-Bit-Darstellung der Umlaute. Der Ergebnisstring sollte nach
* Gebrauch mittels "free" wieder freigegeben werden.
*/
char *IbmAndBrokenToIso (char *s)
{
static char ibm[] =
{IBM_Ae, IBM_Oe, IBM_Ue, IBM_ae, IBM_oe, IBM_ue, IBM_ss, ATARI_ss,
BROKEN_Ae, BROKEN_Oe, BROKEN_Ue, BROKEN_ae, BROKEN_oe, BROKEN_ue,
BROKEN_ss};
static char iso[] =
{ISO_Ae, ISO_Oe, ISO_Ue, ISO_ae, ISO_oe, ISO_ue, ISO_ss, ISO_ss,
ISO_Ae, ISO_Oe, ISO_Ue, ISO_ae, ISO_oe, ISO_ue, ISO_ss};
char *result = (char *) malloc (strlen (s) + 1);
char *r = result;
char c;
int i;
if (result == (char *) 0)
{
OutOfMemory ("IbmToIso");
return (char *) 0;
}
while (*s)
{
c = *s++;
for (i = 0; i < sizeof (ibm) / sizeof (ibm[1]); i++)
if (c == ibm[i])
c = iso[i];
*r++ = c;
}
*r = '\0';
return result;
}
#endif
/*
* "IbmToIso" konvertiert einen C-String mit IBM-Umlauten (und solchen vom
* Atari ST) nach ISO-8859-1. Der Ergebnisstring sollte nach Gebrauch mittels
* "free" wieder freigegeben werden.
*/
char *IbmToIso (char *s)
{
static char ibm[] =
{IBM_Ae, IBM_Oe, IBM_Ue, IBM_ae, IBM_oe, IBM_ue, IBM_ss, ATARI_ss};
static char iso[] =
{ISO_Ae, ISO_Oe, ISO_Ue, ISO_ae, ISO_oe, ISO_ue, ISO_ss, ISO_ss};
char *result = (char *) malloc (strlen (s) + 1);
char *r = result;
char c;
int i;
if (result == (char *) 0)
{
OutOfMemory ("IbmToIso");
return (char *) 0;
}
while (*s)
{
c = *s++;
for (i = 0; i < sizeof (ibm) / sizeof (ibm[1]); i++)
if (c == ibm[i])
c = iso[i];
*r++ = c;
}
*r = '\0';
return result;
}
/*
* "IsoToCapitals" konvertiert einen C-String in einen solchen mit
* Großbuchstaben. Deutsche Sonderzeichen gemäß ISO-8859-1 werden durch "AE",
* "OE", "UE" und "SS" ersetzt. Der Ergebnisstring sollte nach Gebrauch mittels
* "free" wieder freigegeben werden.
*/
char *IsoToCapitals (char *string)
{
unsigned char *s = (unsigned char *) string;
char *result = (char *) malloc (strlen ((char *) s) * 2 + 1);
char *r = result;
if (result == (char *) 0)
{
OutOfMemory ("IsoToCapitals");
return (char *) 0;
}
while (*s)
{
if (isascii (*s))
{
if (islower (*s))
*r++ = toupper (*s++);
else if (isspace (*s) || ispunct (*s))
s++;
else
*r++ = *s++;
}
else
{
switch (*s)
{
case ISO_Ae:
case ISO_ae:
{
*r++ = 'A';
*r++ = 'E';
break;
}
case ISO_Oe:
case ISO_oe:
{
*r++ = 'O';
*r++ = 'E';
break;
}
case ISO_Ue:
case ISO_ue:
{
*r++ = 'U';
*r++ = 'E';
break;
}
case ISO_ss:
{
*r++ = 'S';
*r++ = 'S';
break;
}
default:
{
char help[300];
sprintf (help, "Interner Fehler: ISO-8859-Zeichen \"%c\" kann nicht konvertiert werden.\n", *s);
Message (help);
break;
}
}
s++;
}
}
*r++ = '\0';
return result;
}
/*
* "OldPlz" liefert die alte Postleitzahl in einem einheitlichen
* Format "XNNNN" als C-String.
* Der Ergebnisstring muß sofort in einen eigenen Bereich kopiert werden.
*/
char *OldPlz (char *s, char verkehrsgebiet)
{
static char oldPlz[6];
int i;
if (*s == 'W' || *s == 'w')
oldPlz[0] = 'W';
else if (*s == 'O' || *s == 'o')
oldPlz[0] = 'O';
else
{
oldPlz[0] = verkehrsgebiet;
s--;
}
if (*++s == '-')
s++;
for (i = 1; *s && i < 5; i++)
oldPlz[i] = *s++;
for (; i < 5; i++)
oldPlz[i] = '0';
return oldPlz;
}
/*
* ReadSeparatedField
*/
char *ReadSeparatedField (char *string, int pos, char separator)
{
char *s1, *s2;
char *r;
int length;
int field = 0;
s1 = s2 = string - 1;
while (field < pos)
{
s1 = s2;
for (s2 = s1 + 1; *s2 && *s2 != separator; s2++)
;
field++;
}
length = s2 - s1 - 1;
r = (char *) malloc (length + 1);
if (r == (char *) 0)
OutOfMemory ("ReadField");
else
{
strncpy (r, s1 + 1, length);
r[length] = '\0';
}
return r;
}
/*
* "StripBlanks" entfernt hinten stehende Blanks aus einem C-String. Die
* Funktion arbeitet direkt auf dem String.
*/
void StripBlanks (char *string)
{
char *s = string;
while (*s)
s++;
do
s--;
while (s >= string && *s == ' ');
s++;
*s = '\0';
}
int strntoi (char *s, int length)
{
char buffer[100];
strncpy (buffer, s, length);
buffer[length] = '\0';
return atoi (buffer);
}
int IbmIsoCStringCompare (char *s1, char *s2)
{
char *h, *h1, *h2;
int r;
h = IbmToIso (s1);
h1 = IsoToCapitals (h);
free (h);
h = IbmToIso (s2);
h2 = IsoToCapitals (h);
free (h);
r = strcmp (h1, h2);
free (h1);
free (h2);
return r;
}
/*
* Setzt die Bausteine Postleitzahl, Ort, Zustellamt und Ortsteil zu einem
* String zusammen. Alle Elemente sind optional.
*/
char *OrtString (char *plz, char *ort, char *zustellamt, char *ortsteil)
{
static char string[200];
strcpy (string, plz);
if (*ort)
{
if (*string)
strcat (string, " ");
strcat (string, ort);
}
if (*zustellamt)
{
if (*string)
strcat (string, " ");
strcat (string, zustellamt);
}
if (*ortsteil)
{
if (*string)
strcat (string, " ");
strcat (string, "(");
strcat (string, ortsteil);
strcat (string, ")");
}
return string;
}
/*
* Setzt die Bausteine Straße und Hausnummer oder Postfach zu einem String
* zusammen. Alle Elemente sind optional.
*/
char *StrasseString (char *strasse, char *hausnummer, char *postfach)
{
static char string[200];
*string = '\0';
if (*strasse)
{
strcpy (string, strasse);
if (*hausnummer)
{
if (*string)
strcat (string, " ");
strcat (string, hausnummer);
}
}
else if (*postfach)
{
strcpy (string, "Postfach ");
strcat (string, postfach);
}
return string;
}
/*
* UpdateString
*/
Boolean UpdateString (char **old, char *new)
{
if (*old != (char *) 0)
{
if (strcmp (*old, new) == 0)
return False;
free (*old);
}
*old = (char *) malloc (strlen (new) + 1);
strcpy (*old, new);
return True;
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.