Язык Си: шаг за шагом

#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(ошибка)  │       — явно указанный файл│
│ максимальная длина строки ─┘                       │
└──────────────────────────────────────────&