Полезная информация

Server for Information Technologies Сервер поддерживается
Центром Информационных Технологий
(095) 932-9212, 932-9213, 939-0783
E-mail: info@citforum.ru
Сервер содержит море(!) аналитической информации CIT Forum CD-ROM

Пример 30

/* /bin/cc -M2 -Ml -DMATCHONLY -LARGE dosfs.c match.c -o dosfs
 * Копирование файлов с дискеты, записанной в MS DOS, в UNIX.
 * Предполагается, что ваша UNIX-машина имеет соответствующий драйвер
 * для чтения дискет, сформатированных на IBM PC.
 * match.c - файл, содержащий текст функции match().
 */
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
extern char *malloc();  /* выделитель памяти */
extern char *strrchr(); /* поиск последнего вхождения буквы */
extern long lseek();
void readBoot(), readFAT(), readRootDir(), main(), line(), getFile(),
     doDirectory(), mkname(), enterDir(), countFree(), traceclu();
int fd;         /* дескриптор файла - дисковода */
FILE *mapfp;     /* файл трассировки  */
int trace = 0;   /* трассировка пока выключена */
int ask = 1;     /* спрашивать ли подтверждение на перезапись файлов */
int dironly = 0; /* 1: только показывать имена, файлы не скидывать   */
typedef unsigned char  uchar;
/*typedef unsigned short ushort; Есть в sys/types.h */
/* Формат сектора загрузки */
struct boot {
	char jmp[3];      /* команда jmp */
	char label[8];    /* название системы */
	char bfs[2];      /* размер boot-сектора */
	uchar sectorsPerCluster; /* число секторов в кластере */
	char fatoff[2];   /* смещение до начала FAT */
	uchar copies;     /* число копий FAT  */
	char dirsize[2];  /* число записей в корневом каталоге */
	char sectors[2];  /* размер дискеты в секторах */
	uchar desc;       /* описатель типа дискеты */
	char FATsize[2];  /* размер FAT в секторах */
	char sectorsPerTrack[2]; /* число секторов на трек */
	char sides[2];    /* число сторон (1, 2) */
	char hidden[2];   /* число спрятанных секторов */
} *boot;
#define SECTOR 512      /* Размер сектора в байтах   */
int CLU;        /* Размер кластера в байтах          */
int SPC;        /* Размер кластера в секторах        */
int SECT;       /* Число секторов на дискете         */
long capacity;  /* емкость дискеты в байтах          */
ushort MAXCLU;  /* максимальный номер кластера + 1   */
int NDIR;       /* Число слотов в корневом каталоге  */
int DIRSIZE;    /* Длина корневого каталога в байтах */
int ENTRperCLUSTER;  /* Количество слотов в одном кластере каталога */
int SPF;        /* Размер FAT в секторах             */
int FATSIZE;    /* Размер FAT в байтах               */
int FATSTART;   /* Смещение до FAT в байтах          */
int NFAT;       /* Количество копий FAT              */
uchar DESC;     /* Описатель типа дискеты            */
int DATACLU;    /* Начало области данных (номер физич. кластера) */
int bit16 = 0;  /* 1 если FAT использует 16-битные поля, а не 12 */
/* Преобразование char[] в integer */
#define INT(s)  ( * (short *)s)
#define LONG(s) ( * (long  *)s)
/* Формат одной записи каталога. */
struct dir{
	char name[8];   /* имя файла            */
	char ext[3];    /* расширение (суффикс) */
	uchar attrib;   /* атрибуты файла       */
	char unused[10];
	char creat_time[2];     /* время создания */
	char creat_date[2];     /* дата создания  */
	char firstCluster[2];   /* начальный кластер */
	char size[4];           /* размер в байтах */
};
#define isdir(attr)     (attr & 0x10)     /* Является ли каталогом ? */
#define islabel(attr)   (attr & 0x08)     /* Метка тома ?            */
#define eq(s1, s2)      (!strcmp(s1, s2)) /* сравнение строк на ==   */
struct dir *droot;  /* Содержимое корневого каталога */
char *FAT1;         /* File Allocation Table, копия 1 */
char *FAT2;         /*                        копия 2 */
char cwd[256] = "";     /* Текущий каталог в DOS. "" - корневой  */
char *root = "/tmp";    /* Каталог в UNIX, куда копируются файлы */
char *pattern = NULL;   /* шаблон базового имени */
char *dirpattern;       /* каталог (не шаблон)   */
char newname[256];      /* буфер дла генерации имен */
char cluster[4098];     /* буфер для чтения кластера */
/* Чтение n байт по адресу s */
Read(fd, s, n) char *s;
{
	int nn = read(fd, s, n);
	if(nn != n ){
		fprintf(stderr, "Ошибка чтения: %d вместо %d\n", nn, n);
		perror( "read" ); exit(1);
	}
	return nn;
}
/* Позиционирование головок */
long Lseek(fd, off, how) long off;
{
	long offf;
	if((offf = lseek(fd, off, how)) < 0){
		fprintf(stderr, "Ошибка lseek(%ld,%d)\n", off, how);
	}
	return offf;
}
/* Отведение памяти и ее зачистка */
char *Malloc(n) unsigned n;{
	char *ptr = malloc(n);
	register unsigned i;
	if( !ptr){
		fprintf(stderr, "Не могу malloc(%u)\n", n ); exit(2);
	}
	for(i=0; i < n ; i++ ) ptr[i] = 0;
	/* Можно было бы использовать ptr = calloc(1,n); эта функция
	 * как раз отводит и очищает память */
	return ptr;
}
/* Нарисовать горизонтальную черту */
void line(c) char c;{
	register i;
	for(i=0; i < 78; i++) putchar(c);
	putchar('\n');
}
/* Обработка псевдо-имен устройств. Используются имена для XENIX */
char *drive(name) char *name;
{
	if( eq(name, "360")) return "/dev/fd048ds9";
	if( eq(name, "720")) return "/dev/fd096ds9";
	if( eq(name, "1.2")) return "/dev/fd096ds15";
	return name;
}
/* Создать каталог */
char command[512];      /* буфер дла формирования команд */
mkdir(name, mode) char *name;
{
   int retcode;    struct stat st;
   if( stat(name, &st) >= 0 &&
       (st.st_mode & S_IFMT) == S_IFDIR ) return 0; /* уже есть */
   sprintf(command, "mkdir \"%s\"", name );
   retcode = system(command); /* выполнить команду, записанную в command */
   chmod(name, mode & 0777);  /* установить коды доступа */
   return retcode;            /* 0 - успешно */
}
/* Открыть файл, создавая (если надо) недостаюшие каталоги */
FILE *fmdopen(name, mode)
	char *name, *mode;
{
	extern errno;   char *s;    FILE *fp;
	if( fp = fopen(name, mode)) return fp;  /* OK */
	/* иначе файл не смог создаться */
	/* if( errno != ENOENT ) return NULL; /* из-за недостатка прав */
	/* Пробуем создать все каталоги по пути к файлу */
	if((s = strrchr(name, '/' )) == NULL ) return NULL;
	*s = '\0'; md(name); *s = '/';
	return fopen(name, mode);
}
/* Рекурсивный mkdir */
md(path)        char *path;
{       struct stat st; char *s; int code;
	if( !*path) return 0;     /* корневой каталог "/" */
	if( stat(path, &st) >= 0 ){     /* существует */
	    if((st.st_mode & S_IFMT) == S_IFDIR) return 0; /* OK */
	    printf( "%s - не каталог\n", path ); return 1; /* FAIL */
	}
	if( s = strrchr(path, '/')){
	    *s = '\0'; code = md(path); *s = '/';
	    if( code ) return code;     /* Облом */
	}
	sprintf(command, "mkdir \"%s\"", path );
	return system(command); /* 0 если OK */
}
/* Сконструировать имя файла в стиле UNIX.
 * В MS DOS все буквы в именах - большие */
void mkname( res, n, e ) char *res, *n, *e;
{ /* res - результат, n - имя, e - суффикс */
	register i; char *start = res;
	if( n[0] == 0x05 ) n[0] = 0xE5;  /* подставной символ */
	for(i=0; i < 8 && n[i] && n[i] != ' ' ; i++)
		*res++ = n[i];
	if( e[0] != ' ')
		*res++ = '.';
	for(i=0; i < 3 && e[i] && e[i] != ' ' ; i++)
		*res++ = e[i];
	*res = '\0';
	while( *start ){
		if( isalpha(*start) && isupper(*start))
			*start = tolower(*start);
		start++;
	}
}
/* ------------------------------------------------------- */
/* Получить запись из FAT для кластера clu */
ushort numCluster(clu) ushort clu;
{       ushort n;
	if( clu >= MAXCLU )
	  printf( "Слишком большой номер кластера %03X >= %03X\n",
						  clu,    MAXCLU );
	if( bit16 ){    /* 16 бит на номер кластера */
		n = INT( &FAT1[ 2*clu ]);
		n &= 0xFFFF;
		return n;
	} /* иначе 12 бит на номер кластера */
	n = clu + clu/2 ;
	n = INT( &FAT1[n] );
	if( clu % 2 ){  /* нечетный */
		n >>= 4;
	}
	n &= 0xFFF;
	return n;
}
/* Узнать следующий кластер файла. 0 если последний */
ushort nextCluster(clu) ushort clu;
{
	clu = numCluster(clu);
	if( clu >= (bit16 ? 0xFFF8 : 0xFF8 ))
		return 0;       /* EOF */
	return clu;
}
/* Прочесть кластер и сохранить его в файле и буфере */
getCluster(clu, fp, size, buffer)
	ushort clu;     /* логический кластер (2..) */
	FILE *fp;       /* файл для спасения  */
	long size;      /* осталось дописать  */
	char *buffer;   /* буфер для кластера */
{
	long offset;
	int rd, howmuchtoread;
	if( size <= 0L ){
		printf( "CLUSTER %03X лишний\n", clu ); exit(3);
	}
	/* Вычислить смещение. Кластеры нумеруются начиная с #2 */
	offset = (clu - 2 + DATACLU) * (long) CLU;
	Lseek(fd, offset, 0);
	/* Сколько байт прочесть ? */
	howmuchtoread = (size > CLU) ? CLU : size;
	rd = Read(fd, buffer, howmuchtoread);
	if( fp != NULL )
	    fwrite(buffer, 1, rd, fp);
	return ( rd < 0 ) ? 0 : rd;
}
/* ----------------------------------------------------------------- *      dosfs -rPATH    файлы скидываются в каталог PATH, а не в /tmp
 *      dosfs ... "шаблон"    сбрасываются только файлы с подходящими
 *        именами, например:
 *              dosfs 1.2  "/*.c"        *.c из корня дискеты
 *              dosfs 1.2  "/dir1/*.c"   *.c из каталога /dir1
 *              dosfs 1.2  "*.c"         *.c из всех каталогов
 *      dosfs -d        только просмотр каталогов, без сброса файлов
 *      Пример: dosfs -qr. 360
 */
void main(argc, argv) char *argv[];
{
	if( argc < 2 ) goto usage;
	if( *argv[1] == '-' ){  /* разбор ключей */
	    char *keys = &argv[1][1];
	    while(*keys){
	       switch(*keys){
	       case 't':  /* включить трассировку */
		   trace++;
		   if((mapfp = fopen( ".Map", "w" )) == NULL )
		       trace = 0;
		   break;
	       case 'q':  /* без запросов (quiet) */
		   ask = 0; break;
	       case 'r':  /* переназначить root */
		   root = keys+1; goto breakwhile;
	       case 'd':  /* dosfs -d == команда dir */
		   dironly++; break;
	       }
	       keys++;
	    }
	breakwhile:
	    argc--; argv++;
	}
	if( argc < 2 ) goto usage;
	if( pattern = argv[2] ){   /* может быть NULL */
		char *s = strrchr(pattern, '/');
		if(s){  /*      PATH/PATTERN                */
		    dirpattern  = pattern;       /* PATH    */
		    *s = '\0';    pattern = s+1; /* PATTERN */
		}else{  /*      просто PATTERN              */
		    dirpattern = NULL;
		}
	}
	setbuf(stdout, NULL);   /* отменить буферизацию */
	readBoot(drive(argv[1]));
	readFAT();
	countFree();
	readRootDir();
	exit(0);
usage:
	printf( "Вызов:  dosfs  [-dqtrDIR]  устройство [\"шаблон\"]\n" );
	exit(4);
}
/* Прочесть boot-sector, вычислить разные параметры дискеты */
void readBoot(dsk) char *dsk;
{
	char BOOT[SECTOR];
	int skips, sides;
	if((fd = open( dsk, O_RDONLY)) < 0 ){
		fprintf(stderr, "Не могу читать %s\n", dsk); exit(5);
	}
	/* нулевой сектор дискеты - boot */
	Read(fd, BOOT, SECTOR);
	boot = (struct boot *) BOOT;
	line('-');
	printf( "Сформатировано \"%8.8s\"\n", boot->label );
	printf( "Размер boot-сектора %d байт\n", INT(boot->bfs));
	printf( "Кластер содержит %d секторов\n",
		SPC = boot->sectorsPerCluster );
	printf( "Дискета содержит %d секторов ",
		SECT = INT(boot->sectors));
	capacity = SECT * (long) SECTOR;
	printf( "(%ld KB)\n", capacity / 1024L );
	printf( "На треке %d секторов\n", INT(boot->sectorsPerTrack));
	sides = INT(boot->sides);
	printf( "Диск имеет %d сторон%c\n\n", sides, sides==1? 'у':'ы');
	printf( "Смещение до FAT %d сектор\n",
		skips = INT(boot->fatoff));
	printf( "Имеется %d копии FAT\n", NFAT = boot->copies );
	printf( "FAT занимает %d секторов\n\n", SPF = INT(boot->FATsize));
	printf( "Корневой каталог содержит %d записей\n\n",
		NDIR = INT(boot->dirsize));
	printf( "Описатель дискеты = %02X\t(", DESC = boot->desc );
	switch( DESC ){
	case 0xFF: printf( "double sided, 8 sectors per track" ); break;
	case 0xFE: printf( "single sided, 8 sectors per track" ); break;
	case 0xFD: printf( "double sided, 9 sectors per track" ); break;
	case 0xFC: printf( "single sided, 9 sectors per track" ); break;
	case 0xF9: printf( "double sided, 15 sectors per track"); break;
	case 0xF8: printf( "Winchester" ); bit16++; break;
	default:   printf( "неизвестный тип" ); break;
	}
	printf( ")\n");
	printf( "На диске %d спрятанных секторов\n", INT(boot->hidden));
	/* Вычислить характеристики */
	CLU      = SECTOR * SPC;   /* размер кластера в байтах */
	FATSIZE  = SECTOR * SPF;   /* длина FAT в байтах       */
	FATSTART = SECTOR * skips; /* смещение в байтах до FAT */
	/* длина корневого каталога в байтах */
	DIRSIZE  = NDIR   * sizeof(struct dir);
	/* физический номер первого кластера данных */
	DATACLU  = ((long) FATSTART +
		    (long) FATSIZE * NFAT +
		    (long) DIRSIZE ) / CLU;
	printf( "Первый кластер данных (физ.) = %d\n", DATACLU );
	/* число записей каталога в кластере */
	ENTRperCLUSTER = CLU / sizeof(struct dir);
	/* число секторов для данных */
	MAXCLU = (SECT - DATACLU * SPC);
	/* число кластеров для данных */
	MAXCLU = MAXCLU / SPC;
	/* логические номера кластеров идут с #2 */
	MAXCLU += 2;
}
/* Прочесть File Allocation Table (таблицу размещения файлов) */
void readFAT(){
	register int i;
	FAT1 = Malloc(FATSIZE);
	Lseek(fd, (long) FATSTART, 0);
	Read(fd, FAT1, FATSIZE);
	if(NFAT > 1){
		FAT2 = Malloc(FATSIZE);
		Read(fd, FAT2, FATSIZE);
		/* Сравнить копии FAT */
		for(i=0; i < FATSIZE; i++ )
			if(FAT1[i] != FAT2[i]){
			   printf( "копии FAT различаются в %d/%d\n",
				    i, FATSIZE );
			   break;
			}
		free( FAT2 );
	}
	if( DESC != FAT1[0] )
	    printf( "У FAT другой описатель: %02X\n", FAT1[0] & 0xFF );
}
/* Прочесть корневой каталог дискеты.
 * Он расположен сразу же после копий FAT
 */
void readRootDir(){
	if( DIRSIZE % SECTOR )
		printf( "Размер каталога не кратен сектору\n" );
	Lseek(fd, (long)FATSTART + (long)FATSIZE * NFAT, 0);
	droot = (struct dir *) Malloc(DIRSIZE);
	Read(fd, droot, DIRSIZE );
	/* NDIR должно быть 112 для 360K и 720K
	 *                  224 для 1.2 Mb
	 */
	if( !dironly ) mkdir( root, 0755 );
	line('-');
	doDirectory(0, NDIR, droot);
}
/* Обработать каталог (напечатать, спасти файлы, обойти подкаталоги) */
#define PRINT  \
  for(j=0; j < level; j++ ) printf( "  " ); /* отступ */                \
  printf( "%02d\t%s/%-14s   %12ld   %s\n",                              \
	   strt + i,                                                    \
		 cwd,                                                   \
		    basename,                                           \
			    size,                                       \
				    isdir(dd[i].attrib) ?    "<DIR>"  : \
				    islabel(dd[i].attrib) ?  "<LAB>"  : "" )
void doDirectory(strt, entries, dd)
	struct dir dd[];
{
	register i, j;
	char basename[40];
	static int level = 0;
	int need_to_get;        /* надо ли сбрасывать */
	/* line('-'); */
	for(i=0; i < entries; i++ ){
	   uchar c; long size;
	   if((c = *dd[i].name) == 0xE5 || !c)
		   continue;        /* файл стерт (дыра) */
	   mkname(basename, dd[i].name, dd[i].ext);
	   size = LONG(dd[i].size); /* размер файла */
	   /* проверить шаблон имени, если нужно */
	   if( !pattern          || /* pattern задан и */
	       (   (!dirpattern  || eq(cwd, dirpattern)) &&
		   match(basename, pattern)
	       )
	   ){  PRINT; need_to_get = !dironly; }
	   else       need_to_get = 0;
	   if(isdir(dd[i].attrib)){
	       /* себя и родителя проигнорировать */
	      if( eq(basename, "." ) || eq(basename, ".."))
		   continue;
	       level++; /* У каталогов почему-то size == 0 */
		enterDir( basename, INT(dd[i].firstCluster), need_to_get);
	       level--;
	   } else if( islabel(dd[i].attrib)){
	       printf( "Volume label:%11.11s\n", dd[i].name );
	   } else if( need_to_get )
	       getFile ( basename, INT(dd[i].firstCluster), size);
	}
	/* line('#'); */
}
/* Прочесть файл в UNIX-ную файловую систему */
void getFile(name, clu, size)
	char *name;     /* имя файла */
	ushort clu;     /* начальный кластер */
	long size;      /* размер */
{
	FILE *fp;       /* файл куда сохранять */
	struct stat st;
	ushort nclu = 0;/* порядковый номер кластера */
	sprintf(newname, "%s%s/%s", root, cwd, name );
	if( ask && stat(newname, &st) >= 0 ){
		char answer[30];
		fprintf(stderr, "%s уже существует, перезаписать? ",
				 newname);
		gets(answer);
		if( *answer != 'y' ) return;
		fprintf( stderr, "\tOK\n" );
	}
	if((fp = fmdopen( newname, "w" )) == NULL){
		printf( "Не могу создать %s\n", newname );
		return;
	}
	if( trace ) fprintf( mapfp, "\n%s/%s:", cwd, name );
	while( clu ){
		if( trace ) traceclu(nclu++, clu);
		size -= getCluster(clu, fp, size, cluster);
		clu = nextCluster(clu);
	}
	fclose(fp);
}
/* Обработать подкаталог */
void enterDir(name, clu, create)
	char *name;     /* имя */
	ushort clu;     /* начальный кластер */
{
	char *tail, *myCluster;
	struct dir *dsub;
	ushort nclu;
	int nentries;   /* число записей в каталоге */
	/* Коррекция cwd */
	tail = cwd + strlen(cwd);
	*tail = '/'; strcpy(tail+1, name);
	if( create ){   /* создать */
	    sprintf( newname, "%s%s", root, cwd );
	    mkdir  ( newname, 0755);
	}
	if( trace ) fprintf( mapfp, "\nDIR %s:", cwd);
	myCluster = Malloc( sizeof cluster );
	dsub = (struct dir *) myCluster;
	nentries = nclu = 0;
	while( clu ){
		if( trace ) traceclu(nclu++, clu);
		/* Прочесть очередной кластер каталога */
		getCluster(clu, NULL,(long) CLU, myCluster);
		/* Обработать имена в этом кластере */
		doDirectory(nentries, ENTRperCLUSTER, dsub);
		nentries += ENTRperCLUSTER;
		/* Взять следующий кластер */
		clu = nextCluster(clu);
	}
	*tail = '\0';   free(myCluster);
}
/* Подсчет свободных и плохих кластеров. */
void countFree(){
	int isFree = 0;       /* свободные кластеры */
	int isBad  = 0;       /* сбойные кластеры   */
	int isReserved = 0;   /* спрятанные кластеры */
	register ushort n = 0;
	register ushort clu;  /* текущий анализируемый кластер */
	int nline = 300;
	if( trace ) fprintf(mapfp, "\t\tFAT chart\n");
	for(clu=0; clu < MAXCLU; clu++){
		if( clu >= 2 ){
		    n = numCluster(clu);
		    if( n == 0 ) isFree++;
		    if( n == (bit16 ? 0xFFF7 : 0xFF7)) isBad++;
		    if( n >= (bit16 ? 0xFFF0 : 0xFF0 ) &&
			n <  (bit16 ? 0xFFF7 : 0xFF7 )) isReserved++;
		}
		if( trace ){
		  if( nline >= 8){
			nline = 0; fprintf( mapfp, "\n%03X:\t", clu );
		  } else  nline++;
		  fprintf( mapfp, "%03X ", n );
		}
	}
	line('=');
	printf( "Свободно %ld, испорчено %ld, резерв %d кластеров\n",
		      (long)isFree * CLU,  /* в байтах */
			       (long)isBad * CLU,   isReserved );
}
void traceclu(nclu, clu) ushort nclu, clu;
{
	if( nclu % 16 == 0 )
	    fprintf( mapfp, "\n\t" );
	fprintf( mapfp, "%03X ", clu );
}
#ifdef LOCAL_MALLOC
/*
Обратите внимание, что в этой программе память отводится malloc()
и освобождается free() по принципу стека (LIFO).
Мы могли бы переопределить стандартные функции malloc() и free(),
заставив их работать со статической памятью! (Если мы напишем
свою функцию с именем, как у стандартной, то будет использоваться
НАША функция).
*/
static char allocArena[32 * 1024];
static char *top = allocArena;
char *malloc(n){        char *ptr;
	/* округлить до целого числа слов */  /* деление с остатком */
	/* число int-ов: */  n = (n + (sizeof(int)-1)) / sizeof(int);
	/* число char-ов:*/  n *= sizeof(int);
	ptr = top; top += n; return ptr;
}
free(ptr) char *ptr; { top = ptr; }
#endif /*LOCAL_MALLOC*/
 
	/*      Пример 31      */
/* Интроспективная программа: печатает сама себя */
#include <stdio.h>
char *text[] = {
	"#include <stdio.h>",
	"char *text[] = {",
	"        NULL};",
	"/* Программа, печатающая свой собственный текст */",
	"main(){ int i;",
	"  puts(text[0]); puts(text[1]);",
	"  for(i=0; text[i]; i++) putq(text[i]);",
	"  for(i=2; text[i]; i++) puts(text[i]);",
	"}",
	"putq(s) char *s; {",
	"  printf(\"\\t\\\"\");",
	"  while(*s){",
	"    if(*s == '\"')       printf(\"\\\\\\\"\");",
	"    else if(*s == '\\\\') printf(\"\\\\\\\\\");",
	"    else putchar(*s);",
	"    s++;",
	"  }",
	"  printf(\"\\\",\\n\");",
	"}",
        NULL};
/* Программа, печатающая свой собственный текст */
main(){ int i;
  puts(text[0]); puts(text[1]);
  for(i=0; text[i]; i++) putq(text[i]);
  for(i=2; text[i]; i++) puts(text[i]);
}
putq(s) char *s; {
  printf("\t\"");
  while(*s){
    if(*s == '"')       printf("\\\"");
    else if(*s == '\\') printf("\\\\");
    else putchar(*s);
    s++;
  }
  printf("\",\n");
}
 
	/*      Пример 32     */
/* C beautify: программа cb.c, форматирующая исходный
 * текст программы на Си. Текст взят из дистрибутива UNIX */
#include <stdio.h>
#include <stdlib.h>
#define gets    getlex
#define puts    putlex
	/* прототипы */
void main(int argc, char *argv[]);
void ptabs( void );
int getch( void );
void puts( void );
int lookup( char *tab[] );
int gets( void );
void gotelse( void );
int getnl( void );
void comment( void );
int     slevel[10];
int     clevel  = 0;
int     spflg[20][10];
int     sind [20][10];
int     siflev[10];
int     sifflg[10];
int     iflev   = 0;
int     ifflg   = -1;
int     level   = 0;
int     ind[10] = { 0,0,0,0,0,0,0,0,0,0 };
int     eflg    = 0;
int     paren   = 0;
int     pflg[10] = { 0,0,0,0,0,0,0,0,0,0 };
char    lchar;
char    pchar;
int     aflg    = 0;
int     ct;
int     stabs[20][10];
int     qflg    = 0;
char    *wif[] = { "if",NULL};
char    *welse[] = { "else", NULL};
char    *wfor[] =  { "for" , NULL};
char    *wds[] =   { "case","default", NULL};
int     j       = 0;
char    string[200];
char    cc;
int     sflg    = 1;
int     peek    = -1;
int     tabs    = 0;
int     lastchar;
int     c;
void main(int argc, char *argv[])
{
	if( argc > 1 ){
		if( freopen( argv[1], "r", stdin ) == NULL ){
			fprintf(stderr, "Can't open %s\n", argv[1] );
			exit(1);
		}
	}
	if( argc > 2 ){
		if( freopen( argv[2], "w", stdout ) == NULL ){
			fprintf(stderr, "Can't create %s\n", argv[2] );
			exit(1);
		}
	}
	while((c = getch()) != EOF){
		switch(c){
		case ' ':
		case '\t':
			if(lookup(welse) == 1){
				gotelse();
				if(sflg == 0 || j > 0) string[j++] = c;
				puts();
				sflg = 0;
				if(getnl() == 1){
					puts();
					printf("\n");
					sflg = 1;
					pflg[level]++;
					tabs++;
				}
				continue;
			}
			if(sflg == 0 || j > 0) string[j++] = c;
			continue;
		case '\n':
			if((eflg = lookup(welse)) == 1) gotelse();
			puts();
			printf("\n");
			sflg = 1;
			if(eflg == 1){
				pflg[level]++;
				tabs++;
			}
			else
				if(pchar == lchar)
					aflg = 1;
			continue;
		case '{':
			if(lookup(welse) == 1) gotelse();
			siflev[clevel] = iflev;
			sifflg[clevel] = ifflg;
			iflev = ifflg = 0;
			clevel++;
			if(sflg == 1 && pflg[level] != 0){
				pflg[level]--;
				tabs--;
			}
			string[j++] = c;
			puts(); getnl(); puts(); printf("\n");
			tabs++;
			sflg = 1;
			if(pflg[level] > 0){
				ind[level] = 1;
				level++;
				slevel[level] = clevel;
			}
			continue;
		case '}':
			clevel--;
			if((iflev = siflev[clevel]-1) < 0) iflev = 0;
			ifflg = sifflg[clevel];
			if(pflg[level] >0 && ind[level] == 0){
				tabs -= pflg[level];
				pflg[level] = 0;
			}
			puts();
			tabs--;
			ptabs();
			if((peek = getch()) == ';'){
				printf("%c;", c);
				peek = -1;
			}
			else printf("%c", c);
			getnl(); puts(); printf("\n");
			sflg = 1;
			if(clevel < slevel[level])if(level > 0) level--;
			if(ind[level] != 0){
				tabs -= pflg[level];
				pflg[level] = 0;
				ind[level] = 0;
			}
			continue;
		case '"':
		case '\'':
			string[j++] = c;
			while((cc = getch()) != c){
				string[j++] = cc;
				if(cc == '\\'){
					string[j++] = getch();
				}
				if(cc == '\n'){
					puts();
					sflg = 1;
				}
			}
			string[j++] = cc;
			if(getnl() == 1){
				lchar = cc;
				peek = '\n';
			}
			continue;
		case ';':
			string[j++] = c;
			puts();
			if(pflg[level] > 0 && ind[level] == 0){
				tabs -= pflg[level];
				pflg[level] = 0;
			}
			getnl(); puts(); printf("\n");
			sflg = 1;
			if(iflev > 0)
				if(ifflg == 1){
					iflev--; ifflg = 0;
				}
				else iflev = 0;
			continue;
		case '\\':
			string[j++] = c;
			string[j++] = getch();
			continue;
		case '?':
			qflg = 1;
			string[j++] = c;
			continue;
		case ':':
			string[j++] = c;
			if(qflg == 1){
				qflg = 0;
				continue;
			}
			if(lookup(wds) == 0){
				sflg = 0;
				puts();
			}
			else{
				tabs--; puts(); tabs++;
			}
			if((peek = getch()) == ';'){
				printf(";");
				peek = -1;
			}
			getnl(); puts(); printf("\n");
			sflg = 1;
			continue;
		case '/':
			string[j++] = c;
			if((peek = getch()) != '*') continue;
			string[j++] = peek;
			peek = -1;
			comment();
			continue;
		case ')':
			paren--;
			string[j++] = c;
			puts();
			if(getnl() == 1){
				peek = '\n';
				if(paren != 0) aflg = 1;
				else if(tabs > 0){
					pflg[level]++;
					tabs++;
					ind[level] = 0;
				}
			}
			continue;
		case '#':
			string[j++] = c;
			while((cc = getch()) != '\n') string[j++] = cc;
			string[j++] = cc;
			sflg = 0;
			puts();
			sflg = 1;
			continue;
		case '(':
			string[j++] = c;
			paren++;
			if(lookup(wfor) == 1){
				while((c = gets()) != ';');
				ct=0;
cont:
				while((c = gets()) != ')'){
					if(c == '(') ct++;
				}
				if(ct != 0){
					ct--; goto cont;
				}
				paren--;
				puts();
				if(getnl() == 1){
					peek = '\n';
					pflg[level]++;
					tabs++;
					ind[level] = 0;
				}
				continue;
			}
			if(lookup(wif) == 1){
				puts();
				stabs[clevel][iflev] = tabs;
				spflg[clevel][iflev] = pflg[level];
				sind[clevel][iflev]  = ind[level];
				iflev++;
				ifflg = 1;
			}
			continue;
		default:
			string[j++] = c;
			if(c != ',') lchar = c;
		}
	}
}
void ptabs( void ){
	int i;
	for(i=0; i < tabs; i++) printf("\t");
}
int getch( void ){
	if(peek < 0 && lastchar != ' ' && lastchar != '\t')
	   pchar = lastchar;
	lastchar = (peek<0) ? getc(stdin) : peek;
	peek = -1;
	return(lastchar);
}
void puts( void ){
	if(j > 0){
		if(sflg != 0){
			ptabs();
			sflg = 0;
			if(aflg == 1){
				aflg = 0;
				if(tabs > 0) printf("    ");
			}
		}
		string[j] = '\0';
		printf("%s",string);
		j = 0;
	}
	else{
		if(sflg != 0){
			sflg = 0; aflg = 0;
		}
	}
}
int lookup( char *tab[] )
{
	char r;
	int l,kk,k,i;
	if(j < 1) return(0);
	kk=0;
	while(string[kk] == ' ') kk++;
	for(i=0; tab[i] != 0; i++){
		l=0;
		for(k=kk;(r = tab[i][l++]) == string[k] && r != '\0';k++);
		if(r == '\0' &&
		   (string[k] < 'a' || string[k] > 'z' || k >= j))
		      return(1);
	}
	return(0);
}
int gets( void ){
	char ch;
beg:
	if((ch = string[j++] = getch()) == '\\'){
		string[j++] = getch();
		goto beg;
	}
	if(ch == '\'' || ch == '"'){
		while((cc = string[j++] = getch()) != ch)
		     if(cc == '\\') string[j++] = getch();
		goto beg;
	}
	if(ch == '\n'){
		puts();
		aflg = 1;
		goto beg;
	}
	else return(ch);
}
void gotelse( void ){
	tabs = stabs[clevel][iflev];
	pflg[level] = spflg[clevel][iflev];
	ind[level]  = sind [clevel][iflev];
	ifflg = 1;
}
int getnl( void ){
	while((peek = getch()) == '\t' || peek == ' '){
		string[j++] = peek;
		peek = -1;
	}
	if((peek = getch()) == '/'){
		peek = -1;
		if((peek = getch()) == '*'){
			string[j++] = '/';
			string[j++] = '*';
			peek = -1;
			comment();
		}
		else string[j++] = '/';
	}
	if((peek = getch()) == '\n'){
		peek = -1;
		return(1);
	}
	return(0);
}
void comment( void ){
rep:
	while((c = string[j++] = getch()) != '*')
		if(c == '\n'){
			puts();
			sflg = 1;
		}
gotstar:
	if((c = string[j++] = getch()) != '/'){
		if(c == '*') goto gotstar;
		goto rep;
	}
}

© Copyright А. Богатырев, 1992-95
Си в UNIX

Назад | Содержание | Вперед

Comments: info@citmgu.ru
Designed by Andrey Novikov
Copyright © CIT