305 lines
8.7 KiB
C
Executable File
305 lines
8.7 KiB
C
Executable File
/************************************************************************/
|
|
/* Sourcen-Reiniger von DL1XAO */
|
|
/* */
|
|
/* expandiert in den gewuenschten Files die Tabulatoren, loescht */
|
|
/* ueberfluessige Spaces und wandelt Umlaute */
|
|
/* */
|
|
/* Aenderungen fuer Kommandozeilenparameter von DF6LN */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
#include "tnn.h"
|
|
|
|
int clean(char *);
|
|
void usage(void);
|
|
|
|
int tabs = 8;
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
char file[MAXPATH];
|
|
int i = 1;
|
|
char *sp;
|
|
|
|
if (argc < 2)
|
|
{
|
|
usage();
|
|
return (-1);
|
|
}
|
|
|
|
if (argc > 2)
|
|
{
|
|
if (!strcmp(argv[1], "-t"))
|
|
{
|
|
if (sscanf(argv[2], "%d", &tabs) != 1)
|
|
{
|
|
usage();
|
|
return (-1);
|
|
}
|
|
if (tabs < 2 || tabs > 8)
|
|
{
|
|
fprintf(stderr, "TAB size out of range (2 .. 8).\n");
|
|
return (-1);
|
|
}
|
|
i += 2;
|
|
if (i == argc)
|
|
{
|
|
usage();
|
|
return (-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (; i < argc; i++)
|
|
{
|
|
strcpy(file, argv[i]);
|
|
strlwr(file);
|
|
sp = strstr(file, ".c");
|
|
if (sp != file + strlen(file) - 2)
|
|
{
|
|
sp = strstr(file, ".h");
|
|
if (sp != file + strlen(file) - 2)
|
|
{
|
|
fprintf(stderr, "%s has bad file extension.\n", argv[i]);
|
|
return (-1);
|
|
}
|
|
}
|
|
if (!clean(file))
|
|
return (-1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
fprintf(stderr, "Usage: cleaner [-t <num>] filename [filename [...]]\n");
|
|
}
|
|
|
|
int
|
|
clean(char *fn)
|
|
{
|
|
char tempf[10];
|
|
char out[2048];
|
|
char *co;
|
|
int changed = 0;
|
|
int n, c, lc;
|
|
FILE *fpi;
|
|
FILE *fpo;
|
|
|
|
if ((fpi = xfopen(fn, "rb")) == NULL)
|
|
{
|
|
fprintf(stderr, "File not found: %s\n", fn);
|
|
return (0);
|
|
}
|
|
strcpy(tempf, "temp");
|
|
if ((fpo = xfopen(tempf, "w")) == NULL)
|
|
{
|
|
fprintf(stderr, "Can't open temp file.\n");
|
|
fclose(fpi);
|
|
return (0);
|
|
}
|
|
setvbuf(fpi, NULL, _IOFBF, 8192L);
|
|
setvbuf(fpo, NULL, _IOFBF, 8192L);
|
|
|
|
for (lc = 0, co = out; (c = fgetc(fpi)) != EOF; )
|
|
{
|
|
#ifndef __LINUX__
|
|
if (c == '\n' && lc != '\r')
|
|
changed = 1;
|
|
#else
|
|
if (c == '\r')
|
|
changed = 1;
|
|
#endif
|
|
|
|
switch (c)
|
|
{
|
|
case 9: changed = 1;
|
|
c = ' ';
|
|
for (n = tabs -1 - ((co - out) % tabs); n; n--)
|
|
*co++ = c;
|
|
break;
|
|
case 0x8e:
|
|
case 0xc4: changed = 1;
|
|
*co++ = 'A';
|
|
c = 'e';
|
|
break;
|
|
case 0x99:
|
|
case 0xd6: changed = 1;
|
|
*co++ = 'O';
|
|
c = 'e';
|
|
break;
|
|
case 0x9a:
|
|
case 0xdc: changed = 1;
|
|
*co++ = 'U';
|
|
c = 'e';
|
|
break;
|
|
case 0x84:
|
|
case 0xe4: changed = 1;
|
|
*co++ = 'a';
|
|
c = 'e';
|
|
break;
|
|
case 0x94:
|
|
case 0xf6: changed = 1;
|
|
*co++ = 'o';
|
|
c = 'e';
|
|
break;
|
|
case 0x81:
|
|
case 0xfc: changed = 1;
|
|
*co++ = 'u';
|
|
c = 'e';
|
|
break;
|
|
case 0x9e:
|
|
case 0xdf:
|
|
case 0xe1: changed = 1;
|
|
c = 's';
|
|
*co++ = c;
|
|
break;
|
|
}
|
|
|
|
lc = c;
|
|
if (c != '\r' && c != '\n')
|
|
*co++ = c;
|
|
|
|
if (c == '\n')
|
|
{
|
|
while (co > out && *(co - 1) == ' ')
|
|
{
|
|
co--;
|
|
changed = 1;
|
|
}
|
|
*co++ = '\n';
|
|
*co = '\0';
|
|
fputs(out, fpo);
|
|
co = out;
|
|
}
|
|
}
|
|
|
|
fclose(fpi);
|
|
fclose(fpo);
|
|
if (changed)
|
|
{
|
|
unlink(fn);
|
|
rename(tempf, fn);
|
|
fprintf(stderr, "Changed version of %s saved.\n", fn);
|
|
}
|
|
else
|
|
unlink(tempf);
|
|
return (-1);
|
|
}
|
|
|
|
/*
|
|
String in Kleinbuchstaben umwandeln - aus DJGPP GNU-Paket fuer MS-DOS
|
|
von D.J. Delorie
|
|
*/
|
|
|
|
char *
|
|
strlwr(char *s)
|
|
{
|
|
char *p = s;
|
|
while (*s)
|
|
{
|
|
if ((*s >= 'A') && (*s <= 'Z'))
|
|
*s += 'a'-'A';
|
|
s++;
|
|
}
|
|
return(p);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Einen Dateinamen normieren, d.h. er wird den Gegenheiten des */
|
|
/* verwendeten Dateisystems angepasst. Die Informationen hierfuer */
|
|
/* werden in ALL.H festgelegt. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
char *
|
|
normfname(char *filename)
|
|
{
|
|
char *s; /* Zeiger innerhalb des Namens */
|
|
|
|
for (s = filename; *s; s++) /* alle Zeichen im String durchgehen */
|
|
if (strchr(SEPARATORS, *s)) /* ein Dateitrennungszeichen ? */
|
|
*s = FILE_SEP; /* dann durch das richtige ersetzen */
|
|
#if (FILE_FLAGS & FF_LWR)
|
|
strlwr(filename); /* eventuell in Kleinschreibung... */
|
|
#endif
|
|
return (filename);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Eine Datei oeffnen, es wird darauf geachtet, das einige Betriebs- */
|
|
/* systeme zwischen Textdateien und Binaerdateien unterscheiden. */
|
|
/* normfname() wird zur Normierung des Dateinamens benutzt. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
FILE *
|
|
xfopen(const char *filename, const char *mode)
|
|
{
|
|
char fmode[4], *fm; /* der angepasste Datei-Mode */
|
|
char fname[MAXPATH+1];
|
|
|
|
strcpy(fname, filename); /* umkopieren, den Originalnamen */
|
|
normfname(fname); /* nicht anfassen */
|
|
|
|
fm = fmode;
|
|
if (strchr(mode, 'w')) /* zum Schreiben */
|
|
*fm++ = 'w';
|
|
else
|
|
if (strchr(mode, 'a')) /* zum Anhaengen */
|
|
*fm++ = 'a';
|
|
else
|
|
*fm++ = 'r'; /* sonst zum Lesen oeffnen */
|
|
#if (FILE_FLAGS & FF_TXT) /* b/t-Flag uebernehmen? */
|
|
if (strchr(mode, 'b')) /* eine Binaer-Datei? */
|
|
*fm++ = 'b'; /* ... Flag uebernehmen */
|
|
#ifndef MC68K
|
|
if (strchr(mode, 't')) /* eine Text-Datei? */
|
|
*fm++ = 't'; /* ... Flag uebernehmen */
|
|
#endif
|
|
#endif
|
|
if (strchr(mode, '+')) /* Ueberschreiben? */
|
|
*fm++ = '+';
|
|
|
|
*fm = 0; /* String terminieren */
|
|
return (fopen(fname, fmode)); /* Datei oeffnen */
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Eine Datei loeschen, es werden ALLE Dateien geloescht (auch RDONLY) */
|
|
/* normfname() wird zur Normierung des Dateinamen benutzt. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
int
|
|
xremove(const char *filename)
|
|
{
|
|
char fname[MAXPATH+1];
|
|
|
|
strcpy(fname, filename); /* umkopieren, den Originalnamen */
|
|
normfname(fname); /* nicht anfassen */
|
|
return (remove(fname));
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Eine Datei umbenennen. */
|
|
/* normfname() wird zur Normierung des Dateinamens benutzt. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
int
|
|
xrename(const char *oldname, const char *newname)
|
|
{
|
|
char fname[MAXPATH+1];
|
|
char fname2[MAXPATH+1];
|
|
|
|
strcpy(fname, oldname); /* umkopieren, den Originalnamen */
|
|
normfname(fname); /* nicht anfassen */
|
|
strcpy(fname2, newname); /* umkopieren, den neuen Namen */
|
|
normfname(fname2); /* nicht anfassen */
|
|
return (rename(fname,fname2));
|
|
}
|