trim_ext

Trim-Modul - Funktionen um die Leerzeichen vorne und hinten bei einem String wegschneiden.

trim_ext.c:

/*********************************************************************
*
* Autor:   Jürgen Kreick
* Version: 1.1.1 vom 17.11.2011
*
**********************************************************************
*
* Hinweise zum Modul/Quelltext: Keine aktuellen Hinweise.
*
**********************************************************************
*
* Release Notes:
*
* Ver 1.0.0 (vom 10.08.2006):
*	Die erste Version des Moduls. Umfasst folgende Funktionen:
* 	trimL(), trimR(), trimAll().
*
* Ver 1.1.0 (vom 30.11.2010):
* 	In der ersten Version, wenn einer der Strings kein '\0'-Zeichen am Ende hat,
* 	ist ein BufferOverflow möglich. Diese Sicherheitslücke ist hier durch Angabe
* 	der maximalen Buffer-Länge (ein zusätzlicher Parameter) geschlossen.
*
* Ver 1.1.1 (vom 17.11.2011):
* 	BugFix: Plausibilitätsprüfung in trimL(), trimR() und trimAll():
* 	Prüfung "if (maxLen == 0)" durch "if (maxLen <= 0)" ersetzt.
*
**********************************************************************
*
* Funktionsbeschreibung:
*
* trimL()   - schneidet Leerstellen in einem String links ab
* trimR()   - schneidet Leerstellen in einem String rechts ab
* trimAll() - schneidet Leerstellen in einem String links und rechts ab
*
**********************************************************************/
 
 
// Wegen NULL
#include <stdio.h>
 
#define RC_TRIM_MODIFY   1
#define RC_TRIM_NOMODIFY 0
#define RC_TRIM_ERR     -1
 
// Schneidet Leerstellen in einem String links ab
// Parameter:
//   char *ziel   : Hier steht am Ende der Bearbeitung das Ergebnis
//   char *quelle : Der zu bearbeitende String oder NULL
//   int maxLen   : Längenbegrenzung für den String
// Rückgabewert:
//   1 : Der String wurde modifiziert
//   0 : Der String ist unverändert geblieben
//  -1 : Fehler (z.B. bei der Plausibilitätsprüfung)
int trimL (char *ziel, const char *quelle, const int maxLen)
// Es sind zwei Varianten möglich:
// Variante 1: dabei sind Quell- und Ziel-Strings unterschiedliche Variablen
// Variante 2: dabei wird keine zweite Variable benötigt: dann "*quelle" ist gleich NULL
{
	char *pZiel;
	char *pQuelle;
	int position = 0;
	int rc = RC_TRIM_NOMODIFY;
 
	// Plausibilitätsprüfung:
	if (!ziel)       return RC_TRIM_ERR; // Ziel-String kann nicht gespeichert werden
	if (maxLen <= 0) return RC_TRIM_ERR; // Kein Platz im Buffer
 
	// Anfang des Quellstrings
	if (quelle != NULL) pQuelle = quelle; // Variante 1 - mit zwei Variablen
	else                pQuelle = ziel;   // Variante 2 - mit einer einzigen Variable
 
	pZiel = ziel;   // Anfang des Zielstrings
 
	ziel[maxLen - 1] = '\0'; // Sicherheitsmaßnahme
 
	if ((*pQuelle) == '\0') // Wenn der (Quell-/einzige) String leer ist, keine Bearbeitung nötig
	{
		ziel[0] = '\0'; // Sicherheitsmaßnahme
		return RC_TRIM_NOMODIFY;
	} // if
 
	if (quelle != NULL) // Variante 1 - mit zwei Variablen
	{
		if ((*pQuelle) != ' ') rc = RC_TRIM_NOMODIFY; // Wenn der (Quell-)String keine Leerstelle vorne hat - keine Bearbeitung, nur der Kopiervorhang
	}
	else // Variante 2 - mit einer einzigen Variable
	{
		if ((*pQuelle) != ' ') return RC_TRIM_NOMODIFY; // Wenn der (einzige) String keine Leerstelle vorne hat, fertig - keine Bearbeitung
	} // if
 
	if ((*pQuelle) == ' ') rc = RC_TRIM_MODIFY; // Der String wird modifiziert werden
 
	position = 0;
	while ((*pQuelle) == ' ' && position < maxLen) // Leerstellen links berücksichtigen
	{
		pQuelle++;
		position++;
	} // while
	if (position >= maxLen) rc = RC_TRIM_ERR; // String hat kein '\0' (möglich nur wenn der Quell-String nicht NULL ist)
 
	while ((*pQuelle) != '\0' && position < maxLen) // Kopiervorgang
	{
		(*pZiel) = (*pQuelle);
		pZiel++;
		pQuelle++;
		position++;
	} // while
	if (position >= maxLen) rc = RC_TRIM_ERR; // String hat kein '\0'
 
	(*pZiel) = '\0'; // Neues Zeilenende
	ziel[maxLen - 1] = '\0'; // Sicherheitsmaßnahme
 
	return rc;
} // trimL()
 
 
// Schneidet Leerstellen in einem String rechts ab
// Parameter:
//   char *s    : Der zu bearbeitende String
//   int maxLen : Längenbegrenzung für den String
// Rückgabewert:
//   1 : Der String wurde modifiziert
//   0 : Der String ist unverändert geblieben
//  -1 : Fehler (z.B. bei der Plausibilitätsprüfung)
int trimR (char *s, const int maxLen)
{
	char *pS;
	int rc = RC_TRIM_NOMODIFY;
 
	// Plausibilitätsprüfung: Prüfung auf NULL-Pointer und auf leeren String
	if (!s)           return RC_TRIM_ERR;      // Kein String angegeben - keine Bearbeitung
	if ((*s) == '\0') return RC_TRIM_NOMODIFY; // Der String ist leer
	if (maxLen <= 0)  return RC_TRIM_ERR;      // Kein Platz im Buffer
 
	s[maxLen - 1] = '\0'; // Sicherheitsmaßnahme
 
	pS = s; // Anfang des Strings
	while ((*pS) != '\0') pS++; // Nach Ende des Strings suchen
	pS--; // Eine Stelle zurück
	while ((*pS) == ' ') // Leerstellen rechts entdeckt
	{
		(*pS) = '\0'; // Neues Zeilenende
		rc = RC_TRIM_MODIFY;
		pS--; // Eine Stelle zurück
	} // while
 
	return rc;
} // trimR()
 
 
// Schneidet Leerstellen in einem String links und rechts ab
// Parameter:
//   char *ziel   : Hier steht am Ende der Bearbeitung das Ergebnis
//   char *quelle : Der zu bearbeitende String oder NULL
//   int maxLen   : Längenbegrenzung für den String
// Rückgabewert:
//   1 : Der String wurde modifiziert
//   0 : Der String ist unverändert geblieben
//  -1 : Fehler (z.B. bei der Plausibilitätsprüfung)
int trimAll (char *ziel, const char *quelle, const int maxLen)
// Es sind zwei Varianten möglich:
// Variante 1: dabei sind Quell- und Ziel-Strings unterschiedliche Variablen
// Variante 2: dabei wird keine zweite Variable benötigt: dann "*quelle" ist gleich NULL
{
	int rc  = RC_TRIM_NOMODIFY;
	int rcL = RC_TRIM_NOMODIFY;
	int rcR = RC_TRIM_NOMODIFY;
 
	// Plausibilitätsprüfung:
	if (!ziel)       return RC_TRIM_ERR;
	if (maxLen <= 0) return RC_TRIM_ERR; // Kein Platz im Buffer
 
	rcL = trimL(ziel, quelle, maxLen); // Erst links abschneiden
	rcR = trimR(ziel, maxLen);         // Dann rechts abschneiden
 
	if (rcL == RC_TRIM_MODIFY || rcR == RC_TRIM_MODIFY) rc = RC_TRIM_MODIFY;
	if (rcL == RC_TRIM_ERR    || rcR == RC_TRIM_ERR)    rc = RC_TRIM_ERR;
 
	return rc;
} // trimAll()
 
// EOF

---

Stand: 17.11.2011
— : Jürgen Kreick

EOF