#include
#include
#defineFA_DIREC 0x10
#define CONTROL ‘$’
#define OPEN “”
#define CLOSE””
#define DEFIS””
#define NUM “”
#define EOLN ”
#define ITALIC “”
#define BOLD “”
//$$narg=1;
char in[20],x[40],z[80],str[120],img[80];
int empty,befor;
FILE *fdi, *fdo;
int c0num,cnum,inum,nstr,tnum;
int sign,old,expand;
int GetStr()
{
befor =old; old = 1;
if(empty==0)
{
nstr++;
if (fgets(str,80,fdi)==NULL) return(-1);
if (str[0]==0 || str[0]==’n’)
{
befor=1;
nstr++;
if (fgets(str,80,fdi)==NULL)return(-1);
if (str[0]==0 || str[0]==’n’)
return(2);
else
{ empty=1; return(1); }
}
else
{ old=0; return(0); }
}
else
{
empty=0; old=0; return(0);
}
}
int NoLF()
{
int i;
for(i=0; str[i]!=0; i++)
if (str[i]==’n’) break;
str[i]=0;
}
Cat(s,pi,ss)
char s[],ss[];
int *pi;
{
int i;
for(i=0; ss[i]!=0; i++,(*pi)++) s[*pi]=ss[i];
}
void ProcProg()
{
int i,j,n,k;
char xx[120];
strcpy(xx,str);
for(i=j=n=k=0; xx[j]!=0; j++)
{
switch (xx[j])
{
case’
case’>’: str[i++]=xx[j];
str[i++]=xx[j];
break;
case’/’: if(xx[j+1]==’/’)
{
k++;
str[i++] = xx[j++];
str[i++] = xx[j];
Cat(str,&i,ITALIC);
}
else
str[i++] = xx[j];
break;
case'”‘: if (n)
{
Cat(str,&i,BOLD);
str[i++] = xx[j];
}
else
{
str[i++] = xx[j];
Cat(str,&i,ITALIC);
}
n = !n; break;
default: str[i++] = xx[j];
}
}
if (k)Cat(str,&i,BOLD);
str[i]=0;
}
int Proc()
{
int i,j,n,k;
char xx[120];
if(str[0]==’t’ && str[1]==’-‘) fprintf(fdo,«nn»);
for(i=0; str[i]!=0; i++) xx[i]=str[i];
xx[i]=0;
for(i=j=n=0; xx[j]!=0; j++)
{
switch (xx[j])
{
case’n’:
case’t’:
case ”: n++; if (n==1) str[i++]=’ ‘; break;
case’-‘: if (!expand) str[i++]=xx[j]; break;
n=0;
if (xx[j+1]!=0 || xx[j-1]==’ ‘)
Cat(str,&i,DEFIS);
else
str[i++]=’-‘;
break;
case'”‘: if (!expand) str[i++]=xx[j]; break;
n=0;
if (sign)
Cat(str,&i,CLOSE);
else
Cat(str,&i,OPEN);
sign = !sign; break;
default: n=0; str[i++] = xx[j];
}
}
str[i]=0;
for(i–; i>=0 && str[i]==’ ‘; i–) str[i]=0;
if(str[i]==’-‘ && str[i-1]!=’ ‘)
{
str[i]=0;
fprintf(fdo,”%s”,str);
}
else
fprintf(fdo,”%s%c”,str,EOLN);
}
int Copy(ext,num,mode)
char *ext;
int num;
int mode;
{
FILE*fd1;
int n;
sprintf(x,”%s%d.%s”,in,num,ext);
puts(x);
if((fd1=fopen(x,«w»))==NULL) return(0);
fprintf(fdo,«n{%s }nn»,x);
if(mode==1)
{
sprintf(z,”//──────────────────────────────────────────────%sn”,x);
fprintf(fd1,”%s”,z);
}
if((mode & 1) && expand) ProcProg();
if(mode!=0) fprintf(fd1,”%sn”,str);
if(mode==0)
sprintf(img,«n Рис.%s%d. %s»,in,num,str+1);
while((n=GetStr())!=-1)
{
NoLF();
if ((mode & 1) && expand)
{
fprintf(fd1,«n»);
ProcProg();
}
if (n==2 || str[0]==CONTROL || mode==2&& n==1)
{
if (mode==0)fprintf(fd1,”%sn”,img);
fclose(fd1);
return(1);
}
if (n==1)
fprintf(fd1,«n»);
else
fprintf(fd1,”%sn”,str);
}
fclose(fd1);
return(0);
}
charA[]=”АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩъЫЬЭЮЯ”;
charB[]=”абвгдежзийклмнопрстуфхцчшщъыьэюя”;
char Alpha(c)
char c;
{
int i;
for(i=0; A[i]!=0; i++) if (c==A[i]) return(B[i]);
return(0);
}
void keywords()
{
FILE*fdi,*fdo;
int i,j,n;
char cc,out[100];
sprintf(x,”%s0.txt”,in);
if((fdi=fopen(x,«r»))==NULL) return;
if((fdo=fopen(«keys.txt»,«a»))==NULL) return;
fseek(fdo,0L,2);
while((cc=getc(fdi)) !=EOF)
{
if (Alpha(cc)==0) continue;
for (i=1,out[0]=cc; (cc=getc(fdi))!=EOF;i++)
{
if (cc ==’ ‘ || (cc=Alpha(cc))!=0)
out[i]=cc;
else break;
}
out[i]=0;
if (i > 2)fprintf(fdo,”%stt%sn”,out,in);
}
fclose(fdi);
fclose(fdo);
}
void step()
{
int i,n,mode;
sprintf(x,”%s.000″,in);
if((fdi=fopen(x,«r»))==NULL) return;
sprintf(x,”%s0.txt”,in);
if((fdo=fopen(x,«w»))==NULL) return;
c0num=cnum=inum=tnum=1;
nstr=0;
sign=0;
while((n=GetStr())!=-1)
{
NoLF();
if (n!=0)
fprintf(fdo,«nn»);
else
{
mode=0;
if (str[0]==CONTROL) mode=1;
if (str[0]==’┌’) mode=3;
if (str[0]==’╔’) mode=3;
if (str[0]==’/’ && str[1]==’/’&& befor) mode=2;
if (str[0]==’#’ && befor) mode=2;
for (i=0; str[i]!=0 && befor;i++)
{
if (str[i]==’ ‘) continue;
if (str[i]==’t’) continue;
if (str[i]>=’a’ && str[i]
break;
}
switch(mode)
{
case0: Proc();
break;
case 3: if (!Copy(«TBL»,tnum++,2)) return;
break;
case 2: if (!Copy(«C»,cnum++,1)) return;
break;
case 1: if (!Copy(«TXT»,inum++,0)) return;
break;
case 4: if (!Copy(«C0»,c0num++,3)) return;
break;
}
}
}
fclose(fdi);
fclose(fdo);
keywords();
}
voidmain(int narg, char *argv[])
{
structffblk DIR;
int done,i;
expand=0;
if (narg
{
printf(«bk.exe файл| * [+]n* — всефайлыn+ — преобразованиеc-файловтиппоумолчанию — .000n»);
exit(0);
}
strcpy(in,argv[1]);
if(narg==3 && argv[2][0]==’+’) expand++;
if(in[0]!=’*’)
{
step();
}
else
{
for(done=findfirst(“*.000″,&DIR,FA_DIREC); !done;done=findnext(&DIR))
{
if ((DIR.ff_attrib & FA_DIREC) ==0&& DIR.ff_name[0] !=’.’)
{
strcpy(in,DIR.ff_name);
for (i=0; in[i]!=’.’; i++);
in[i]=0;
step();
}
}
}
}
Идентификатор BK1
Определением переменной BK1
Тип данных BK1
Индекс BK1
Инициализация BK1
Функция BK1
Заголовок функции BK1
Имя функции BK1
Результат функции BK1
Формальные параметры BK1
Локальные переменные BK1
Глобальные переменные BK1
Вызов функции BK1
Фактические параметры BK1
Инкремент BK1
Декремент BK1
Логическая операция ИЛИ BK1
Логическая операция НЕ BK1
Логическая операция И BK1
Оператор BK1
Ограничитель BK1
Составной оператор BK1
Блок BK1
Тело цикла BK1
Шаг цикла BK1
Заголовочный файл BK1
Переменная BK21
Тип данных BK21
Определение переменной BK21
Базовый тип данных BK21
Машинное слово BK21
Бит BK21
Разрядность BK21
Байт BK21
Стандартное машинное слово BK21
Двойное слово BK21
Тетрада BK21
Дополнительный код BK21
Перечислимый тип BK21
Код символа BK21
Индекс BK21
Направление выполнения операций BK22
Приведение типов BK22
Логическая операция Или BK22
Логическая операция Не BK22
Адресное выражение BK22
Пустой оператор BK23
Составной оператор BK23
Блок BK23
Условие продолжения BK23
Заголовок функции BK24
Тело функции BK24
Определение функции BK24
Фактические параметры BK24
Локальные переменные BK24
Автоматические переменные BK24
Передача параметров по значению BK24
Глобальные переменные BK24
Внешние переменные BK24
Объявление функции BK24
Прототип BK24
Расширение имени файла BK25
Макроопределение BK25
Макроподстановка BK25
Макропроцессор BK25
Макросредства BK25
Лексика BK25
Идентификатор BK25
Синтаксис BK25
Семантика BK25
Генерация кода BK25
Объектный модуль BK25
Модульное программирование BK25
Библиотека объектных модулей BK25
Компоновка BK25
Программирование без goto BK31
Итерационный цикл BK33
Метод последовательных приближений BK33
Строка BK34
Строковая константа BK34
Машинно-ориентированные операции BK35
Операции над машинными словами BK35
Поразрядные операции BK35
Поразрядная операция ИЛИ BK35
Поразрядная операция ИСКЛЮЧАЮЩЕЕ ИЛИ BK35
Поразрядная операция ИНВЕРСИИ BK35
Операция СДВИГА ВПРАВО BK35
Операция СДВИГА ВЛЕВО BK35
Маска BK35
Установка битов BK35
Выделение битов BK35
Маскирование BK35
Проверка битов BK35
Очистка битов BK35
Неравнозначность BK35
Сложение по модулю 2 BK35
Инверсия битов BK35
Логический сдвиг BK35
Арифметический сдвиг BK35
Ключ BK37
Последовательный поиск BK37
Линейный поиск BK37
Двоичный поиск BK37
Сортировка подсчетом BK37
Сортировка вставками BK37
Сортировка выбором BK37
Обменная сортировка BK37
Сортировка слиянием BK37
Сортировка методом пузырька BK37
Шейкер-сортировка BK37
Быстрая сортировка BK37
Медиана BK37
Поразрядная сортировка BK37
Простая вставка BK37
Вставка погружением BK37
Сортировка Шелла BK37
Простое слияние BK37
Поразрядная распределяющая сортировка BK37
Оперативная память BK41
Адресом памяти BK41
Прямая адресация BK41
Косвенная адресация BK41
Указатель BK41
Назначение указателя BK41
Указуемая переменная BK41
Косвенное обращение по указателю BK41
Тип указателя BK41
Адресная арифметика BK41
Передача параметров по значению BK41
Передача параметров по ссылке BK41
Сравнение указателей на равенство BK41
Преобразование типа указателя BK41
Указатель на пустой типvoid* BK41
Сравнение указателей на больше-меньше BK41
Разность значений указателей BK41
Указатель на строку BK41
Строковая константа BK41
Элемент структуры BK42
Объект BK42
Производный тип данных BK43
Выделение составляющего типа данныхBK43
Преобразование типа указателя BK44
Регистровая переменная BK46
Динамические переменные BK51
Динамическая память BK51
Виртуальный массив BK52
Дескриптор файла BK57
Двоичный файл произвольного доступа BK57
Текущая позиция в файле BK57
Смещение в файле BK57
Адрес в файле BK57
Файловый указатель BK57
Объект BK61
Метод BK61
Класс BK61
Наследование BK61
Полиморфизм BK61
Передача параметра по ссылке BK62
Базовый класс BK64
Производный класс BK64
Виртуальная функция BK64
Абстрактным базовый класс BK64
Приложение 1. Операциии приоритеты
─────────────────────────────────────
┌─────┬─────────────────────────────────────────┬───────┐
│Прио─│ Операции │Направ-│
│ритет│ │ление │
├─────┼─────────────────────────────────────────┼───────┤
│ 1 │ () (вызов функции), [], ->,”.” │────> │
│ 2 │ !, ~, +, — (унарные), ++, –, *,(тип), │
│ │sizeof, (new,delete — Си++) │ │
│ 3 │ .*, ->* — Си++ │────> │
│ 4 │ *, /, % (бинарные) │────> │
│ 5 │ +, — (бинарные) │────> │
│ 6 │ > │────> │
│ 7 │ , > │────> │
│ 8 │ ==, != │ ────>│
│ 9 │ & (поразрядное) │────> │
│ 10 │^ │────> │
│ 11 │| (поразрядное) │────> │
│ 12 │&& (логическое) │────> │
│ 13 │|| (логическое) │────> │
│ 14 │?: (условная) │
│ 15 │=, +=, -=, *=, /=, %=, &=, ^=, |=,
│ │>>= │ │
│ 16 │”,” (запятая) │────> │
└─────┴─────────────────────────────────────────┴───────┘
Приложение 2. Интерфейс командной строки main
─────────────────────────────────────────────
// Вывод компонент командной строки, переданной в main
// Командная строка разбивается на части, каждая
// компонента оформляется отдельной строкой
#include
// ┌───────────────количество компонент
// │ ┌── массив указателейна компоненты
main(intnarg, char *argv[])
{ for(int i=0; i
>test.exe aaa 100 bbbb
┌──────────┬─────┬─────┬─────┐
│test.exe│aaa│100│ccc│
argv[] └│─────────┴│────┴│────┴│────┘
┌───────┐0 │ │ │ │
│ ───────────┘ │ │ │
├───────┤1 │ │ │
│ ──────────────────────┘ │ │
├───────┤2 │ │
│ ────────────────────────────┘ │
├───────┤3 │
│ ──────────────────────────────────┘
└───────┘
Приложение3. Стандартнаябиблиотекаввода-вывода
─────────────────────────────────────────────────
1. Заголовочныйфайлбиблиотеки
┌
#include
2. Определение символа «конец файла» иNULL-указатель
┌
#define NULL 0
#define EOF -1
3. Определение дескриптора открытого файла в stdio.h
┌
typedef struct
{
…
unsigned flags; //Флаги состояния───────────────┐
char fd; // Номер открытого файла (handle)│
unsigned char hold; //Возвращенный символ │
shortbsize; // Размер внутреннего буфера │
unsigned char *buffer,*curp; │
… //и его указатели │
} FILE; ──── Определение типа«Дескриптор файла» │
(описательпотока) │
┌─── Флаги состояния — биты,определенные через define ───┘
│
_F_RDWR — открытдля чтения и записи
_F_READ — открыт только для чтения
_F_WRIT — открыт только для записи
_F_BUF — имеетдинамически выделенный буфер данных
_F_LBUF — построчная буферизация
_F_ERR — обнаружена ошибка при выполнении операции
_F_EOF — обнаруженконец файла при выполнении операции
_F_BIN — двоичный(прозрачный) режим
_F_IN — выполняется операция чтения
_F_OUT — выполняется операция записи
_F_TERM — файл открыт на терминале
4. Проверка флагов состояния в дескрипторе файла
┌
FILE*fd;
…
if(fd->flags & _F_BIN) …
5. Макроопределения и функции проверки флагов состояния
┌───────────────────────────────────────────────────────┐
│ #define ferror(pf) ((pf)->flags & _F_ERR) │
│#define feof(pf) ((pf)->flags& _F_EOF) │
│#define fileno(pf) ((pf)->fd) │
│void clearerr(FILE *pf) — сбросить_F_EER и_F_EOF │
└───────────────────────────────────────────────────────┘
6. Стандартныепотоки(файлы) ввода-вывода
В библиотеке имеются внешниепеременные-указатели
на дескрипторы файлов — стандартных устройствввода-вывода.
┌
extern FILE *stdin,*stdout, *stderr, *stdaux, *stdprn;
стандартныйввод──┘ │ │ │ │
стандартныйвывод─────────┘ │ │ │
регистрацияошибок─────────────────┘ │ │
дополнительноеустройство───────────────────┘ │
устройствопечати────────────────────────────────────┘
Этифайлыоткрываютсябиблиотекойавтоматически перед вы-
полнением main и по умолчанию назначаются на терминал
(stdin — клавиатура, stdout,stderr — экран),последователь-
ный порт (stdaux) и принтер (stdprn). stdin и stdout могут
быть переназначены в командой строке запуска программы на
любые другие файлы
┌
>test.exe c:xxxb.dat
│ └───────файл stdout
└─────────────────файл stdin
Все функции посимвольного, построчного и форматированного
ввода-вывода имеют варианты для файлов стандартного ввода-
вывода.
7. Функции открытия-закрытия файла
┌───────────────────────────────────────────────────────┐
│ режим работы с файлом────────┐ │
│ имя файла────────┐ │ │
│ │ │ │
│FILE *fopen(char *name, char *mode) — открытьфайл │
│ │ │
│ └─── указатель на дескриптор файла или NULL │
│ │
│intfclose(FILE *fd) — закрытьфайл │
│ │ │
│ └─── 0 илиEOF (ошибка) │
│ │
│intfcloseall(void) — закрытьвсе │
│ │ │
│ └─── число закрытых файлов или EOF │
│ │
│FILE *freopen(char *name, char *mode, FILE *fd) │
│ — закрыть и открыть повторно │
│ │
│ FILE *tmpfile(void) — создать и открыть временный │
│ файл с уникальным именем │
└───────────────────────────────────────────────────────┘
Символы строки режима работы с файлом
┌
Создание нового при отсутствии файла─────────────────┐
Начальноезначение указателя в файле─────────┐ │
Усечение при закрытии────────────┐ │ │
Запись───────────────┐ │ │ │
Чтение────────┐ │ │ │ │
┌────┬──────────────────────────────┬───┬───┬───┬───┬───┐
│ r │чтениe │ + │ — │ — │ 0 │ — │
│ w │запись │ — │ + │ + │ 0 │ + │
│ a │запись (дополнение) │ — │ + │ + │EOF│ + │
│ r+ │ чтение и запись (обновление) │ +│ + │ — │ 0 │ — │
│ w+ │ чтение и запись (обновление) │ +│ + │ + │ 0 │ + │
│ a+ │ чтение и запись (обновление) │ +│ + │ — │EOF│ + │
├────┼───────────────────┬──────────┴───┴───┴───┴───┴───┤
│ b │двоичные данные │ послеr,w,a,r+,w+,a+ │
│ t │текст │ ….. │
└────┴───────────────────┴──────────────────────────────┘
8. Функции посимвольного ввода-вывода
┌────────────────────────────────Посимвольный ввод ────┐ │
│ intfgetc(FILE*fd) — явно указанный файл │
│ intgetc(FILE*fd) │
│ intfgetchar(void) — стандартный ввод │
│ incgetchar(void) │
│ └─── код символа или EOF │
│ intungetc(intch, FILE *fd) — возвратить символ │
│ в файл (повторно читается)│
└───────────────────────────────────────────────────────┘
┌───────────────────────────────Посимвольный вывод ────┐ │
│ intfputc(intch,FILE *fd) — явно указанный файл │
│intputc(int ch, FILE *fd) │
│intfputchar(int ch) — стандартныйвывод │
│incputchar(int ch) │
│ └─── кодсимволаилиEOF │
└───────────────────────────────────────────────────────┘
Примечание:хотяфункцииивыполняютввод отдельного сим-
вола, обычно он осуществляется в стандартном режиме по-
строчного ввода, поддерживаемого операционной системой
(«эхо»-печать вводимых символов, редактирование строки).
Поэтому в библиотеку строка попадает только полностью,
после ввода символа «конец строки», а уже затем выдается
в программу посимвольно. Для немедленного реагированияпро-
граммы на введенный символ или отказ от эхо-печати необхо-
димо пользоваться нестандартными библиотеками (например,
conio.h)
9. Функции построчного ввода-вывода
┌─────────────────────────────────────Построчный ввод ─┐
│ char *gets(char *str) — стандартный ввод │
│char *fgets(char *str, int n, FILE *fd) │
│ └── str или NULL(ошибка) │ — явно указанный файл│
│ максимальная длина строки ─┘ │
└──────────────────────────────────────────&