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

#define     BOLD""

// $$narg=1;

charin[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)

chars[],ss[];

int   *pi;

{

int   i;

for (i=0; ss[i]!=0; i++,(*pi)++) s[*pi]=ss[i];

}

voidProcProg()

{

int i,j,n,k;

charxx[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;

charxx[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);

}

char A[]="АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩъЫЬЭЮЯ";

char B[]="абвгдежзийклмнопрстуфхцчшщъыьэюя";

charAlpha(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;

charcc,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;

elsebreak;

}

      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]<='z') mode=4;

break;

}

        switch(mode)

          {

case 0:     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();

}

void main(int narg, char *argv[])

{

struct ffblk DIR;

int    done,i;

expand=0;

if (narg < 2)

    {

    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(int narg, char *argv[])

{ for (int i=0; i

>test.exe aaa 100 bbbb

                ┌──────────┬─────┬─────┬─────┐

│test.exe