home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Crawly Crypt Collection 1
/
crawlyvol1.bin
/
program
/
compiler
/
nasm20b
/
nasm_src
/
crlf155.c
< prev
next >
Wrap
C/C++ Source or Header
|
1993-01-19
|
20KB
|
848 lines
/* MEMO: tried TABCHAR stuff, for various files */
#define LASTDITCH 1
/* ---------------------------------------------------------------------- */
/* Copyright (C) 1992 by Natürlich! */
/* This file is copyrighted! */
/* Refer to the documentation for details. */
/* ---------------------------------------------------------------------- */
/* rev. history 1.0 -- */
/* 1.1 -- */
/* 1.2 -- */
/* 1.3 -- got a bit more userfriendly */
/* 1.4 -- bug fix ? */
/* 1.5 -- merged with tos_unix */
/* 1.6 -- fixed little masking bug in <mode> */
/* different tabchar */
/* last ditch code added */
/* 1.7 -- increased portability */
/* time date setting for everyone */
/* ---------------------------------------------------------- */
#include "defines.h"
#undef VERSION
#undef REVISION
#define VERSION 1
#define REVISION 7
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include OSBIND
#include "nasm.h"
#ifndef __hp9000s300
# define MALLOCING 1
#endif
#if OS == AMIGA || defined( SUN)
# include <utime.h>
#endif
#if OS == MSDOS && __TURBOC__
# define perror( s) fputs( s, stderr)
#endif
#if OS == TOS || OS == MSDOS
# if OS == TOS
# include <ext.h> /* for stat */
# endif
static struct ffblk fbuf;
#endif
#if OS == TOS
# define LOSER() keypress()
int tossable;
void keypress()
{
if( tossable)
{
while( Bconstat( 2))
Bconin( 2);
Bconin( 2);
}
}
# ifdef __TURBOC__ /* PUREC fouls up too */
# define stat( x, y) mystat( y)
void mystat( p)
struct stat *p;
{
p->st_size = fbuf.ff_fsize;
p->st_mtime = *(long *) &fbuf.ff_ftime; /* sorta hackish */
}
# endif
#else
# define LOSER()
#endif
#ifdef __TURBOC__
# define off_t slword
#endif
#if LASTDITCH
# if OS == TOS || OS == MSDOS
static char ditch[ 128] = "f:\\tmp\\";
# define DIR_SLASH '\\'
# else
static char ditch[ 128] = "/tmp/";
# define DIR_SLASH '/'
# endif
void last_ditch( to_file, abuffer, size)
char *to_file;
void huge *abuffer;
lword size;
{
int fd;
char *z;
strcat( ditch, (z = strrchr( to_file, DIR_SLASH)) ? z + 1 : to_file);
if( (fd = (int) Fkreate( ditch, 0644)) >= 0)
{
# if OS == /* fucking */ MSDOS
_fmode = O_BINARY;
# endif
Fwrite( fd, size, abuffer);
Fclose( fd);
fprintf( stderr, "*** Backup in \"%s\" ***\n", ditch);
}
}
#else
# define last_ditch( x, y, z)
#endif
void nerror( s)
char *s;
{
static char buf[256];
sprintf( buf, "crlf155: Error \"%s\"\n", s);
perror( buf);
LOSER();
exit(1);
}
void nserror( s, t)
char *s, *t;
{
static char buf[256];
sprintf( buf, s, t);
nerror( buf);
}
#define MAXBUF 0x40000 /* sorry but the fucking HP malloc commits */
/* suicide when fragmenting ... (or what ?)*/
#if ! MALLOCING
static char foobuf[ MAXBUF],
memerr2[] = "static buffer too small, recompile!";
#endif
static char huge *p;
static char memerr1[] = "out of memory",
blurb[] =
{
'c','r','l','f','1','5','5',' ','v',VERSION+'0','.',REVISION+'0',' ',
'(','c',')',' ','1','9','9','2',' ','b','y',' ',
'N','a','t','u','e','r','l','i','c','h','!',
' ','-','-',' ','c','o','n','v','e','r','t','s',' ',
#if OS == UNIX || AMIGA
'C','R','/','L','F',' ','t','o',' ','L','F',
#else
'L','F',' ','t','o',' ','C','R','/','L','F',
#endif
' ','a','n','d',' ','m','o','r','e','.','.','.','\n'
};
#if OS == TOS || OS == MSDOS
# define UNIX_TOS 0
# define TOS_UNIX 4
# else
# define TOS_UNIX 0
# define UNIX_TOS 4
#endif
#define ATARI_UNIX 1
#define ATARI_TOS 2
#define UNIX_ATARI 5
#define TOS_ATARI 6
FILE *fp, *fq, *fopen();
int fd,
showstuff,
mode,
untabify,
tabchar,
eliminate,
tabs = -1,
xtabc = -1,
hardtabs = 1,
unmatched= 1;
char huge *atari_tos( size)
register lword size;
{
register byte huge *q;
#if MALLOCING
if( ! (p = Malloc( size + size)))
nerror( memerr1);
#else
if( size >= MAXBUF)
nerror( memerr2);
#endif
for( q = (byte huge *) p; size--;)
if( (*q++ = getc( fp)) == 155)
{
q[ -1] = '\r';
*q++ = '\n';
}
return( (char huge *) q);
}
char huge *atari_unix( size)
register lword size;
{
register byte *q;
register int c;
#if MALLOCING
if( ! (p = Malloc( size)))
nerror( memerr1);
#else
if( size >= MAXBUF)
nerror( memerr2);
#endif
for( q = (byte huge *) p; size--;)
*q++ = ((c = getc( fp)) == 155) ? '\n' : c;
return( (char huge *) q);
}
char huge *tos_atari( size)
register lword size;
{
register char huge *q;
#if MALLOCING
if( ! (p = Malloc( size)))
nerror( memerr1);
#else
if( size >= MAXBUF)
nerror( memerr2);
#endif
for( q = p; size--;)
if( (*q++ = getc( fp)) == '\r' &&
(size-- ? ((*q++ = getc( fp)) == '\n') : (size = 0)))
q--[ -2] = 155;
return( q);
}
char huge *unix_atari( size)
register lword size;
{
register char huge *q;
register int c;
#if MALLOCING
if( ! (p = Malloc( (lword) size)))
nerror( memerr1);
#else
if( size + size >= MAXBUF)
nerror( memerr2);
#endif
for( q = p; size--;)
*q++ = (c = getc( fp)) == '\n' ? 155 : c;
return( q);
}
char huge *none( size)
register lword size;
{
register char huge *q;
#if MALLOCING
if( ! (p = Malloc( (lword) size)))
nerror( memerr1);
#else
if( size + size >= MAXBUF)
nerror( memerr2);
#endif
for( q = p; size--;)
*q++ = getc( fp);
return( q);
}
char huge *unix_tos( size)
lword size;
{
register char huge *q;
register int c;
#if MALLOCING
if( ! (p = Malloc( (lword) (size + size))))
nerror( memerr1);
#else
if( size + size >= MAXBUF)
nerror( memerr2);
#endif
for( q = p, c = 'a'; c != EOF;)
if( (*q++ = c = getc( fp)) == '\n')
{
q[ -1] = '\r';
*q++ = '\n';
}
return( q - 1);
}
char huge *tos_unix( size)
lword size;
{
register char huge *q;
register int c;
#if MALLOCING
if( ! (p = Malloc( (lword) size)))
nerror( memerr1);
#else
if( size >= MAXBUF)
nerror( memerr2);
#endif
if( eliminate)
{
for( q = p, c = 'a'; c != EOF;)
{
while( (c = getc( fp)) == 032);
#if OS == UNIX || AMIGA
if( (*q++ = c) == '\r' &&
(q[-1] = getc( fp)) != '\n')
{
*q = q[-1];
q[ -1] = c;
c = *q;
}
#else
*q++ = c;
#endif
}
}
else
for( q = p, c = 'a'; c != EOF;)
#if OS == UNIX || AMIGA
if( (*q++ = c = getc( fp)) == '\r' &&
(q[-1] = getc( fp)) != '\n')
{
*q = q[-1];
q[ -1] = c;
c = *q;
}
#else
*q++ = c = getc( fp);
#endif
return( q - 1);
}
void do_it( to_file)
char *to_file;
{
off_t size, oldsize;
struct stat sbuf;
register char huge *q;
register lword y;
#if ! MALLOCING
p = foobuf;
#endif
if( q = getenv( "TMPDIR"))
strcpy( ditch, (char *) q);
if( ! (fp = fopen( to_file, (mode & 0xB) ? "rb" : "r" )))
nserror("File open of \"%s\" failed", to_file);
stat( to_file, &sbuf);
if( ! (oldsize = sbuf.st_size))
{
printf("File \"%s\" is empty\n", to_file);
return;
}
if( showstuff)
{
printf("Converting \"%s\" with %ld bytes ", to_file, (long) oldsize);
fflush( stdout);
}
if( (size_t) oldsize != (off_t) oldsize)
nerror("runtime: conversion problem");
switch( mode)
{
default :
q = none( oldsize);
break;
case UNIX_TOS :
q = unix_tos( oldsize);
break;
case TOS_UNIX :
q = tos_unix( oldsize);
break;
case ATARI_UNIX:
q = atari_unix( oldsize);
break;
case UNIX_ATARI:
q = unix_atari( oldsize);
break;
case TOS_ATARI:
q = tos_atari( oldsize);
break;
case ATARI_TOS:
q = atari_tos( oldsize);
}
fclose( fp);
size = (off_t) ( q - p);
if( untabify)
for( q = p, y = size; *q++ != tabchar && y; y--);
if( untabify && y)
{
register lword i, len;
register int j, c;
if( ! (fq = fopen( to_file, "wb")))
nserror("Opening of \"%s\" failed", to_file);
if( hardtabs) /* won't expand last char in file */
for( q = p, i = len = 0, j = tabs; i != size - 1; i++)
if( (c = *q++) != tabchar)
{
if( putc( c, fq) == '\n' || ! --j)
j = tabs;
len++;
}
else
{
while( j)
{
putc( ' ', fq);
len++;
j--;
}
j = tabs;
}
else
for( q = p, len = i = 0; i != size - 1; i++)
{
if( (c = *q++) != tabchar)
{
putc( c, fq);
len++;
}
else
for( j = tabs; j; putc( ' ', fq), len++, j--);
}
if( putc( *q, fq) == EOF)
{
fclose( fq);
last_ditch( to_file, p, size);
nerror("write failed");
}
if( showstuff)
printf("%s to %ld bytes\n", (len > oldsize) ? "up" : "down",
(long) len);
fclose( fq);
}
else
if( (mode & 0x3) || size != oldsize)
{
if( (fd = (int) Fkreate( to_file, 0644)) < 0)
nserror("Creation of \"%s\" failed", to_file);
#if OS == /* fucking */ MSDOS
_fmode = O_BINARY;
#endif
if( showstuff)
printf("%s to %ld bytes\n", (size > oldsize) ? "up" : "down",
(long) size);
if( size != Fwrite( fd, size, p))
{
Fclose( fd);
last_ditch( to_file, p, size);
nerror("write failed");
}
Fclose( fd);
}
else
{
if( showstuff)
puts( "to equal size. [no update]");
goto free_em;
}
/* due to CLOSE writing the creation date, we got to do this */
#if OS == TOS
if( (fd = (int) Fopen( to_file, 0)) < 0)
fprintf( stderr, "Someone snarfed your output file (not me!)\n");
else
{
Fdatime( (DOSTIME *) &sbuf.st_mtime, fd, 1);
Fclose( fd);
}
#else
{
struct utimbuf time;
time.actime = sbuf.st_atime;
time.modtime = sbuf.st_mtime;
if( utime( to_file, &time))
nserror("Timestamp update failed on \"%s\"", to_file);
}
#endif
free_em:
#if MALLOCING
Mfree( (void *) p)
#endif
;
}
main( argc, argv)
int argc;
char **argv;
{
int i = 0,
foo;
if( argc == 1)
goto usage;
while( ++i < argc)
{
if( *argv[ i] == '-')
switch( argv[ i][ 1])
{
#ifdef __DATE__
case ':' :
fputs( __DATE__, stderr);
# ifdef __TIME__
fprintf( stderr, " %s", __TIME__);
# endif
putc( '\n', stderr);
break;
#endif
#if OS == TOS
case 'T' :
case 't' :
tossable = ! tossable;
break;
#endif
case 'V' : /* at runtime would be better, but more painful */
case 'v' : /* to code */
fputs( blurb, stderr);
break;
case 'h' :
case 'H' :
hardtabs = ! hardtabs;
break;
case 'z' :
case 'Z' :
eliminate = ! eliminate;
break;
case 'a' :
case 'A' :
mode = (mode & 0xFC) | ATARI_UNIX;
break;
case 'x' :
case 'X' :
mode = (mode & 0xFC) | ATARI_TOS;
break;
case 'b' :
case 'B' :
mode ^= UNIX_TOS | TOS_UNIX;
break;
case 'u' :
case 'U' :
untabify = ! untabify;
if( argv[ i][ 2] && sscanf( &argv[ i][ 2],"%X", &foo))
tabs = foo;
break;
case 's' :
case 'S' :
showstuff = ! showstuff;
break;
case 'N' :
case 'n' :
mode ^= 0x8;
break;
case 'C' :
case 'c' :
{
unsigned char d = argv[ i][ 2];
if( d == '\\')
switch( argv[ i][ 2])
{
case 't' :
d = '\t';
break;
case 'r' :
d = '\r';
break;
case 'b' :
d = '\b';
break;
case 'n' :
d = '\b';
break;
default :
goto usage;
}
else
if( d >= '0' && d <= '9')
d = (char) atoi( &argv[ i][ 2]);
xtabc = d;
break;
}
default :
goto usage;
}
else
{
static char xbuf[ 256];
static char fname[ 13];
char *p, *q;
if( tabs < 0)
tabs = (mode == TOS_UNIX || mode == TOS_ATARI) ? 3 : 8;
tabchar = (xtabc < 0)
? ((mode == ATARI_UNIX || mode == ATARI_TOS)
? 127 : '\t')
: xtabc;
#if OS == TOS || OS == MSDOS /* if findfirst works */
q = argv[ i];
p = xbuf;
strcpy( p, q);
if( ! (p = strrchr( q, '\\')))
p = xbuf;
else
p = xbuf + (int) ((q = p + 1) - argv[ i]);
strcpy( p, "*.*");
if( findfirst( xbuf, &fbuf, 0)) /* only normal files ? */
nserror("Directory search failed for \"%s\"", xbuf);
{
register char *x, *y;
do
{
for( x = fbuf.ff_name, y = fname; *x; y++, x++)
*y = tolower( *x);
*y = 0;
if( wildmat( fname, q))
{
unmatched = 0;
strcpy( p, fname);
do_it( xbuf);
}
}
while( ! findnext( &fbuf));
}
#else
do_it( argv[ i]);
unmatched = 0;
#endif
}
}
return( unmatched);
usage:
fputs( "\
usage: crlf155 ([flags] <pattern>)+\n\
\t-a\t: convert 155 to LF\n\
\t-n\t: just untabify\n\
\t-x\t: convert 155 to CR/LF\n\
\t-c<chr>\t: tab character\n\
\t-h\t: no hardtabs\n\
\t-z\t: eliminates ^Zs from MSDOS files\n\
\t-b\t: backwards, change conversion direction, f.e. LF to 155\n\
\t-u[val]\t: untabify, default spaces: TOS->UNIX : 3, UNIX->TOS : 8\n\
\t-s\t: show some statistics for user amusement\n", stderr);
#if OS == TOS
fputs( "\
\t-t\t: halt screen before exiting\n\n\
\t\t* Warning: filenames and patterns: all lowercase!\n\
\t\t *.C won't work, *.c will\n", stderr);
#endif
fputs( "\n\
\t\t Insure that there is enough discspace, else one file might\n\
\t\t get truncated\n", stderr);
LOSER();
exit(1);
}
#if OS != UNIX
/* $Revision: 1.7 $
**
** Do shell-style pattern matching for ?, \, [], and * characters.
** Might not be robust in face of malformed patterns; e.g., "foo[a-"
** could cause a segmentation violation. It is 8bit clean.
**
** Written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
** Rich $alz is now <rsalz@bbn.com>.
** April, 1991: Replaced mutually-recursive calls with in-line code
** for the star character.
**
** Special thanks to Lars Mathiesen <thorinn@diku.dk> for the ABORT code.
** This can greatly speed up failing wildcard patterns. For example:
** pattern: -*-*-*-*-*-*-12-*-*-*-m-*-*-*
** text 1: -adobe-courier-bold-o-normal--12-120-75-75-m-70-iso8859-1
** text 2: -adobe-courier-bold-o-normal--12-120-75-75-X-70-iso8859-1
** Text 1 matches with 51 calls, while text 2 fails with 54 calls. Without
** the ABORT, then it takes 22310 calls to fail. Ugh. The following
** explanation is from Lars:
** The precondition that must be fulfilled is that DoMatch will consume
** at least one character in text. This is true if *p is neither '*' nor
** '\0'.) The last return has ABORT instead of FALSE to avoid quadratic
** behaviour in cases like pattern "*a*b*c*d" with text "abcxxxxx". With
** FALSE, each star-loop has to run to the end of the text; with ABORT
** only the last one does.
**
** Once the control of one instance of DoMatch enters the star-loop, that
** instance will return either TRUE or ABORT, and any calling instance
** will therefore return immediately after (without calling recursively
** again). In effect, only one star-loop is ever active. It would be
** possible to modify the code to maintain this context explicitly,
** eliminating all recursive calls at the cost of some complication and
** loss of clarity (and the ABORT stuff seems to be unclear enough by
** itself). I think it would be unwise to try to get this into a
** released version unless you have a good test data base to try it out
** on.
*/
#define TRUE 1
#define FALSE 0
#define ABORT -1
/* What character marks an inverted character class? */
#define NEGATE_CLASS '^'
/* Is "*" a common pattern? */
#define OPTIMIZE_JUST_STAR
/* Do tar(1) matching rules, which ignore a trailing slash? */
#undef MATCH_TAR_PATTERN
/*
** Match text and p, return TRUE, FALSE, or ABORT.
*/
static int
DoMatch(text, p)
char *text;
char *p;
{
int last;
int matched;
int reverse;
for ( ; *p; text++, p++) {
if (*text == '\0' && *p != '*')
return ABORT;
switch (*p) {
case '\\':
/* Literal match with following character. */
p++;
/* FALLTHROUGH */
default:
if (*text != *p)
return FALSE;
continue;
case '?':
/* Match anything. */
continue;
case '*':
while (*++p == '*')
/* Consecutive stars act just like one. */
continue;
if (*p == '\0')
/* Trailing star matches everything. */
return TRUE;
while (*text)
if ((matched = DoMatch(text++, p)) != FALSE)
return matched;
return ABORT;
case '[':
reverse = p[1] == NEGATE_CLASS ? TRUE : FALSE;
if (reverse)
/* Inverted character class. */
p++;
for (last = 0400, matched = FALSE; *++p && *p != ']'; last = *p)
/* This next line requires a good C compiler. */
if (*p == '-' ? *text <= *++p && *text >= last : *text == *p)
matched = TRUE;
if (matched == reverse)
return FALSE;
continue;
}
}
#ifdef MATCH_TAR_PATTERN
if (*text == '/')
return TRUE;
#endif /* MATCH_TAR_ATTERN */
return *text == '\0';
}
/*
** User-level routine. Returns TRUE or FALSE.
*/
int
wildmat(text, p)
char *text;
char *p;
{
#ifdef OPTIMIZE_JUST_STAR
if (p[0] == '*' && p[1] == '\0')
return TRUE;
#endif /* OPTIMIZE_JUST_STAR */
return DoMatch(text, p) == TRUE;
}
#endif