tc(' ', fp); break;
	  }
	  putc(cprev = c, fp); /* сама буква */
	  state = TEXT;
	  if(c == '\\') putc('e', fp);
	}
	s++;
    } /* пробелы в конце строки просто игнорируютсЯ */
    putc ('\n', fp);
}
/* Ћбработать файл с именем name */
void proceed (char *name) {
    FILE *fp;
    static unsigned char inp[2048];
    /* достаточно большой буфер ввода */

    if      (strcmp(name, "-") == 0 ) fp = stdin;
    else if ((fp = fopen (name, "r")) == NULL) {
	fprintf (stderr, "Cannot read %s\n", name);
	return;
    }
    while (fgets (inp, sizeof inp, fp) != NULL) {
	register unsigned char  *s, *p;
	int len = strlen (inp);
	if (len && inp[len - 1] == '\n')
		   inp[--len]   =  '\0';
	if (!*inp) {
	/* .sp N  - пропуск N пустых строк */
space:      fprintf (fout, ".sp 1\n");
	    continue;
	}

    /* обрезать концевые пробелы */
	for(p = NULL, s = inp; *s; ++s){
	    if (!isspace (*s)) p = s;
	}
	if(p) p[1] = '\0';
	else goto space;
    /* p указывает на последний непробел */

/* “далить переносы слов в конце строки: перенос - это
   минус, прижатый к концу слова         */
	if (*p == '-' && p != inp /* не в начале строки */
		      && isalnum(UC(p[-1])) /* после буквы  */
	){  int c;  *p = '\0'; /* затереть перенос */
/* —итаем продолжение слова из начала следующей строки */
	    while (isspace (c = getc (fp)));
	    ungetc (c, fp);
	    while ((c = getc (fp)) != '\n' && !isspace (c))
		*p++ = c;
	    *p = '\0';
	    if (c != '\n' ){ /* прочли пробел */
	    /* вычитываем ‚‘… пробелы */
	       while (isspace(c = getc (fp)));
	       if(c != '\n') ungetc (c, fp);
	    }
	}
	/* .pp - директива начала абзаца. */
	if (isspace (*inp)) {
	    fprintf (fout, ".pp\n");
	    for (s = inp; isspace (*s); s++);
	    putstr (fout, s);
	}
	else {
	    if (*inp == '.' || *inp == '\'')
		fprintf (fout, "\\&");
	    putstr (fout, inp);
	}
    }
    if( fp != stdin ) fclose (fp);
}

int main (int argc, char *argv[]) {
    int  i;
    setlocale(LC_ALL, "");
    for (i = 1; i &lt; argc; i++)
	proceed (argv[i]);
    return 0; /* exit code */
}

	/*      Џример 5      */

/* Џрограмма, распечатывающаЯ слова в строках файла в обратном порЯдке */

#include &lt;stdio.h>
#include &lt;ctype.h>
#include &lt;string.h>
#include &lt;locale.h>
#define MAXL 255        /* макс. длина строки */

/* …сли бы мы не включили ctype.h, то мы должны были бы определить
 * #define isspace(c) ((c) == ' ' || (c) == '\t' || (c) == '\f')
 */
main ( argc, argv )  char **argv;{
	setlocale(LC_ALL, "");
	if( argc == 1 ){
		/* программа вызвана без аргументов */
		munch( "" );
	}else{
	     /* аргументы программы - имена файлов */
	     while( argv[ 1 ] ){
		   munch( argv[1] );
		   argv++;
		   argc--;
	     }
	}
	total(); exit(0);
}

/* обработать файл с именем name */
munch( name ) char *name;
{
	char    l[MAXL];   /* буфер длЯ очередной строки */
	int len;           /* длина этой строки */
	char *words[50];   /* таблица полей строки */
	char **s;          /* служебнаЯ */
	int nwords;        /* число слов в строке */

	FILE *fp;

	if( name == NULL || !*name )
	       fp = stdin;   /* стандартный ввод */
	else
	  if( (fp = fopen( name, "r" )) == NULL ){
		fprintf( stderr, "Ќе могу открыть файл %s\n",
			 name );
		return;
	  }

	printf( "----------------------------%s----\n", name );
	while( fgets( l, MAXL, fp ) !=  NULL ){
		len = strlen( l );
		if( len && l[len-1] == '\n' )
			   l[--len]  = '\0' ;

		if( nwords = parse( l, words)){
			/* распечатка слов в обратном порЯдке */
			for( --nwords; nwords >= 0; nwords-- ){
				printf( "%s ", words[ nwords] );
				add( words[ nwords ] );
			}
		}
		putchar ('\n');
	}
	if( fp != stdin ) fclose( fp );
}

/* разобрать строку на слова */
parse( s, tabl )
       register unsigned char *s;
       unsigned char *tabl[];
{
	char eol = 0;
	int nwords = 0;

	while ( !eol ){

		/* пропустить пробелы и табулЯции */
		while(isspace(*s)) s++;

		if( !*s ) /* строка кончилась */
			break;

		*tabl++ = s; nwords++;
		/* начало очередного слова */

		/* пока не пробел и не конец строки */
		while( *s && !isspace(*s))s++;

		/* указатель стоит на символе,  следующем за словом */
		if( ! *s ) eol ++;

		*s = '\0';
		/* закрыли ‘лово, начинаем „ело */
		s++;
	}

	*tabl = NULL;
	return nwords;
}

/* построение таблицы слов, встречающихсЯ в файле */
#define MAXWORDS 1024

struct W{
	int ctr;        /* число вхождений слова */
	char *wrd;      /* слово */
}w [MAXWORDS];          /* таблица */
int busy = 0 ;          /* занЯто в таблице */

extern char *malloc();

/* „обавить слово в таблицу */
add( word ) char *word;
{
	register i;
	static alert = 1;

	/* нет ли уже слова в таблице ? */
	/* если есть - просто увеличить счетчик */
	for( i = 0; i &lt; busy ; i++ ){
		if( !strcmp( word, w[i].wrd )){
			w[i].ctr++;
			return;
		}
	}

	if( busy >= MAXWORDS ){
		if( alert ){
			fprintf( stderr, "Џереполнение таблицы слов\7\n");
			alert = 0;
		}
		return;
	}

	/* нет, слова нет. ‡аносим: */
	w[busy].wrd = malloc( strlen( word ) + 1 );
			      /* 1 байт под символ \0 */

	if( w[busy].wrd == NULL ){
		fprintf( stderr, "Њало памЯти\n");

		busy = MAXWORDS+1;  /* Якобы переполнение */
		return;
	}
	w[busy].ctr = 1;
	strcpy( w[busy].wrd, word );
	busy++;
}

compare( a, b ) struct W *a, *b;
{
	return strcoll( a-> wrd, b-> wrd );
	/* strcoll сравнивает слова в алфавитном порЯдке */
}

/* выдача всех слов, встреченных в тексте, и числа их вхождений */
total(){
	register i;

	/* сортируем слова по алфавиту */
	qsort( w, busy, sizeof(struct W), compare );
	printf( "-----|-----------€’Ћѓ---------------\n");

	for( i=0; i &lt; busy; i++ )
		printf( "%4d | %s\n",
			w[i].ctr,
			w[i].wrd
		);
}

	/*      Џример 6         */

/* ‘ортировка букв в строке методом "пузырька" (bubble sort) */
#define YES 1
#define NO  0

bsort(s) char *s;
{
    register i;          /* индекс сравниваемой буквы */
    register need = YES; /* надо ли продолжать сортировку ? */

    while( need ){
	need = NO;       /* не надо */

	for(i=0; s[i+1]; i++ )
	  /* условие цикла: мы сравниваем i-ую и i+1-ую буквы,
	   * поэтому и проверЯем наличие i+1ой буквы
	   */
	   if( s[i] > s[i+1] ){ /* в неверном порЯдке */
		swap( &s[i], &s[i+1] ); /* переставить */
		need = YES; /* что-то изменилось: надо будет
			     * повторить просмотр массива букв */
	   }
    }
}

/* Ђ вот вариант сортировки, написанный с указателЯми */
bpsort(s) char *s;
{
	register char *p; register need = YES;

	while( need ){
		need = NO;
		for( p = s; p[1] != '\0' ; p++ )
		    if( *p > *(p+1) ){
			swap( p, p+1 ); need = YES;
		    }
	}
}

/* обмен двух букв, находЯщихсЯ по адресам s1 и s2 */
swap( s1, s2 ) register char *s1, *s2;
{
	char tmp;  /* temporary */
	tmp = *s1; *s1 = *s2; *s2 = tmp;
}

char sample1[] = "Homo homini lupus est - ergo bibamus!";
char sample2[ sizeof sample1 ]; /* массив такого же размера */
main(){
	strcpy( sample2, sample1 );  /* скопировать */
	bsort ( sample1 ); printf( "%s\n", sample1 );
	bpsort( sample2 ); printf( "%s\n", sample2 );
}

	/*      Џример 7     */
/* ђабота с хэш-таблицей. —асть функций написана так, чтобы
 * быть независимой от типов ключа и значениЯ и легко
 * подвергатьсЯ модификации.
 */
#include &lt;stdio.h>
#include &lt;string.h>     /* prototype for strchr() */
extern void *malloc(unsigned size);
/* типы ключа и значениЯ: в нашем случае это строки */
typedef unsigned char uchar;
typedef uchar *VAL; typedef uchar *KEY;

/* „лЯ использованиЯ следует реализовать операции
int  HASHFUNC(KEY); int  EQKEY(KEY, KEY);
void FREEVAL(VAL);  void SETVAL(VAL, VAL);
void FREEKEY(KEY);  void SETKEY(KEY, KEY);
*/
#define HASHSIZE 21     /* размер таблицы: очень хорошо 2**n */

uchar *strudup(const uchar *s){ /* создание копии строки в "куче" */
  uchar *p =  (uchar *) malloc(strlen(s)+1); strcpy(p, s); return p;
}
/* одна из возможных хэш-функций */
unsigned int hash; /* последнее вычисленное значение хэш-функции */
int HASHFUNC(KEY key){
	unsigned int i = 0; uchar *keysrc = key;
	while(*key){
	  i = (i &lt;&lt; 1)|(i >> 15); /* ROL */
	  i ^= *key++;
	}
	hash = i % HASHSIZE;
	printf( "hash(%s)=%d\n", keysrc, hash);  /* отладка */
	return hash;
}
#define EQKEY(s1, s2)   (strcmp(s1, s2) == 0)
#define FREEKEY(s)      free(s)
#define FREEVAL(s)      free(s)
#define SETVAL(at,s)    at = strudup(s)
#define SETKEY(at,s)    at = strudup(s)
#define KEYFMT          "%s"
#define VALFMT          "%s"

/* ================== типо-независимаЯ часть ================= */
struct cell {
	struct cell *next; /* ссылка на очередной элемент */
	KEY key;           /* ключ     */
	VAL val;           /* значение */
} *hashtable[ HASHSIZE ];  /* хэш-таблица */

/* получение значениЯ по ключу */
struct cell *get(KEY key){
	struct cell *p;
	for(p = hashtable[HASHFUNC(key)]; p; p = p->next)
		if(EQKEY(p->key, key))
			return p;
	return NULL;    /* отсутствует */
}

/* занести пару ключ:значение в таблицу */
void set(KEY key, VAL val){
	struct cell *p;

	/* проверить - не было ли звена с таким ключом */
	if((p = get(key)) == NULL){       /* не было   */
	    if(!(p = (struct cell *) malloc(sizeof(*p)))) return;
	    SETKEY(p->key, key);
	    p->next = hashtable[hash]; /* hash вычислено в get() */
	    hashtable[hash] = p;
	} else /* уже было: изменить значение */
	    FREEVAL(p->val);
	SETVAL(p->val, val);
}

/* удаление по ключу */
int del(KEY key){
	int indx = HASHFUNC(key);
	struct cell *p, *prev = NULL;

	if((p = hashtable[indx]) == NULL) return 0;
	for( ;p ;prev = p, p=p->next)
		if(EQKEY(p->key, key)){
		    FREEVAL(p->val); FREEKEY(p->key);
		    if( p == hashtable[indx] ) /* голова списка */
			     hashtable[indx] = p->next;
		    else     prev->next = p->next;
		    free((void *) p ); return 1; /* удален */
		}
	return 0;  /* не было такого */
}

/* распечатать пару ключ:значение */
void printcell(struct cell *ptr){
	putchar('(');
	printf( KEYFMT, ptr->key ); putchar(',');
	printf( VALFMT, ptr->val ); putchar(')');
}

/* распечатка таблицы (длЯ отладки) */
void printtable(){
  register i; struct cell *p;
  printf("----TABLE CONTENTS----\n");
  for(i=0; i &lt; HASHSIZE; i++)
      if((p = hashtable[i]) != NULL){
	  printf( "%d: ", i);
	  for(; p; p=p->next)
	     printcell(p), putchar(' ');
	  putchar('\n');
      }
}

/* итератор */
struct celliter {
	int index; struct cell *ptr;
};
/* выдать очередное значение */
struct cell *nextpair(struct celliter *ci){
	struct cell *result;
	while((result = ci->ptr) == NULL){
		if( ++(ci->index) >= HASHSIZE )
			return NULL;    /* больше нет */
		ci->ptr = hashtable[ci->index];
	}
	ci->ptr = result->next; return result;
}
/* инициализациЯ итератора */
struct cell *resetiter(struct celliter *ci){
	ci->index = (-1); ci->ptr = NULL;
	return nextpair(ci);  /* первое значение */
}
/* =========================================================== */

void main(){ /* таблица из имен и размеров файлов текущего каталога */
 struct celliter ci; struct cell *cl;
 char key[40], value[40]; struct cell *val;
 extern FILE *popen();    FILE *fp;     char *s ;

 /* popen() читает вывод команды, заданной в 1-ом аргументе */
 fp = popen( "ls -s", "r" );
 while( fscanf( fp, "%s%s", value, key) == 2 )
	set(key, value);
 pclose(fp);  /* popen() надо закрывать pclose(); */

 for(;;){
	printf( "-> " );  /* приглашение */
	if( !gets( key )) break;   /* EOF */
	if( *key == '-' ){         /* -Љ‹ћ—          :удалить     */
		printf( del( key+1 ) ? "OK\n" : "нет такого\n");
		continue;
	}
	if( !*key || !strcmp(key, "=")){ /* = :распечатать таблицу*/
		printtable();    continue;
	}
	if(s = strchr(key, '=')){ /* Љ‹ћ—=‡ЌЂ—…Ќ€…  :добавить     */
		*s++ = '\0';
		set(key, s); continue;
	}
	if((val = get( key )) == NULL) /* Љ‹ћ— :найти значение */
	     printf( "нет такого ключа\n");
	else{ printf( "значение "); printf(VALFMT, val->val);
	      putchar('\n');
	}
 }
 /* распечатка таблицы при помощи итератора */
 for( cl = resetiter(&ci) ; cl ; cl = nextpair(&ci))
	printcell(cl), putchar('\n');
}

	/*      Џример 8     */

/* Џример маленькой базы данных.
 * „анные хранЯтсЯ Ѓ…‡ дубликатов.
 * Ќадо заметить, что используетсЯ плохой (неэффективный)
 * алгоритм доступа - линейный поиск.
 */
#include &lt;stdio.h>

/* ‚се записи в базе имеют фиксированный размер */
#define VLEN 20
#define KEY_FREE (-13)   /* ключ свободного места. Ћн выбран
произвольно, но не должен встречатьсЯ в качестве входных данных */

struct data{
	short b_key;            /* ключ */
	char  b_val[VLEN];      /* строка-значение */
};

char  BASEF[] = ".base" ;       /* имЯ файла базы */
FILE *fbase;                    /* pointer на базу */
struct data tmp;                /* вспомогательнаЯ переменнаЯ */

void
initBase (void){
	/* fopen: r  read  (чтение)
	 *        w  write (запись), файл пересоздаетсЯ.
	 * (создаетсЯ, если не было, если был - опустошаетсЯ).
	 *        r+ чтение и запись (файл уже существует).
	 *        w+ чтение и запись (создаетсЯ пустой файл).
	 *        a  append (запись в конец файла), создать если нет:
	 *           имеетсЯ в виду, что ЉЂ†„Ђџ операциЯ записи сначала
	 *           ставит указатель записи на конец файла.
	 * ‚ MS DOS нетекстовый файл Ќ…ЋЃ•Ћ„€ЊЋ открывать как
	 *        rb wb rb+ wb+ ab+  иначе ничего не будет работать.
	 */
	if(( fbase = fopen( BASEF, "r+" )) == NULL ){
		if(( fbase = fopen( BASEF, "w+" )) == NULL ){
		     fprintf( stderr, "Ќе могу открыть базу данных %s\n",
			      BASEF );
		     exit(1);
		}
		fprintf( stderr, "Ѓаза создана\n" );
	}
}

void
closeBase (void){
	fclose( fbase );
}
/* “чтите, что если вы записываете в файл структуры, то в файле
не будет разделениЯ на строки - файл Ќ…’…Љ‘’Ћ‚›‰! Џоэтому и
читать такой файл можно только структурами: read(), fread()
(но не scanf-ом и не fgets-ом)
 */

/* Џоиск по ключу .
   ‚ыдать (-1), если записи с данным ключом нет,
   иначе   - номер слота, где содержитсЯ запись с данным ключом.
 */
int
bget (int key)
{
	int n;

	/* последовательно просмотреть весь файл */
	rewind( fbase );
	/* в начало файла. ђавно fseek(fbase, 0L, 0); */

	n = 0 ;
	/* int    сколько_элементов_массива_действительно_считано =
	 * fread( адрес_массива_куда_считывать,
	 *        размер_одного_элемента_массива,
	 *        сколько_элементов_считывать_в_массив, канал );
	 * ‡аметьте, что количество данных задаетсЯ Ќ… в байтах,
	 * а в 'штуках'
	 */
	while( fread( &tmp, sizeof( tmp ), 1, fbase ) == 1 ){
		if( tmp.b_key == key )
			return n;
		n++;
	}
	return (-1);    /* не найдено */
}

/* модифицировать запись с индексом ind */
void
bmod (
    int ind,
    int key,       /* новый ключ */
    char *val      /* новое значение */
)
{
	struct data new;

	fseek( fbase, (long) sizeof( struct data ) * ind, 0 );
	new.b_key = key;
	strncpy( new.b_val, val, VLEN );
	/* int    сколько_элементов_массива_действительно_записано =
	 * fwrite( адрес_массива_который_записывать,
	 *         размер_одного_элемента_массива,
	 *         сколько_элементов_массива_записывать, канал );
	 */
	if( fwrite( &new, sizeof new , 1, fbase ) != 1 )
	    fprintf( stderr, "Ћшибка записи.\n" );
}

/* удаление записи по ключу */
int
bdel (int key){
	int ind = bget( key );
	if( ind == -1 )
		return (-1);        /* записи с таким ключом нет */
	bmod( ind, KEY_FREE, "" );  /* записать признак свободного места */
	return 0;
}

/* ‘лужебнаЯ процедура дописи к концу файла */
void
bappend (int key, char *val)
{
		struct data new;

		/* встать на конец файла */
		fseek( fbase, 0L, 2 );

		/* и записать новую структуру в конец */
		new.b_key = key;
		strncpy( new.b_val, val, VLEN );
		fwrite( &new, sizeof( struct data ) , 1, fbase );
}

/* добавление новой записи. …сли запись с таким ключом уже есть -
   выдать ошибку
 */
int
bput (int key, char *val)
{
	int i = bget( key );
	if( i != -1 )
		return (-1);    /* запись уже есть */

	/* найти свободное место */
	i = bget( KEY_FREE );
	if( i == -1 ) {         /* нет свободных мест */
		bappend( key, val );
		return 0;
	}
	/* иначе свободное место найдено.
	 * ‡аменЯем дырку на полезную информацию */
	bmod( i, key, val );
}

/* распечатать всю базу данных подрЯд */
void
bprint (void){
	int n;
	int here = 0;

	rewind( fbase );
	n = 0;
	printf( "-номер--ключ-------значение-----------------\n" );
	while( fread( &tmp, sizeof tmp, 1, fbase ) == 1 ){
		if( tmp.b_key == KEY_FREE ){
			n++;
			continue;
		}
		printf( "#%-2d| %6d\t| %s\n", n, tmp.b_key, tmp.b_val );
		here ++; n++;
	}
	printf( "--------------------------------------------\n" );
	printf( "„лина базы:%d ‡анЯто:%d\n\n", n, here );
}

/* замена полЯ val у записи с ключом key */
int
bchange (int key, char *val)
{
	int ind;

	ind = bget( key );
	if( ind == -1 ){
		/* запись с таким ключом не существует */
		/* „обавить как новую запись */
		bput( key, val );
		return 0;
	}
	bmod( ind, key, val );
	return 1;
}

/* ЂналогичнаЯ функциЯ, но использующаЯ другой способ.
 * Љроме того, если такой ключ отсутствует - ничего не делаетсЯ
 */
int
bchg (int key, char *val)
{
	struct data d;

	rewind( fbase );        /* в начало файла */
	while( fread( &d, sizeof d, 1, fbase ) == 1 ){
		/* поиск ключа */
		if( d.b_key == key ){
			/* вернутьсЯ назад от текущей позиции */
			fseek( fbase, - (long) sizeof d, 1 );
			/* не годитсЯ   (long)-sizeof d !!! */

			d.b_key = key;
			strncpy( d.b_val, val, VLEN );
			fwrite( &d, sizeof d, 1, fbase );

			/* между fread и fwrite должен быть
			 * хоть один fseek. (магическое заклинание!)
			 */
			fseek( fbase, 0L, 1);  /* никуда не сдвигатьсЯ */
			return 0;              /* сделано */
		}
	}
	return (-1);    /* такого ключа не было */
}

/* Џример */
void
main (void){
	int i;

	initBase();
	bprint();
	bdel( 8 );

	printf( "‘оздаем базу данных\n" );
	bput( 1, "строка 1" );
	bput( 2, "строка 2" );
	bput( 3, "строка 3" );
	bput( 4, "строка 4" );
	bprint();

	printf( "“далЯем записи с ключами 1 и 3\n" );
	bdel( 1 );
	bdel( 3 );
	bprint();

	printf( "„обавлЯем записи 5, 6 и 7\n" );
	bput( 5, "строка 5" );
	bput( 6, "строка 6" );
	bput( 7, "строка 7" );
	bprint();

	printf( "‡аменЯем строку в записи с ключом 2\n" );
	bchange( 2, "новаЯ строка 2" );
	bprint();

	printf( "‡аменЯем строку в записи с ключом 4\n" );
	bchg( 4, "новаЯ строка 4" );
	bprint();

	printf( "‡аменЯем строку в записи с ключом 6 и ключ 6 на 8\n" );
	i = bget( 6 );
	printf( "‘ейчас запись с ключом 6 содержит \"%s\"\n",
		tmp.b_val );
	bmod( i, 8, "ЌоваЯ строка 6/8" );
	bprint();

	closeBase();
}

	/*      Џример 9       */
/* ‚ставка/удаление строк в файл */
#include &lt;stdio.h>

#define INSERT_BEFORE 1		/* ‚ставить строку перед указанной */
#define INSERT_AFTER  2		/* ‚ставить строку после указанной */
#define DELETE        3		/* “далить строку  */
#define REPLACE       4		/* ‡аменить строку */

/* Љ каждой строке linenum должно относитьсЯ не более 1 операции !!! */
struct lineop {
    char    op;			/* ЋперациЯ                     */
    long    linenum;		/* Ќомер строки в файле (с 0)   */
    char   *str;		/* ‘трока (или NULL длЯ DELETE) */
};

long lineno;                          /* номер текущей строки */
int fileChange (char *name,           /* имЯ файла */
		struct lineop ops[],  /* задание   */
		int nops              /* число элементов в массиве ops[] */
){
    FILE     *fin, *fout;
    static   char   TMPNAME[] = "  ?  ";
    char     buffer[BUFSIZ];
    register i;
    struct   lineop tmpop;

    if ((fin = fopen (name, "r")) == NULL)
	 return (-1);
    if ((fout = fopen (TMPNAME, "w")) == NULL) {
	 fclose (fin); return (-1);
    }
    lineno = 0L;
    while (fgets (buffer, BUFSIZ, fin) != NULL) {
	if( nops ) for (i = 0; i &lt; nops; i++)
	    if (lineno == ops[i].linenum) {
		switch (ops[i].op) {
		    case DELETE: /* удалить */
			break;
		    case INSERT_BEFORE: /* вставить перед */
			fprintf (fout, "%s\n", ops[i].str);
			fputs (buffer, fout);
			break;
		    case INSERT_AFTER: /* вставить после */
			fputs (buffer, fout);
			fprintf (fout, "%s\n", ops[i].str);
			break;
		    case REPLACE: /* заменить */
			fprintf (fout, "%s\n", ops[i].str);
			break;
		}
	   /* переставить выполненную операцию в конец массива и забыть */
		tmpop = ops[nops-1]; ops[nops-1] = ops[i]; ops[i] = tmpop;
		nops--; goto next;
	    }
    /* иначе строка не числитсЯ в массиве ops[] : скопировать */
	fputs (buffer, fout);
next:
	lineno++;
    }
    fclose (fin); fclose (fout); rename (TMPNAME, name);
    return nops;  /* число несделанных операций (0 - все сделано) */
}

struct lineop myops[] = {
	{ DELETE,         2L,     NULL                 },
	{ INSERT_BEFORE,  0L,     "inserted before 0"  },
	{ INSERT_BEFORE,  10L,    "inserted before 10" },
	{ INSERT_AFTER,   5L,     "inserted after 5"   },
	{ DELETE,         6L,     NULL                 },
	{ INSERT_AFTER,   8L,     "inserted after 8"   },
	{ INSERT_AFTER,   12L,    "inserted after 12"  },
	{ REPLACE,        3L,     "3 replaced"         }
};

void main( void ){
  int n;
  n = fileChange( "aFile", myops, sizeof(myops)/sizeof(struct lineop));
  printf( "‘трок в файле: %ld; осталось операций: %d\n", lineno, n);
}
/*
исходный файл            получившийсЯ файл
line 0                   inserted before 0
line 1                   line 0
line 2                   line 1
line 3                   3 replaced
line 4                   line 4
line 5                   line 5
line 6                   inserted after 5
line 7                   line 7
line 8                   line 8
line 9                   inserted after 8
line 10                  line 9
			 inserted before 10
			 line 10
		‘трок в файле: 11; осталось операций: 1
*/

	/* Џример 10 */

/* Џроблема: позволить делать вызов free(ptr)
 * на данные, не отводившиесЯ malloc()-ом.
 * ђешение: вести список всех данных,
 * отведенных malloc()ом.
 * ‚озможно также отслеживание диапазона адресов,
 * но последнее ЯвлЯетсЯ машинно-зависимым решением.
 *
 * Џри большом количестве файлов эта программа - неплохой тест
 * производительности машины!
 */
#include &lt;stdio.h>
#include &lt;stdlib.h>
#include &lt;string.h>

typedef struct _cell {
	void *addr;
	struct _cell *next;
} Cell;

typedef struct _entry {
	int length;
	int used;
	Cell *list;
} Entry;

/* •эшированнаЯ таблица */
#define NENTRIES 64
Entry aTab[NENTRIES];

/* •эш-функциЯ от адреса */
int aHash(void *addr){
	unsigned long x = (unsigned long) addr;
	x >>= 3;        /* деление на 8, так как адреса из malloc()
			   обычно четные,
			   поскольку выровнены на границу double */
	return(x % NENTRIES);
	/* ’ут к месту напомнить, что вычисление остатка от делениЯ на степень двойки
	 * можно соптимизировать:
	 *   x % (2**N) = x & 0b0001.....1  (N двоичных единиц)
	 * Љ примеру, x % 64 = x & 0x3F;    (6-аЯ степень двойки)
	 */
}

/* ‚ыделить памЯть, записать адрес в таблицу */
void *aCalloc(int n, int m){
	void *ptr = calloc(n, m);
	Entry *ep = &aTab[ aHash(ptr) ];
	Cell *p;

	for(p=ep->list; p; p=p->next)
		if(p->addr == NULL){
		/* ‘вободнаЯ Ячейка: переиспользовать */
			p->addr = ptr;
			ep->used++;
			return ptr;
		}
	/* Ќет свободных, завести новую */
	p = (Cell *) calloc(1, sizeof(Cell));
	p->addr = ptr;
	p->next = ep->list;
	ep->list = p;
	ep->length++;
	ep->used++;
	return ptr;
}

/* Ћсвободить памЯть */
int aFree(void *ptr){
	Entry *ep = &aTab[ aHash(ptr) ];
	Cell *p;

	for(p=ep->list; p; p=p->next)
		if(p->addr == ptr){
			free(ptr);
			p->addr = NULL;
			/* џчейка не удалЯетсЯ, но метитсЯ как свободнаЯ */
			ep->used--;
			return 1;
		}
	/* Ќет, такой указатель не отводилсЯ.
	 * Ќе делать free()
	 */
	return 0;
}

/* ‚ыдать статистику об использовании хэша */
void aStat(){
	int i;
	int len_all;
	int used_all;

	for(i=len_all=used_all=0; i &lt; NENTRIES; i++){
		len_all  += aTab[i].length;
		used_all += aTab[i].used;

		printf("%d/%d%s", aTab[i].used, aTab[i].length,
		       i==NENTRIES-1 ? "\n":" ");
	}
	printf("%d/%d=%g%%\n",
		used_all, len_all,
		(double)used_all * 100 / len_all);
}

/* ’…‘’ =================================================================*/

Cell *text;

/* Џрочитать файл в памЯть */
void fileIn(char *name){
	char buf[10000];
	FILE *fp;

	if((fp = fopen(name, "r")) == NULL){
		printf("Cannot read %s\n", name);
		return;
	}
	while(fgets(buf, sizeof buf, fp) != NULL){
		char *s;
		Cell *p;

		s = (char *) aCalloc(1, strlen(buf)+1);
		strcpy(s, buf);

		p = (Cell *) aCalloc(sizeof(Cell), 1);
		p->addr = s;
		p->next = text;
		text = p;
	}
	fclose(fp);
}

/* “ничтожить текст в памЯти */
void killAll(){
	Cell *ptr, *nxtp;

	ptr = text;
	while(ptr){
		nxtp = ptr->next;
		if(!aFree(ptr->addr)) printf("No free(1)\n");
		if(!aFree(ptr))       printf("No free(2)\n");
		ptr = nxtp;
	}
}

/* “далить из текста строки, начинающиесЯ с определенной буквы */
void randomKill(int *deleted){
	unsigned char c = rand() % 256;
	Cell *ptr, *prevp;
	unsigned char *s;

retry:
	prevp = NULL; ptr = text;
	while(ptr){
		s = (unsigned char *) ptr->addr;
		if(*s == c){    /* нашел */
			if(!aFree(s)) printf("No free(3)\n");

			/* исключить из списка */
			if(prevp) prevp->next = ptr->next;
			else      text        = ptr->next;

			if(!aFree(ptr))    printf("No free(4)\n");

			/* ‡аведомо неправильный free
			if(!aFree(ptr+1))  printf("No free(5)\n");
			*/

			(*deleted)++;

			goto retry;
		}
		prevp = ptr;
		ptr = ptr->next;
	}
}

int main(int ac, char *av[]){
	int i, r, d;
	char buffer[4098];

	srand(time(NULL));
	for(i=1; i &lt; ac; i++){
		printf("File: %s\n", av[i]);
		fileIn(av[i]);
		aStat();

		d = 0;
		for(r=0; r &lt; 128; r++) randomKill(&d);
		printf("%d lines deleted\n", d);
		aStat();
	}
	killAll();
	aStat();

	if(!aFree(buffer))
		printf("buffer[] - не динамическаЯ переменнаЯ.\n");

	return 0;
}

	/* Џример 11 */

/* Џакет длЯ ловли наездов областей выделенной памЯти
 * друг на друга,
 * а также просто повреждений динамически отведенной памЯти.
 */
#include &lt;stdio.h>
#include &lt;stdlib.h>
#include &lt;fcntl.h>      /* O_RDWR */
#include &lt;sys/types.h>
#include &lt;ctype.h>
#include &lt;locale.h>

#define CHECKALL
/*
	----------------- &lt;--------- ptr
	| red_zone      | головнаЯ "пограничнаЯ зона"
	-----------------
	| byte[0]       |
	|     ...       |
	| byte[size-1]  |
	| placeholder   |
	----------------- выровнено на границу RedZoneType
	| red_zone      | хвостоваЯ "пограничнаЯ зона"
	-----------------

Ћсновные идеи состоЯт в следующем:
1) Џеред и после области данных строитсЯ зона,
   заполненнаЯ заранее известным "узором".
   …сли ее содержимое изменилось, испорчено -
   значит мы где-то разрушили нашу памЯть.
2) ‚едетсЯ таблица всех отведенных malloc()-ом сегментов памЯти;
   длЯ экономии места эта таблица вынесена в файл (но зато это
   очень медленно).
3) Њы не можем пользоватьсЯ библиотекой STDIO длЯ обменов с файлом,
   потому что эта библиотека сама использует malloc() и буфера
   могут быть разрушены.
*/

typedef char *RedZoneType;      /* выравнивание на границу указателЯ */
/* Њожно выравнивать на границу double:
typedef double RedZoneType;
 */

/* ‘егмент, выделЯемый в оперативной памЯти */
typedef struct _allocFrame {
	RedZoneType red_zone;   /* головнаЯ "пограничнаЯ зона"            */
	RedZoneType stuff[1];   /* место длЯ данных                       */
				/* хвостоваЯ "пограничнаЯ зона" безымЯнна */
} AllocFrame;

const int RedZoneTypeSize = sizeof(RedZoneType);

/* ‡апись, помещаемаЯ в таблицу всех выделенных malloc()ом
 * областей памЯти.
 */
typedef struct _memFileRecord {
	AllocFrame *ptr;        /* адрес                                 */
	size_t size, adjsize;   /* размер выделенной области             */
				/* (0,0) - означает "сегмент освобожден" */
	int serial;
} MemFileRecord;

char red_table[] = {
	0x01, 0x03, 0x02, 0x04,
	0x11, 0x13, 0x12, 0x14,
	0x21, 0x23, 0x22, 0x24,
	0x31, 0x33, 0x32, 0x34
};
char free_table[] = {
	'F', 'r', 'e', 'e', 'p', 't', 'r', '\0',
	'F', 'r', 'e', 'e', 'p', 't', 'r', '\0'
};

/* ”айл длЯ хранениЯ таблицы указателей */
static  int mem_fd = (-1);
#define PTABLE "PointerTable.bin"

#define NRECORDS 256
MemFileRecord memrecords[NRECORDS];
/* ============================================================= */
void  MEMputTableRecord(AllocFrame *newptr, AllocFrame *oldptr,
			size_t size, size_t adjsize);
void  MEMputTableRecordKilled(AllocFrame *ptr);
void  MEMerasePreviousRecords(AllocFrame *ptr);
int   MEMcheckRecord(MemFileRecord *rec);
int   MEMcheck_consistency(AllocFrame *ptr);
void  MEMmakeRedZones(char *cptr, size_t size, size_t adjsize);
void  MEMopenFd();
/* ============================================================= */
/* ќтим следует пользоватьсЯ вместо стандартных функций          */
void *MEMmalloc (size_t size);
void *MEMrealloc(void *ptr, size_t size);
void *MEMcalloc (size_t n,  size_t size);
void  MEMfree   (void *ptr);

void  MEMcheckAll();  /* это можно вызывать в середине программы */
/* ============================================================= */
void MEMopenFd(){
	if(mem_fd &lt; 0){
		close(creat(PTABLE, 0644));     /* создать файл */
		mem_fd = open(PTABLE, O_RDWR);  /* чтение+запись */
		unlink(PTABLE);                 /* только длЯ M_UNIX */

		atexit(MEMcheckAll);
		setlocale(LC_ALL, "");
	}
}

/* Џоместить запись в таблицу всех указателей на
 * выделенные области памЯти.
 */
void MEMputTableRecord(AllocFrame *newptr, /* длЯ записи */
		       AllocFrame *oldptr, /* длЯ стираниЯ */
		       size_t size,        /* размер данных */
		       size_t adjsize      /* размер всей записи с зонами */
){
	MemFileRecord memrecord;
	static int serial = 0;

	memrecord.ptr     = newptr;
	memrecord.size    = size;
	memrecord.adjsize = adjsize;
	memrecord.serial  = serial++;

	MEMopenFd();
#ifdef CHECKALL
	/* стереть прежние записи про этот адрес */
	MEMerasePreviousRecords(oldptr);
#endif
	lseek(mem_fd, 0L, SEEK_END);                    /* в конец */
	write(mem_fd, &memrecord, sizeof memrecord);    /* добавить */
}

/* ‘делать запись об уничтожении области памЯти */
void  MEMputTableRecordKilled(AllocFrame *ptr){
	/* Џометить как size=0, adjsize=0 */
	MEMputTableRecord(ptr, ptr, 0, 0);
}

/* Љоды ответа функции проверки */
#define OK      0       /* все хорошо                 */
#define DAMAGED 1       /* повреждена "погранзона"    */
#define FREED   2       /* эта памЯть уже освобождена */
#define NOTHERE (-1)    /* нет в таблице              */

/* Џроверить сохранность "пограничных зон" */
int MEMcheckRecord(MemFileRecord *rec){
	int code = OK;
	char *cptr;
	register i;
	AllocFrame *ptr        = rec->ptr;
	size_t size            = rec->size;
	size_t adjsize         = rec->adjsize;

	if(size == 0 && adjsize == 0){
		printf("%p [%p] -- сегмент уже освобожден, "
		       "record=#%d.\n",
			&ptr->stuff[0], ptr,
			rec->serial
		);
		return FREED;
	}
	cptr    = (char *) ptr;
	for(i=0; i &lt; adjsize; i++){
	    if(i &lt;  RedZoneTypeSize || i >= RedZoneTypeSize + size ){
		/* головнаЯ погранзона €‹€ хвостоваЯ погранзона */
		if( cptr[i] != red_table[ i % RedZoneTypeSize ] ){
		   printf("%p [%p] -- испорчен байт %4d [%4d]"
			  "= 0x%02X '%c' record=#%d size=%lu.\n",
			   &ptr->stuff[0], ptr,
			   i - RedZoneTypeSize, i,
			   cptr[i] & 0xFF,
			   isprint(cptr[i] & 0xFF) ? cptr[i] & 0xFF : '?',
			   rec->serial, size
		   );
		   code = DAMAGED;
		}
	    }
	}
	for(i=0; i &lt; RedZoneTypeSize; i++)
		if(cptr[i] == free_table[i]){
			printf("%p -- уже освобождено?\n", ptr);
			code = FREED;
		}
	if(code != OK) putchar('\n');
	return code;
}

/* Џроверить сохранность памЯти по указателю ptr. */
int MEMcheck_consistency(AllocFrame *ptr){
	MemFileRecord mr_found;
	int nrecords, i, found = 0;
	size_t size;

	MEMopenFd();

	/* €щем запись в таблице указателей */
	lseek(mem_fd, 0L, SEEK_SET);    /* перемотать в начало */
	for(;;){
		size = read(mem_fd, memrecords, sizeof memrecords);
		nrecords = size / sizeof(memrecords[0]);

		if(nrecords &lt;= 0) break;

		for(i=0; i &lt; nrecords; i++)
			if(memrecords[i].ptr == ptr){
			/* Њы ищем последнюю запись про памЯть
			 * с таким адресом, поэтому
			 * вынуждены прочитать ‚…‘њ файл.
			 */
				mr_found = memrecords[i];
				found++;
			}
	}
	if(found) {
		return MEMcheckRecord(&mr_found);
	} else {
		printf("%p -- запись в таблице отсутствует.\n", ptr);
		return NOTHERE;
	}
}

/* “ничтожить все прежние записи про ptr, прописываЯ их adjsize=0 */
void MEMerasePreviousRecords(AllocFrame *ptr){
	int nrecords, i, found;
	size_t size;

	MEMopenFd();
	lseek(mem_fd, 0L, SEEK_SET);    /* перемотать в начало */
	for(;;){
		found = 0;
		size = read(mem_fd, memrecords, sizeof memrecords);
		nrecords = size / sizeof(memrecords[0]);

		if(nrecords &lt;= 0) break;

		for(i=0; i &lt; nrecords; i++)
			if(memrecords[i].ptr == ptr){
				memrecords[i].adjsize = 0;
				/* memrecords[i].size = 0; */
				found++;
			}
		if(found){
			lseek(mem_fd, -size, SEEK_CUR);    /* шаг назад */
			write(mem_fd, memrecords, size);   /* перезаписать */
		}
	}
}

void MEMcheckAll(){
#ifdef CHECKALL
	int nrecords, i;
	size_t size;

	printf("Џроверка всех указателей -------------\n");
	MEMopenFd();
	lseek(mem_fd, 0L, SEEK_SET);    /* перемотать в начало */
	for(;;){
		size = read(mem_fd, memrecords, sizeof memrecords);
		nrecords = size / sizeof(memrecords[0]);

		if(nrecords &lt;= 0) break;

		for(i=0; i &lt; nrecords; i++)
			if(memrecords[i].adjsize != 0)
				MEMcheckRecord(&memrecords[i]);
	}
	printf("Џроверка всех указателей завершена ---\n");
#endif
}

/* ============================================================= */
/* ‡аполнение пограничных зон образцом - "следовой дорожкой" */
void MEMmakeRedZones(char *cptr, size_t size, size_t adjsize){
	register i;

	for(i=0; i &lt; adjsize; i++){
		if(i &lt;  RedZoneTypeSize || i >= RedZoneTypeSize + size ){
		   /* головнаЯ погранзона €‹€
		    * хвостоваЯ погранзона + дополнение
		    * до целого числа RedZoneType-ов
		    */
			cptr[i] = red_table[ i % RedZoneTypeSize ];
		}
	}
}
/* ============================================================= */
/* ”ункциЯ выделениЯ памЯти */
void *MEMmalloc(size_t size){
	AllocFrame *retptr;
	int fullRedZoneTypes =
		(size + RedZoneTypeSize - 1) / RedZoneTypeSize;
	size_t adjustedSize =
		sizeof(retptr->red_zone) * 2 + /* две погранзоны */
		fullRedZoneTypes * RedZoneTypeSize;

	retptr  = (AllocFrame *) malloc(adjustedSize);
	if(retptr == NULL) return NULL;

	MEMmakeRedZones ((char *) retptr, size, adjustedSize);
	MEMputTableRecord(retptr, retptr, size, adjustedSize);
	return &retptr->stuff[0];
	/* вернуть указатель на зону данных */
}

void *MEMrealloc(void *ptr, size_t size){
	AllocFrame *retptr;
	char *cptr = (char *)ptr - RedZoneTypeSize;  /* прежний AllocFrame */
	AllocFrame *oldptr = (AllocFrame *) cptr;
	int fullRedZoneTypes =
		(size + RedZoneTypeSize - 1) / RedZoneTypeSize;
	size_t adjustedSize =
		sizeof(retptr->red_zone) * 2 +
		fullRedZoneTypes * RedZoneTypeSize;

	/* Џроверить сохранность того, что мы сейчас будем realloc-ить */
	MEMcheck_consistency(oldptr);

	retptr  = (AllocFrame *) realloc((void *)oldptr, adjustedSize);
	if(retptr == NULL) return NULL;

	MEMmakeRedZones ((char *) retptr, size, adjustedSize);
	MEMputTableRecord(retptr, oldptr, size, adjustedSize);
	return &retptr->stuff[0];
}

void *MEMcalloc(size_t n, size_t size){
	size_t newsize = n * size;
	void *ptr = MEMmalloc(newsize);
	memset(ptr, '\0', newsize);
	return ptr;
}

/* Ћчистка отведенной памЯти.
 * ptr - это указатель не на AllocFrame,
 * а на данные - то есть на stuff[0].
 */
void MEMfree(void *ptr){
	char *cptr = (char *)ptr - RedZoneTypeSize;
	int i, code;

	code = MEMcheck_consistency((AllocFrame *) cptr);
	for(i=0; i &lt; RedZoneTypeSize; i++)
		cptr[i] = free_table[i];

	if(code != FREED) free((void *) cptr);

	MEMputTableRecordKilled((AllocFrame *) cptr);
}

/* ============================================================= */
/* ’естовый пример                                               */
/* ============================================================= */
#define MAXPTRS 512
char *testtable[MAXPTRS];

/* ‘генерировать строку случайной длины со случайным содержимым */
char *wildstring(int c){
#define N 1024
	char teststring[N + 1];
	int len, i;
	char *ptr;

	len = rand() % N;
	for(i=0; i &lt; len; i++)
		teststring[i] = c;
	teststring[len] = '\0';

	ptr = (char *) MEMmalloc(len + 1);
	if(ptr){
		strcpy(ptr, teststring);
	} else printf("NULL wildstring()\n");

	return ptr;
}

int main(int ac, char *av[]){
	int ilen, len, n, i;

	srand(time(NULL));

	for(n=0; n &lt; MAXPTRS; n++)
		testtable[n] = wildstring('A');

#define DAMAGE (MAXPTRS/3*2-1)
#ifdef DAMAGE
	/* Ќавести порчу */
	len = strlen(testtable[DAMAGE]);
	testtable[DAMAGE][len+1] = 'x';
	testtable[DAMAGE][-2]    = 'y';
	printf("ptr=%p len=%d\n", testtable[DAMAGE], len);
#endif
	for(n=0; n &lt; MAXPTRS/2; n++){
		char *p = wildstring('B');
		int length = strlen(p);
		char *ptr;

		i = rand() % MAXPTRS;
		/* Ќе забыть присвоить возвращенное realloc() значение
		 * обратно в testtable[i] !!!
		 */
		testtable[i] = ptr =
			(char *) MEMrealloc(testtable[i], length + 1);

		if(ptr == NULL) printf("Ќе могу сделать realloc()\n");
		else            strcpy(ptr, p);

#ifdef DAMAGE
		/* Џорча */
		if(n == MAXPTRS/3){
			ptr[length+2] = 'z';
		}
#endif
		MEMfree(p);
	}

	for(n=0; n &lt; MAXPTRS; n++){
		if(testtable[n]) MEMfree(testtable[n]);
	}
#ifdef DAMAGE
	MEMfree(testtable[DAMAGE]);
#endif
	return 0;
}

	/*      Џример 12     */

/* Џрограмма, совмещающаЯ команды mv и cp. €ллюстрациЯ работы с файлами.
 * Џример того, как программа может выбирать род работы
 * по своему названию.
 * ЉомпилЯциЯ:
 *              cc cpmv.c -o copy ; ln copy move
 * Џо мотивам книги Њ.„ансмура и ѓ.„ейвиса.
 */

#include &lt;stdio.h>              /* буферизованный ввод/вывод */
#include &lt;sys/types.h>          /* системные типы данных */
#include &lt;sys/stat.h>           /* struct stat           */
#include &lt;fcntl.h>              /* O_RDONLY              */
#include &lt;errno.h>              /* системные коды ошибок */

/* #define strrchr rindex           /* длЯ версии „…ЊЋ‘ (BSD)    */
extern char *strrchr(char *, char); /* из библиотеки libc.a      */
extern int   errno;
char    MV[] = "move"; char CP[] = "copy";
#define OK      1       /* success - успех   */
#define FAILED  0       /* failure - неудача */
#define YES     OK
#define NO      0

/* ‚ыделить базовое имЯ файла:
 *     ../wawa/xxx  -->   xxx
 *     zzz          -->   zzz
 *     /            -->   /
 */
char *basename( char *name ){
	char *s      = strrchr( name , '/' );
	return (s    == NULL) ? name : /* нет слэшей       */
	       (s[1] == '\0') ? name : /* корневой каталог */
				s + 1;
}
#define ECANTSTAT (-1)  /* файл не существует */
struct ftype {
       unsigned type;  /* тип файла */
       dev_t    dev;   /* код устройства, содержащего файл */
       ino_t    ino;   /* индексный узел файла на этом устройстве */
};
/* Џолучение типа файла */
struct ftype filetype( char *name /* имЯ файла */   )
{
	struct stat st; struct ftype f;

	if( stat( name, &st ) &lt; 0 ){
		 f.type = ECANTSTAT; f.dev = f.ino = 0;
	} else { f.type = st.st_mode & S_IFMT;
		 f.dev  = st.st_dev; f.ino = st.st_ino;
	}
	return f;
}
/* “далЯет файлы, кроме устройств */
int unlinkd( char *name, unsigned type )
{
	if( type == S_IFBLK || type == S_IFCHR || type == S_IFDIR)
		return 0;
	return unlink( name );
}
/* ”ункциЯ нижнего уровнЯ: копирование информации большими порциЯми */
int copyfile( int from, int to )
	/* from - дескриптор откуда */
	/* to   - дескриптор куда   */
{
	char buffer[ BUFSIZ ];
	int n; /* число прочитанных байт */

	while(( n = read( from, buffer, BUFSIZ )) > 0 )
	/* read возвращает число прочитанных байт,
	 * 0 в конце файла
	 */
		    if( write( to,  buffer, n ) != n ){
			printf( "Write error.\n" );
			return FAILED;
		    }
	return OK;
}
/* Љопирование файла */
int docopy(char *src, char *dst, unsigned typefrom, unsigned typeto)
{       int retc; int fdin, fdout;
	printf( "copy %s --> %s\n", src, dst );

	if((fdin = open( src, O_RDONLY )) &lt; 0 ){
		printf( "‘an't read %s\n", src );
		return FAILED;
	}
	if((fdout = creat( dst, 0644 )) &lt; 0 ){  /* rw-r--r-- */
		printf( "Can't create %s\n", dst );
		return FAILED;
	}
	retc = copyfile( fdin, fdout );
	close( fdin ); close( fdout );
	return retc;
}
/* Џереименование файла. ‚ернуть OK, если удачно, FAILED - неудачно */
int mlink(char *src, char *dst, unsigned typefrom, unsigned typeto)
{
	switch( typefrom ){
	case S_IFDIR:           /* переименование каталога */
		printf( "rename directory %s --> %s\n", src, dst );

		if( access( dst, 0 ) == 0 ){
		/* 0 - проверить существование файла */
			printf( "%s exists already\n", dst );
			/* файл уже существует */
			return FAILED;
		}
		if( link( src, dst ) &lt; 0 ){
		    printf( "Can't link to directory %s\n", dst );
		    perror( "link" );
		 /* ‚озможно, что длЯ выполнениЯ link() длЯ каталогов,
		  * программа должна обладать правами суперпользователЯ.
		  */
		    return FAILED;
		}
		unlink( src );
		return OK;

	default:   /* dst - не существует или обычный файл */
		printf( "move %s --> %s\n", src, dst );
		unlinkd( dst, typeto );
		/* зачищаем место, т.к. lin