(*~\Глагол\ПриложенияLink\ПГ\~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
(**)                              ОТДЕЛ ВД;
(*============================================================================*)
(* НАЗНАЧЕНИЕ: 1) Виды Данных                                                 *)
(*             2) чтение и запись символьных файлов                           *)
(*============================================================================*)

ИСПОЛЬЗУЕТ 
        (*  \Глагол\              *)
(* оЦепи    ИЗ "..\..\Отделы\Иное\",*)
  Пустой  ИЗ "..\..\Отделы\Иное\",
ЧэргаСлеД ИЗ "..\..\Отделы\Иное\",

  РС,НП,ОО,ФО,ПЗ;

                            (*--- общедоступные ВИДы ---*)
ВИД
   ДкПонятию- = ДОСТУП К нПонятие;
      ДкВиду- = ДОСТУП К нВид;
      ДкПост- = ДОСТУП К нПост;
   DebugInfo- = ДОСТУП К DebugInfoDesc;

(*------------------------------------ ВидПонятие ----------------------------*)
   нПонятие-  = НАБОР(ЧэргаСлеД.нПустой)

    родп+:ЦЕЛ;      (* род понятий:
                     *        пОтдел|пОбласть|пВид|пПост|пПер|пПрСсылки|
                     *        пЗадача|пВстрЗадача|пСвойство                   *)
    лево+,право+,   (* дерево для лексического поиска                         *)
    след+,область+:ВД.ДкПонятию;
    имя+:НП.Имя;
    признаки+:МНОЖ; (* признаки понятия:
                     * {прОбщедоступная,прВложенная,прНеизменяемая,прГоловная} *)
    вид+:ВД.ДкВиду; (* родп=пВид    -> вид
                     * родп=...     -> вид понятия
                     * родп=пЗадача -> вид возвращаемого значения             *)
(*
    видпр+:ВД.ДкВиду;                            (* объявленный вид приёмника *)
*)
    уровень+:ЦЕЛ;   (* уровень <  0  -> -вхнОтд
                     * уровень >= 0  -> уровень области видимости             *)
    адр+:ЦЕЛ;       (* для задач: 0 | индекс в символьной таблице COFF        *)

    пост+:ВД.ДкПост;(* значение для постоянных, служебн. данные для задач     *)

    типОД+:ЦЕЛ;     (* тип отладочных данных CodeView для приёмников переменных,
                     * доступен после записи debug type section               *)
    debugInfo+:DebugInfo;                         (* ПУСТО | доступ для задач *)

    имяФ:Пустой.ДкЦепи;    (* :ДОСТУП К ЦЕПЬ; *)  (* пОтдел -> имя его файла  *)
  КОН;

                      (*--
                               локальные ПОСТоянные 
                        --*)
ПОСТ
                    (* Род понятий (нПонятие.родп). Из ВД. *)
  пОтдел     =0;
  пОбласть   =1;
  пВид       =2;
  пПост      =3;
  пПер       =4;
  пПрСсылки  =5;
  пЗадача    =6;
  пВстрЗадача=7;
  пСвойство  =8;
(*
  родп       | n адр   пост    след     область
  ============================================================================
  пОтдел     | 0                        верх    Отдел
  пОбласть   | 1 нстр                   первпер Область действия
  пВид       | 2                                Именованный вид
  пПост      | 3       val                      Постоянная
  пПер       | 4 адр           next             Переменная или приёмник значения
  пПрСсылки  | 5 vadr          next             Приемник переменной
  пЗадача    | 6 сно   sizes   firstpar область Задача
  пВстрЗадача| 7 fno   sizes                    Встроенная задача
  пСвойство  | 8 off           next             Свойство набора

  <сно> является номером в символьной таблице COFF (если <сно> <= 0, то это - адр для связки заготовок)
*)

                    (* Признаки понятия (нПонятие.признаки). Из ВД. *)
  прОбщедоступная=0;
  прНеизменяемая =1;
  прОбъявлена    =2;
  прВложенная    =3;
  прГоловная     =4;
  прПередаваемая =5;
(*
  прОбщедоступная- действует во всех отделах
  прНеизменяемая - только для чтения
  прОбъявлена    - для полностью объявленных задач
  прВложенная    - для вложенных задач
  прГоловная     - для задачи _Zapusk 
  прПередаваемая - для иноязычных приложений
*)

                   (* Номера задач (нУзел.подроду). Из ПД. *)
  assign    =0;
  зВЦел     =1;
  зВШирЦел  =2;
  зЧет      =3;
  зВЗнак    =4;
  зМодуль   =5;
  зМин      =6;
  зМакс     =7;
  зУзк      =8;
  зУвеличить=9;
  зУменьшить=10;
  зСтоп     =11;
  зРазмер   =12;
  зДлина    =13;
  зСоздать  =14;
  зСписать  =15;
  зЗадано   =16;
  зПроверить=17;
  зПоставить=18;
  зСместить =19;
  зОбнулить =20; 
  зЦелЧасть =21;
                    (* Номера задач ОБХОД отдела (нУзел.подроду). Из ПД. *)
  зПолучитьАдрес=23;
  зИзПамяти     =24;
  зВПамять      =25;
  зЗначение     =26;
  зОбраз        =27;
  зОУзк         =28;

                            (*--- общедоступные ВИДы ---*)

(*------------------------------------ ВидВид --------------------------------*)
ВИД
  нВид- = НАБОР(ЧэргаСлеД.нПустой)

    след+:ВД.ДкПонятию;(* 
    приёмники          приёмники у переменных вида ЗАДАЧА
    деревосв       * | свойства у наборов
                   * | имя неизвестного вида в опережающем доступе            *)
    родв+:ЦЕЛ;    (* род вида: вНеопр|вЯчейка|вКлюч|..|вНабор                 *)
    вхнОтд+:ЦЕЛ;  (* 0 для тек. отдела | номер входного отдела (в вхОтд)      *)
    колено+:ЦЕЛ;  (* поколение Набора: 0..                                    *)
    n+:ЦЕЛ;       (* 
    слагаемых          число слагаемых ряда
    размерность      | размерность открытого ряда
    сжатый           | =1 для сжатого Набора
    невызываемый     | =1 если вид невызываемых задач                         *)
    размер+:ЦЕЛ;  (*   размер переменной данного вида 
                     | размер описания ОРяда в стеке                          *)
    адрОВ+:ЦЕЛ;   (*   адрес ОВ для Набора 
    смещениеОВ       | смещение РАЗМЕР для ОРяда в стеке                      *)
    овид+:ВД.ДкВиду;     (* опорный вид                                       *)
     пон+:ВД.ДкПонятию;  (* ПУСТО | понятие, определяющее этот вид            *)

    текстп+:ОО.нТекстПоз;(* позиция описания в тексте отдела                  *)
    типОД+:ЦЕЛ;   (* вид отладочной записи CodeView                           *)
    номв:ЦЕЛ      (* номер вида для выходного файла: вНеопр|..|вНабор|..      *)
  КОН;

                      (*--
                               локальные ПОСТоянные 
                        --*)
ПОСТ
  (*                        Род видов (нВид.родв). Из ВД.
 Причём:
          вЯчейка <= вЦел8 <= вЗнак <= вЦел16 <= вЦел32 <= вЦел64.
   *)
  вНеопр  = 0;
  вЯчейка = 1;
  вКлюч   = 2;
  вЗнак   = 3;
  вЦел8   = 4;
  вЦел16  = 5;
  вЦел32  = 6;
  вЦел64  = 7;
  вВещ32  = 8;
  вВещ64  = 9;
  вМнож   =10;
  вПЦепь  =11;
  вПусто  =12;
  вНет    =13;
  вДоступ =14;
  вЗадача =15;
  вБегунок=16;
  вРяд    =17;
  вОРяд   =18;
  вНабор  =19;
  вКон    =20; (* вКон для ДВ. При изменении вКон нужно 3 преобразования с уборка:=ОТКЛ. *)
(*
  родв    | n          овид      след     вхнОтд  адрОВ    текстп
  ===============================================================
  вНеопр  | 0
  вЯчейка | 1
  вКлюч   | 2
  вЗнак   | 3
  вЦел8   | 4
  вЦел16  | 5
  вЦел32  | 6
  вЦел64  | 7
  вВещ32  | 8
  вВещ64  | 9
  вМнож   | 10
  вПЦепь  | 11
  вПусто  | 12
  вНет    | 13
  вДоступ | 14         PBaseTyp           вхнОтд           текстп
  вЗадача | 15         ResTyp    params   вхнОтд           текстп
  вБегунок| 16 шаг     основание          вхнОтд  адрОВ    текстп
  вРяд    | 17 nofel   ElemTyp            вхнОтд           текстп
  вОРяд   | 18 dim     ElemTyp            вхнОтд  lenoff   текстп
  вНабор  | 19         RBaseTyp  fields   вхнОтд  адрОВ    текстп
*)

  множЦел={вЦел8..вЦел64};
  множВещ={вВещ32,вВещ64};


                            (*--- общедоступные ВИДы ---*)
ВИД
(*------------------------------------ ВидПост -------------------------------*)
  нПост- = НАБОР

    цепьД+:Пустой.ДкЦепи;     (* значение цепочки
                    | у принимаемой подзадачи имя её ДПБ файла *)
    цел+  :ШИРЦЕЛ;            (* значение целой постоянной       *)
    цел1+ :ЦЕЛ;               (* адр
                  * | у ЗАДАЧА размер параметров
                  * | у ВЫБРАТЬ наименьшая метка    *)
    цел2+ :ЦЕЛ;               (* у ЗАДАЧА размер переменных
                  * | у ВЫБРАТЬ наибольшая метка    *)
    множ+ :МНОЖ;              (* значение постоянного множества
                  * | у ВЫБРАТЬ {1} => есть ИНАЧЕ   *)
    вещ+  :ШИРВЕЩ             (* значение (ШИР)ВЕЩ постоянной    *)
  КОН;

(*-------------------------------- DebugInfoDesc -----------------------------*)
        DebugInfoDesc- =
  НАБОР
    codeDebugStart+,
    codeDebugEnd+,
           procLen+ :ЦЕЛ    
  КОН;

(*-================================== ПОСТ ПЕР ==============================-*)
ПОСТ
  ВсегоОтделов- = 128(*64*);        (* наибольшее число отделов. Из ВД.отд    *)
  ВсегоВидов    =1023;              (* наибольшее число видов в каждом отделе *)

ПЕР
  неопрвид+,оячвид+,оячкивид+,одоствид+,
  цел8вид+,цел16вид+,цел32вид+,цел64вид+,вещ32вид+,вещ64вид+,
  ключвид+,знаквид+,множвид+,пцепьвид+,пустовид+,нетвид+:ВД.ДкВиду;

  текОбласть+:ВД.ДкПонятию; (* текущая область действия, причем
   .лево    - область окружения
   .право   - верх дерева понятий данной области
   .след    - начало списка задач данной области
   .уровень - уровень вложенности *)

  чВхОтд-:ЦЕЛ; (* число входных отделов *)
(*
  ряд из доступов к нПонятие во всех Входных Отделах
*)
  рПонВхОтд-:РЯД ВД.ВсегоОтделов ИЗ ВД.ДкПонятию; (* все Входные Отделы, где
  рПонВхОтд[].право  - верх дерева понятий данного отдела
  рПонВхОтд[].имя    - имя отдела,
  рПонВхОтд[].адр    - номер в символьной таблице COFF для Код, Пер и Пост,
  рПонВхОтд[].уровень = -вхнОтд
  рПонВхОтд[].имяФ^  - полное имя файла отдела *)

  встрОбласть:ВД.ДкПонятию;

    слномвида:ЦЕЛ; (* следующий номер вида для выходного файла *)

(*---
                        набор-список из доступов к неопределённым видам данных
  ---*)
ПЕР
  доступыКнеоВидам:ЧэргаСлеД.нСписок;                 (* очередь из ВД.ДкВиду *)

                      (*--
                               локальные ПОСТоянные 
                        --*)
ПОСТ
                      (* метки в файле общих понятий *)
  мПост         = 1;
  мВид          = 2;
  мСкрВид       = 3;
  мПер          = 4;
  мНеизмПер     = 5;
  мЗадача       = 6;
  мНеВызЗадача  = 7;
  мБегунок      = 8;
  мДоступ       = 9;
  мВидЗадача    =10;
  мРяд          =11;
  мОРяд         =12;
  мНабор        =13;
  мПриёмники    =14;
  мПрЗнач       =15;
  мНеизмПрЗнач  =16;
  мПрСсылки     =17;
  мНеизмПрСсылки=18;
  мСвойства     =19;
  мСвойство     =20;
  мНеизмСвойство=21;
  мСкрепка      =22;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       СоздатьПон-():ВД.ДкПонятию;
ПЕР
          пон:ВД.ДкПонятию;
УКАЗ
  СОЗДАТЬ(пон);
  ВОЗВРАТ пон
КОН СоздатьПон;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ПодготовитьВид(видД:ВД.ДкВиду;
                      родв:ЦЕЛ);
УКАЗ
  видД.родв:=родв;
  видД.адрОВ:=НП.АдрНеопр;
  видД.текстп:=ОО.текПоз;
  видД.размер:= -1;
  видД.овид:=ВД.неопрвид
КОН ПодготовитьВид;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       СоздатьВид-(родв:ЦЕЛ):ВД.ДкВиду;
ПЕР
                 видД:ВД.ДкВиду;
УКАЗ
         СОЗДАТЬ(видД);
  ПодготовитьВид(видД,родв);
         ВОЗВРАТ видД
КОН СоздатьВид;

ЗАДАЧА СоздатьПост-():ВД.ДкПост;
ПЕР
  пост:ВД.ДкПост;
УКАЗ
  СОЗДАТЬ(пост);
  ВОЗВРАТ пост;
КОН СоздатьПост;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       НайтиВДереве-(верх,
                     пон+:ВД.ДкПонятию);
(*
 *  Цель: найти в дереве с вершиной <верх> понятия <пон> с именем <РС.имя>
 * После: <пон> = ПУСТО, если понятие не найдено.
 *)
УКАЗ
       пон:=верх;
  ПОКА
       пон # ПУСТО
  ВЫП
    ЕСЛИ  РС.имя < пон.имя ТО пон:=пон.лево
    АЕСЛИ РС.имя > пон.имя ТО пон:=пон.право
    ИНАЧЕ (* нашли *) ВОЗВРАТ КОН
  КОН
КОН НайтиВДереве;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       Найти-(пон+:ВД.ДкПонятию);
(*
 *  Цель: найти в области действия <текОбласть> и в охватывающих ее областях
 *        понятия <пон> с именем <РС.имя>
 * После: <пон> = ПУСТО, если понятие не найдено
 *)
ПЕР
                 верх: ВД.ДкПонятию;
УКАЗ
                 верх:=ВД.текОбласть;
  ПОВТОРЯТЬ
    НайтиВДереве(верх.право,пон);
                 верх:=верх.лево
  ДО (пон # ПУСТО) ИЛИ (верх = ПУСТО)
КОН Найти;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       НаборРасширен-(ов,рв:ВД.ДкВиду);
(*
 *  Цель: проверить является ли набор <рв> расширением <ов>
 * После: если это не так, то ошибка
 *)
УКАЗ
  ПОКА (рв # ов) И (рв # ВД.неопрвид) ВЫП
    рв:=рв.овид
  КОН;
  ЕСЛИ рв = ВД.неопрвид ТО
    ОО.Ошибка(ОО.ЭТО_НЕ_РАСШИРЕНИЕ)
  КОН
КОН НаборРасширен;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       НайтиСвойство-(видД :ВД.ДкВиду;
                       пон+:ВД.ДкПонятию);
(*
 *  Цель: найти в наборе <видД> свойство <пон> с именем <РС.имя>
 * После: <пон> = ПУСТО, если понятие не найдено
 *)
УКАЗ
  ПОВТОРЯТЬ
           НайтиВДереве(видД.след,пон);
                        видД:=видД.овид
  ДО (пон # ПУСТО) ИЛИ (видД = ВД.неопрвид)
КОН НайтиСвойство;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВставитьВДерево(дерево,
                          пон,
                         было+:ВД.ДкПонятию);
(*
 * Если в дереве <дерево> с вершиной <дерево.право> находит понятие
 * с именем <пон.имя>, то возвращает его в <было>, иначе помещает <пон> в дерево.
 *)
ПЕР
  след:ВД.ДкПонятию; (* следующее понятие в поиске *)
УКАЗ
  было:=ПУСТО;
  пон.уровень:=дерево.уровень;

       след:=дерево.право;
  ЕСЛИ
       след = ПУСТО
  ТО
    дерево.право:=пон;
    ВОЗВРАТ
  КОН;
  КОЛЬЦО
    ЕСЛИ
         пон.имя < след.имя
    ТО
      ЕСЛИ
           след.лево = ПУСТО
      ТО
           след.лево:=пон;
        ВЫХОД
      КОН;
           след:=след.лево
    АЕСЛИ
           пон.имя > след.имя
    ТО
      ЕСЛИ
           след.право = ПУСТО
      ТО
           след.право:=пон;
        ВЫХОД
      КОН;
           след:=след.право
    ИНАЧЕ
      было:=след;
      ВЫХОД
    КОН
  КОН
КОН ВставитьВДерево;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       Вставить-(имя-:ЦЕПЬ;
                 пон+:ВД.ДкПонятию);
(*
 * Размещает новое понятие <пон> с именем <имя>
 * в области видимости <текОбласть>
 *)
ПЕР
       было:ВД.ДкПонятию;
УКАЗ
              пон:=СоздатьПон();
  СПИСАТЬ(имя,пон.имя);
  ВставитьВДерево(ВД.текОбласть,пон,было);
  ЕСЛИ
       было # ПУСТО
  ТО                                          (* повторное определение *)
    ОО.Отметить(ОО.ПЕРЕОПРЕДЕЛЕНИЕ,имя)
  КОН
КОН Вставить;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       ОткрытьОбласть-(уровень:ЦЕЛ);
(*
 * Создает головное понятие для новой области видимости и
 * помещает его на вершину <текОбласть>.
 *)
ПЕР
  пон:ВД.ДкПонятию;
УКАЗ
  пон:=СоздатьПон();
  пон.родп:=пОбласть;
  пон.уровень:=уровень;
  пон.лево:=ВД.текОбласть;
            ВД.текОбласть:=пон
КОН ОткрытьОбласть;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       ЗакрытьОбласть-;
УКАЗ
  ВД.текОбласть:=ВД.текОбласть.лево
КОН ЗакрытьОбласть;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       УстОтдел-(имя-:НП.Имя);
ПЕР
          пон:ВД.ДкПонятию;
УКАЗ
          пон:=СоздатьПон();
          пон.имя:=имя;

  СОЗДАТЬ(пон.имяФ,ФО.отдИмяФ);

  ВД.рПонВхОтд[0]:=пон
КОН УстОтдел;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       Использовать-(
                      испИмя-,
                      испПуть- :ЦЕПЬ
                    );
ПЕР
  tag,i,номв:ЦЕЛ;

  пон,
  было :ВД.ДкПонятию;
   видД:ВД.ДкВиду;
  пост :ВД.ДкПост;

  вхИмя :НП.Имя;
  вхИмяФ:ЦЕПЬ[250];
            (* исп. отдел (рПонВхОтд_исп[0]) и входные отделы используемого отдела *)
  чВхОтд_исп,
  нВхОтд_исп:ЦЕЛ;

  рПонВхОтд_исп:РЯД ВД.ВсегоОтделов ИЗ ВД.ДкПонятию;

  рДкВиду:РЯД ВсегоВидов ИЗ ВД.ДкВиду;

  слномвида,parlev,fldlev:ЦЕЛ;
  parlist,lastpar,fldlist,lastfld:РЯД 6 ИЗ ВД.ДкПонятию;

 (*................................................подЗАДАЧА...*)
  ЗАДАЧА reverseList(      p:ВД.ДкПонятию;
                     уровень:ЦЕЛ);
  ПЕР
    q,r:ВД.ДкПонятию;
  УКАЗ
    q:=ПУСТО;
    ПОКА p # ПУСТО ВЫП
      p.уровень:=уровень;
      r:=p.след;
      p.след:=q;
      q:=p;
      p:=r
    КОН
  КОН reverseList;

УКАЗ
  ЕСЛИ
       испИмя = "ОБХОД"
  ТО
    Вставить(испИмя,пон);
                    пон.родп:=пОтдел;
                    пон.уровень:=0;
                    пон.область:=встрОбласть;
                    пон.адр:=0;
                    пон.вид:=ВД.нетвид;
    ВОЗВРАТ
  КОН;
  слномвида:=вКон;
  parlev:=-1;
  fldlev:=-1;

  рДкВиду[вНеопр] :=ВД.неопрвид;
  рДкВиду[вЯчейка]:=ВД.оячвид;   рДкВиду[вКлюч]  :=ВД.ключвид;    
  рДкВиду[вЦел8]  :=ВД.цел8вид;  рДкВиду[вЗнак]  :=ВД.знаквид;
  рДкВиду[вЦел16] :=ВД.цел16вид; рДкВиду[вЦел32] :=ВД.цел32вид;
  рДкВиду[вЦел64] :=ВД.цел64вид; рДкВиду[вВещ32] :=ВД.вещ32вид;
  рДкВиду[вВещ64] :=ВД.вещ64вид; рДкВиду[вМнож]  :=ВД.множвид;
  рДкВиду[вПЦепь] :=ВД.пцепьвид; рДкВиду[вПусто] :=ВД.пустовид;
  рДкВиду[вНет]   :=ВД.нетвид;   рДкВиду[вДоступ]:=ВД.одоствид; (*!*)

  ФО.ОпчОткрыть(испИмя,испПуть);
                                (* читаем входные отделы используемого отдела *)
  было:=ПУСТО;
    ФО.ОпчЦел(чВхОтд_исп);
  ЕСЛИ
       чВхОтд_исп >= ВД.ВсегоОтделов
  ТО
    ОО.Ошибка(ОО.МНОГО_ОТДЕЛОВ)
  КОН;
  ОТ нВхОтд_исп:=0 ДО чВхОтд_исп-1 ВЫП
    ФО.ОпчЦепь(вхИмя);
    ФО.ОпчЦепь(вхИмяФ);
           i:=0;
    ПОКА ( i < ВД.чВхОтд) И (вхИмяФ # ВД.рПонВхОтд[i].имяФ^) ВЫП
      УВЕЛИЧИТЬ(i)
    КОН;
    ЕСЛИ
           i < чВхОтд
    ТО                                           (* этот отдел уже есть *)
      ЕСЛИ i = 0 ТО                                    (* это наш отдел *)
        ОО.Ошибка(ОО.ПЕРЕКРЕСТНОЕ_ИСПОЛЬЗОВАНИЕ)
      КОН;
      пон:=ВД.рПонВхОтд[i]
    ИНАЧЕ
      ЕСЛИ ВД.чВхОтд >= ВД.ВсегоОтделов ТО
        ОО.Ошибка(ОО.МНОГО_ОТДЕЛОВ)
      КОН;
              пон:=СоздатьПон();
              пон.имя:=вхИмя;

      СОЗДАТЬ(пон.имяФ,вхИмяФ);

      ЕСЛИ нВхОтд_исп
 = 0 ТО (* сам используемый отдел надо поместить в конец *)
        было:=пон
      ИНАЧЕ
                                пон.уровень:= -ВД.чВхОтд;
        ВД.рПонВхОтд[ВД.чВхОтд]:=пон;
           УВЕЛИЧИТЬ(ВД.чВхОтд)
      КОН
    КОН;
    рПонВхОтд_исп[нВхОтд_исп]:=пон
  КОН;
  ЕСЛИ было # ПУСТО ТО
                             было.уровень:= -ВД.чВхОтд;
    ВД.рПонВхОтд[ВД.чВхОтд]:=было;
       УВЕЛИЧИТЬ(ВД.чВхОтд)
  КОН;
                            (* чтение принимаемых задач *)
  ПЗ.Чтение;
                            (* чтение основных данных *)
  ПОКА НЕ ФО.ОпчКонец() ВЫП
(*
  мПост         = 1;
  мВид          = 2;
  мСкрВид       = 3;
  мПер          = 4;
  мНеизмПер     = 5;
  мЗадача       = 6;
  мНеВызЗадача  = 7;
  мБегунок      = 8;
  мДоступ       = 9;
  мВидЗадача    =10;
  мРяд          =11;
  мОРяд         =12;
  мНабор        =13;
  мПриёмники    =14;
  мПрЗнач       =15;
  мНеизмПрЗнач  =16;
  мПрСсылки     =17;
  мНеизмПрСсылки=18;
  мСвойства     =19;
  мСвойство     =20;
  мНеизмСвойство=21;
  мСкрепка      =22;
*)
    ФО.ОпчЦел(tag);

    ЕСЛИ           (*    1,   2,      3,   4,        5,      6,          7 *)
              tag В {мПост,мВид,мСкрВид,мПер,мНеизмПер,мЗадача,мНеВызЗадача}
(* выход значения за допустимые пределы *)
    ТО 
                          (* понятие *)
      пон :=СоздатьПон();

      ФО.ОпчЦел(номв);

               видД:=рДкВиду[номв];
      пон.вид:=видД;
      нВхОтд_исп:=0;

      ВЫБРАТЬ tag ИЗ
      | мПост:
          пон.родп:=пПост;
          пост:=СоздатьПост();

          ВЫБРАТЬ видД.родв ИЗ
          | вЯчейка,вЗнак,вКлюч,вЦел8,вЦел16,вЦел32,вЦел64:
              ФО.ОпчШирЦел(пост.цел)
          | вМнож:
              ФО.ОпчМнож(пост.множ)
          | вВещ32,вВещ64:
              ФО.ОпчШирВещ(пост.вещ);
              пост.цел1:=НП.АдрНеопр
          | вПЦепь:
              ФО.ОпчПЦепь(пост.цепьД);
              пост.цел1:=НП.АдрНеопр
          | вПусто:
              пост.цел:=0
(*
          ИНАЧЕ
              пост.цел:=0
*)
          КОН;
          пон.пост:=пост

      | мВид,мСкрВид:
          пон.родп:=пВид;
          ЕСЛИ видД.пон = ПУСТО ТО 
               видД.пон:=пон 
          КОН;
          ЕСЛИ tag = мВид ТО
            пон.признаки:={прОбщедоступная}
          КОН;
          ФО.ОпчЦел(нВхОтд_исп)

      | мПер,мНеизмПер:
          пон.родп:=пПер;
          ФО.ОпчЦел(пон.адр);
          ЕСЛИ tag = мНеизмПер ТО
            пон.признаки:={прОбщедоступная,прНеизменяемая}
          ИНАЧЕ
            пон.признаки:={прОбщедоступная}
          КОН

      | мЗадача,мНеВызЗадача:
          пон.родп:=пЗадача;
          пон.пост:=СоздатьПост();
          пон.пост.цел:=-1;
          ЕСЛИ tag=мНеВызЗадача ТО
            пон.признаки:={прПередаваемая}
          КОН;
          reverseList(lastpar[parlev],рПонВхОтд_исп[0].уровень);
          пон.след:=parlist[parlev].право;
          УМЕНЬШИТЬ(parlev)
(*
      ИНАЧЕ
*)
      КОН;
      ФО.ОпчЦепь(пон.имя);
      ВставитьВДерево(рПонВхОтд_исп[нВхОтд_исп],пон,было);
      ЕСЛИ
            (было # ПУСТО)
          И
            (пон.родп = пВид)
      ТО
        рДкВиду[номв]:=было.вид
      КОН
(*
  мПост         = 1;
  мВид          = 2;
  мСкрВид       = 3;
  мПер          = 4;
  мНеизмПер     = 5;
  мЗадача       = 6;
  мНеВызЗадача  = 7;
  мБегунок      = 8;
  мДоступ       = 9;
  мВидЗадача    =10;
  мРяд          =11;
  мОРяд         =12;
  мНабор        =13;
  мПриёмники    =14;
  мПрЗнач       =15;
  мНеизмПрЗнач  =16;
  мПрСсылки     =17;
  мНеизмПрСсылки=18;
  мСвойства     =19;
  мСвойство     =20;
  мНеизмСвойство=21;
  мСкрепка      =22;
*)
    АЕСЛИ            (*    13,   12,  11,       8,        10,     9 *)
                tag В {мНабор,мОРяд,мРяд,мБегунок,мВидЗадача,мДоступ}
(* выход значения за допустимые пределы *)
    ТО
                              (* вид *)
      видД:=СоздатьВид(вНеопр);

      ФО.ОпчЦел(номв);

      видД.овид:=рДкВиду[номв];

      ФО.ОпчЦел(нВхОтд_исп);            (* входной номер отдела в исп. отделе *)

      видД.вхнОтд:= -рПонВхОтд_исп[нВхОтд_исп].уровень;

      ВЫБРАТЬ tag ИЗ
      | мДоступ:
                    видД.родв:=вДоступ;
                    видД.размер:=НП.рДоступ

      | мВидЗадача:
                    видД.родв:=вЗадача;
                    видД.размер:=НП.рЗадача;
          ФО.ОпчЦел(видД.n);

                 reverseList(lastpar[parlev],-видД.вхнОтд);
          видД.след:=parlist[parlev].право;
          УМЕНЬШИТЬ(parlev)

      | мБегунок:
                    видД.родв:=вБегунок;
                    видД.размер:=НП.рБегунок;
          ФО.ОпчЦел(видД.n)

      | мРяд:
                    видД.родв:=вРяд;
          ФО.ОпчЦел(видД.размер);
                    видД.n:=видД.размер ДЕЛИТЬ видД.овид.размер
      | мОРяд:
                    видД.родв:=вОРяд;
          ФО.ОпчЦел(видД.размер);
          ЕСЛИ      видД.овид.родв = вОРяд ТО
                    видД.n:=видД.овид.n+1
          ИНАЧЕ
                    видД.n:=0
          КОН;
          ФО.ОпчЦел(видД.адрОВ)

      | мНабор:
                    видД.родв:=вНабор;
          ФО.ОпчЦел(видД.размер);

          reverseList(lastfld[fldlev],-видД.вхнОтд);

                    видД.след:=fldlist[fldlev].право;

          УМЕНЬШИТЬ(fldlev);
          ЕСЛИ      видД.овид = ВД.нетвид ТО
                    видД.овид:=ВД.неопрвид;
                    видД.колено:=0
          ИНАЧЕ
                    видД.колено:=видД.овид.колено+1
          КОН;
          ФО.ОпчЦел(видД.адрОВ)
(*
      ИНАЧЕ
*)
      КОН;
        рДкВиду[слномвида]:=видД;
      УВЕЛИЧИТЬ(слномвида)

    АЕСЛИ      (*    14   *)
          tag = мПриёмники
    ТО 
                               (* начало списка приёмников *)
      ЕСЛИ parlev >= 5 ТО
        ОО.Ошибка(ОО.МНОГО_ВЛОЖЕННЫХ)
      КОН;
      пон:=СоздатьПон();
      УВЕЛИЧИТЬ(parlev);
      parlist[parlev]:=пон;
      lastpar[parlev]:=ПУСТО
(*
  мПост         = 1;
  мВид          = 2;
  мСкрВид       = 3;
  мПер          = 4;
  мНеизмПер     = 5;
  мЗадача       = 6;
  мНеВызЗадача  = 7;
  мБегунок      = 8;
  мДоступ       = 9;
  мВидЗадача    =10;
  мРяд          =11;
  мОРяд         =12;
  мНабор        =13;
  мПриёмники    =14;
  мПрЗнач       =15;
  мНеизмПрЗнач  =16;
  мПрСсылки     =17;
  мНеизмПрСсылки=18;
  мСвойства     =19;
  мСвойство     =20;
  мНеизмСвойство=21;
  мСкрепка      =22;
*)
    АЕСЛИ       (*     15,          16,       17,           18 *)
           tag В {мПрЗнач,мНеизмПрЗнач,мПрСсылки,мНеизмПрСсылки}
(* выход значения за допустимые пределы *)
    ТО 
                            (* приёмник *)
      пон:=СоздатьПон();

      ВЫБРАТЬ tag ИЗ
      | мПрЗнач:
          пон.родп:=пПер

      | мНеизмПрЗнач:
          пон.родп:=пПер;
          пон.признаки:={прНеизменяемая}

      | мПрСсылки:
          пон.родп:=пПрСсылки

      | мНеизмПрСсылки:
          пон.родп:=пПрСсылки;
          пон.признаки:={прНеизменяемая}
(*
      ИНАЧЕ
*)
      КОН;
      ФО.ОпчЦел(номв);
      пон.вид  :=рДкВиду[номв];
(*
      пон.видпр:=пон.вид;
*)
      ФО.ОпчЦепь(пон.имя);
      пон.след:=lastpar[parlev];
                lastpar[parlev]:=пон;
      ЕСЛИ
           parlist[parlev].право = ПУСТО
      ТО
           parlist[parlev].право:=пон
      КОН
    АЕСЛИ     (*    19   *)
          tag = мСвойства
    ТО
                                 (* начало списка свойств наблюдаемого набора *)
      ЕСЛИ fldlev >= 5 ТО
        ОО.Ошибка(ОО.МНОГО_ВЛОЖЕННЫХ)
      КОН;
      пон:=СоздатьПон();
      УВЕЛИЧИТЬ(fldlev);
      fldlist[fldlev]:=пон;
      lastfld[fldlev]:=ПУСТО

    АЕСЛИ       (*       20,           21 *)
           tag В {мСвойство,мНеизмСвойство}
(* выход значения за допустимые пределы *)
    ТО                                                    (* свойство *)  
      пон:=СоздатьПон();
      пон.родп:=пСвойство;
      ЕСЛИ
           tag = мНеизмСвойство
      ТО
        пон.признаки:={прОбщедоступная,прНеизменяемая}
      ИНАЧЕ
        пон.признаки:={прОбщедоступная}
      КОН;
      ФО.ОпчЦел(номв);
      пон.вид:=рДкВиду[номв];
      ФО.ОпчЦел(пон.адр);
      ФО.ОпчЦепь(пон.имя);
      пон.след:=lastfld[fldlev];

      lastfld[fldlev]:=пон;

      ВставитьВДерево(fldlist[fldlev],пон,было)

    АЕСЛИ      (*   22  *)
          tag = мСкрепка
    ТО                                                   (* ссылка на доступ *)
      ФО.ОпчЦел(номв);
           видД:=рДкВиду[номв];
      ФО.ОпчЦел(номв);
      ЕСЛИ
           видД.овид = ВД.неопрвид
      ТО
           видД.овид:=рДкВиду[номв]
      КОН
    КОН
  КОН;
  ФО.ОпчЗакрыть;
  Вставить(испИмя,пон);
  пон.родп:=пОтдел;
  пон.область:=рПонВхОтд_исп[0].право;
  пон.уровень:=рПонВхОтд_исп[0].уровень;
  пон.вид:=ВД.нетвид
КОН Использовать;


(*-оооооооооооооо- опережающие определения/заготовки задач -ооооооооооооооооо-*)

ЗАДАЧА ^ВыводВида(видД:ВД.ДкВиду);
ЗАДАЧА ^ВыводПонятия(пон:ВД.ДкПонятию);


(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВыводПриемников(пр:ВД.ДкПонятию);
УКАЗ
  ФО.ОпзЦел(мПриёмники);
  ПОКА пр # ПУСТО ВЫП
    ВыводВида(пр.вид);
    ЕСЛИ пр.родп = пПер ТО
      ЕСЛИ прНеизменяемая В пр.признаки ТО
        ФО.ОпзЦел(мНеизмПрЗнач)
      ИНАЧЕ
        ФО.ОпзЦел(мПрЗнач)
      КОН
    ИНАЧЕ
      ЕСЛИ прНеизменяемая В пр.признаки ТО
        ФО.ОпзЦел(мНеизмПрСсылки)
      ИНАЧЕ
        ФО.ОпзЦел(мПрСсылки)
      КОН
    КОН;
    ФО.ОпзЦел(пр.вид.номв);
    ФО.ОпзЦепь(пр.имя);
    пр:=пр.след
  КОН
КОН ВыводПриемников;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВыводСвойств(свво:ВД.ДкПонятию);
УКАЗ
  ФО.ОпзЦел(мСвойства);
  ПОКА свво # ПУСТО ВЫП
    ВыводВида(свво.вид);
    ЕСЛИ прНеизменяемая В свво.признаки ТО ФО.ОпзЦел(мНеизмСвойство) ИНАЧЕ ФО.ОпзЦел(мСвойство) КОН;
    ФО.ОпзЦел(свво.вид.номв);
    ФО.ОпзЦел(свво.адр);
    ФО.ОпзЦепь(свво.имя);
    свво:=свво.след
  КОН
КОН ВыводСвойств;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВыводВида(видД:ВД.ДкВиду);
ПЕР
   вхнОтд,
  номвидо :ЦЕЛ;
    овид  :ВД.ДкВиду;
УКАЗ
  ЕСЛИ    видД.номв > 0 ТО (* обработан *)
    ВОЗВРАТ
  КОН;
  вхнОтд:=видД.вхнОтд;
    овид:=видД.овид;
  ВЫБРАТЬ видД.родв ИЗ
  | вДоступ:
        ФО.ОпзЦел(мДоступ);
      ЕСЛИ овид.номв > 0 ТО
        ФО.ОпзЦел(овид.номв)
      ИНАЧЕ
        ФО.ОпзЦел(вНеопр);

        ЧэргаСлеД.ДобавитьНовЗвеноВконСписка(доступыКнеоВидам,видД)
      КОН;
      ФО.ОпзЦел(вхнОтд)
  | вЗадача:
      ВыводВида(овид);
      ВыводПриемников(видД.след);
      ФО.ОпзЦел(мВидЗадача);
      ФО.ОпзЦел(овид.номв);
      ФО.ОпзЦел(вхнОтд);
      ФО.ОпзЦел(видД.n)
  | вБегунок:
      ВыводВида(овид);
      ФО.ОпзЦел(мБегунок);
      ФО.ОпзЦел(овид.номв);
      ФО.ОпзЦел(вхнОтд);
      ФО.ОпзЦел(видД.n)
  | вРяд:
      ВыводВида(овид);
      ФО.ОпзЦел(мРяд);
      ФО.ОпзЦел(овид.номв);
      ФО.ОпзЦел(вхнОтд);
      ФО.ОпзЦел(видД.размер)
  | вОРяд:
      ВыводВида(овид);
      ФО.ОпзЦел(мОРяд);
      ФО.ОпзЦел(овид.номв);
      ФО.ОпзЦел(вхнОтд);
      ФО.ОпзЦел(видД.размер);
      ФО.ОпзЦел(видД.адрОВ)
  | вНабор:
      ЕСЛИ
           овид = ВД.неопрвид
      ТО
        номвидо:=вНет
      ИНАЧЕ
        ВыводВида(овид);
        номвидо:=овид.номв
      КОН;
      ВыводСвойств(видД.след);

        ФО.ОпзЦел(мНабор);
        ФО.ОпзЦел(номвидо);
        ФО.ОпзЦел(вхнОтд);
        ФО.ОпзЦел(видД.размер);
      ЕСЛИ
           НП.отдВид = НП.описание
      ТО
        ФО.ОпзЦел(0)
      ИНАЧЕ
        ФО.ОпзЦел(видД.адрОВ)
      КОН
  КОН;
  видД.номв:=слномвида;
   УВЕЛИЧИТЬ(слномвида);
  ЕСЛИ
       слномвида >= ВсегоВидов
  ТО
    ОО.Ошибка(ОО.МНОГО_ОБЩЕДОСТУПНЫХ)
  КОН;
  ЕСЛИ
       видД.пон # ПУСТО
  ТО                                  (* это именованный видД *)
    ВыводПонятия(видД.пон)
  КОН
КОН ВыводВида;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВыводПонятия(пон:ВД.ДкПонятию);
ПЕР
  видД:ВД.ДкВиду;
УКАЗ
  ВЫБРАТЬ пон.родп ИЗ
  | пВид:
                видД:=пон.вид;
      ВыводВида(видД);
      ЕСЛИ прОбщедоступная В пон.признаки ТО
        ФО.ОпзЦел(мВид)
      ИНАЧЕ
        ФО.ОпзЦел(мСкрВид)
      КОН;
      ФО.ОпзЦел(видД.номв);
      (* "ВИД в2=О1.в1;" *)
      ЕСЛИ (видД.пон # пон) ТО
        ФО.ОпзЦел(0) (* вхнОтд для в2 *)
      ИНАЧЕ
        ФО.ОпзЦел(видД.вхнОтд) (* вхнОтд для в1 *)
      КОН;
      ФО.ОпзЦепь(пон.имя)
  | пПер:
       ВыводВида(пон.вид);
      ЕСЛИ
           прНеизменяемая В пон.признаки
      ТО
        ФО.ОпзЦел(мНеизмПер)
      ИНАЧЕ
        ФО.ОпзЦел(мПер)
      КОН;
        ФО.ОпзЦел( пон.вид.номв);
        ФО.ОпзЦел( пон.адр);
        ФО.ОпзЦепь(пон.имя)
  | пПост:
        ФО.ОпзЦел(мПост);
        ФО.ОпзЦел( пон.вид.родв);
      ВЫБРАТЬ
                   пон.вид.родв
      ИЗ
      | вЯчейка,вЗнак,вКлюч,вЦел8,вЦел16,вЦел32,вЦел64:
          ФО.ОпзШирЦел(пон.пост.цел)
      | вМнож:
          ФО.ОпзМнож(пон.пост.множ)
      | вВещ32,вВещ64:
          ФО.ОпзШирВещ(пон.пост.вещ)
      | вПЦепь:
          ФО.ОпзПЦепь(пон.пост.цепьД^)
      | вПусто:
      КОН;
          ФО.ОпзЦепь( пон.имя)
  | пЗадача:
      ВыводВида(пон.вид);
      ВыводПриемников(пон.след);
      ЕСЛИ
           прПередаваемая В пон.признаки
      ТО 
        ФО.ОпзЦел(мНеВызЗадача) 
      ИНАЧЕ 
        ФО.ОпзЦел(мЗадача) 
      КОН;
        ФО.ОпзЦел(пон.вид.номв);
        ФО.ОпзЦепь(пон.имя)
  ИНАЧЕ
  КОН
КОН ВыводПонятия;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВыводПонятий(пон:ВД.ДкПонятию);
УКАЗ
  ЕСЛИ пон # ПУСТО ТО

       ВыводПонятий(пон.лево);                (* рекурсия *)
                                   (* записываем только общедоступные понятия *)
    ЕСЛИ прОбщедоступная В пон.признаки ТО

       ВыводПонятия(пон)

    КОН;
       ВыводПонятий(пон.право)
  КОН
КОН ВыводПонятий;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВыводНеоДост;
ПЕР
    видД:ВД.ДкВиду;
         звеноД:ЧэргаСлеД.ДкЗвену_телоД;
УКАЗ
(*
   Обход списка с 1-го звена до N-го, т.е. пока звеноД.слеД # ПУСТО
 *)
          звеноД:=ЧэргаСлеД.Дк1муЗвену(доступыКнеоВидам);
  ПОКА
          звеноД # ПУСТО
  ВЫП
    видД:=звеноД.телоД(ВД.ДкВиду);

    ВыводВида(видД.овид);

    ФО.ОпзЦел(мСкрепка);
    ФО.ОпзЦел(видД.номв);
    ФО.ОпзЦел(видД.овид.номв);

          звеноД:=звеноД.слеД
  КОН;
  ЧэргаСлеД.ОчиститьСписок(доступыКнеоВидам)
КОН ВыводНеоДост;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ВыводИспОтделов;
ПЕР
     но:ЦЕЛ;
УКАЗ
    ФО.ОпзЦел(ВД.чВхОтд);
  ОТ но:=0 ДО ВД.чВхОтд-1 ВЫП
    ФО.ОпзЦепь(ВД.рПонВхОтд[но].имя);
    ФО.ОпзЦепь(ВД.рПонВхОтд[но].имяФ^)
  КОН
КОН ВыводИспОтделов;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       Сохранить-;
УКАЗ
  ФО.ОпзОткрыть;
  ВыводИспОтделов;
  ПЗ.Запись;
  слномвида:=вКон;

  ВыводПонятий(ВД.текОбласть.право);
  ВыводНеоДост;

  ФО.ОпзЗакрыть
КОН Сохранить;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ДобКлючПост(
                      имя-:ЦЕПЬ;
                    value :ЦЕЛ
                  );
ПЕР
  пон:ВД.ДкПонятию;
УКАЗ
  Вставить(имя,пон);
  пон.родп:=пПост;
  пон.вид:=ВД.ключвид;
  пон.пост:=СоздатьПост();
  пон.пост.цел:=value
КОН ДобКлючПост;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ПодготовитьВстрВид(видД+:ВД.ДкВиду;
                          родв :ЦЕЛ);
УКАЗ
         видД:=СоздатьВид(родв);
  видД.размер:=НП.рЯчейка;
  видД.адрОВ:=0;
               видД.номв:=родв
КОН ПодготовитьВстрВид;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ДобВстрВид(         имя-:ЦЕПЬ;
                   родв,размер :ЦЕЛ;
                          видД+:ВД.ДкВиду
                 );
ПЕР
  пон:ВД.ДкПонятию;
УКАЗ
  Вставить(имя,пон);

  видД:=СоздатьВид(родв);
  видД.пон:=пон;
  видД.размер:=размер;
  видД.адрОВ:=0;
  видД.номв:=родв;

  пон.родп:=пВид;
                 пон.вид:=видД;
  пон.признаки:={прОбщедоступная}
КОН ДобВстрВид;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ДобСиноним(имя-:ЦЕПЬ;
                  вид :ВД.ДкВиду
                 );
ПЕР
  пон:ВД.ДкПонятию;
УКАЗ
  Вставить(имя,пон);
  пон.родп:=пВид;
  пон.вид:=вид;
  пон.признаки:={прОбщедоступная}
КОН ДобСиноним;

(*-----------------------------------------локальная ЗАДАЧА-------------------*)
ЗАДАЧА ДобВстрЗадачу(имя-:ЦЕПЬ;
                     num :ЦЕЛ);
ПЕР
  пон:ВД.ДкПонятию;
УКАЗ
  Вставить(имя,пон);
  пон.родп:=пВстрЗадача;
  пон.вид:=ВД.нетвид;
  пон.адр:=num
КОН ДобВстрЗадачу;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       Подготовить-;
УКАЗ
  ЧэргаСлеД.ОчиститьСписок(доступыКнеоВидам);
  чВхОтд:=1
КОН Подготовить;

(*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~общедоступная ЗАДАЧА~~~~~~~~~~~~~~~~~~~~~*)
ЗАДАЧА
       Завершить-;
УКАЗ
  ПОКА        ВД.чВхОтд > 0 ВЫП
    УМЕНЬШИТЬ(ВД.чВхОтд);
    рПонВхОтд[ВД.чВхОтд]:=ПУСТО
  КОН;
  ЧэргаСлеД.ОчиститьСписок(доступыКнеоВидам)
КОН Завершить;


(*-ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss-*)
УКАЗ
  ПодготовитьВстрВид(ВД.неопрвид,вНеопр);
   ВД.неопрвид.овид:=ВД.неопрвид;

  ПодготовитьВстрВид(ВД.нетвид,вНет);        (* вид ответа у задач без ответа *)
  ПодготовитьВстрВид(ВД.пцепьвид,вПЦепь);
  ПодготовитьВстрВид(ВД.пустовид,вПусто);

  ВД.текОбласть:=ПУСТО;
  ОткрытьОбласть(0);
                                                   (* подготовка отдела ОБХОД *)
  ДобВстрВид("Доступ",вДоступ,НП.рДоступ,ВД.одоствид);
  ДобВстрВид("Ячейка",вЯчейка,НП.рЯчейка,ВД.оячвид);
  ДобВстрВид("Ячейки",вОРяд,  0,         ВД.оячкивид);
  ДобВстрВид("Цел8", вЦел8, НП.рЦел8, ВД.цел8вид);
  ДобВстрВид("Цел16",вЦел16,НП.рЦел16,ВД.цел16вид);
  ДобВстрВид("Цел32",вЦел32,НП.рЦел32,ВД.цел32вид);
  ДобВстрВид("Цел64",вЦел64,НП.рЦел64,ВД.цел64вид);
  ДобВстрВид("Вещ32",вВещ32,НП.рВещ32,ВД.вещ32вид);
  ДобВстрВид("Вещ64",вВещ64,НП.рВещ64,ВД.вещ64вид);

  ДобВстрЗадачу("ПолучитьАдрес",зПолучитьАдрес);
  ДобВстрЗадачу("ИзПамяти",     зИзПамяти);
  ДобВстрЗадачу("ВПамять",      зВПамять);
  ДобВстрЗадачу("Значение",     зЗначение);
  ДобВстрЗадачу("Образ",        зОбраз);
  ДобВстрЗадачу("Узк",          зОУзк);

  ДобСиноним("Адрес",цел32вид);

  встрОбласть:=текОбласть.право;
  текОбласть.право:=ПУСТО;

  ДобВстрВид("КЛЮЧ", вКлюч, НП.рКлюч,ВД.ключвид);
  ДобВстрВид("ЗНАК", вЗнак, НП.рЗнак,ВД.знаквид);
  ДобВстрВид("МНОЖ", вМнож, НП.рМнож,ВД.множвид);

  ДобСиноним("ЯЧЦЕЛ", ВД.цел8вид);
  ДобСиноним("УЗКЦЕЛ",ВД.цел16вид);
  ДобСиноним("ЦЕЛ"   ,ВД.цел32вид);
  ДобСиноним("ШИРЦЕЛ",ВД.цел64вид);
  ДобСиноним("ВЕЩ"   ,ВД.вещ32вид);
  ДобСиноним("ШИРВЕЩ",ВД.вещ64вид);

  ДобКлючПост("ОТКЛ",0);
  ДобКлючПост("ВКЛ", 1);
  ДобВстрЗадачу("ВЗНАК",    зВЗнак);
  ДобВстрЗадачу("ВЦЕЛ",     зВЦел);
  ДобВстрЗадачу("ВШИРЦЕЛ",  зВШирЦел);
  ДобВстрЗадачу("ДЛИНА",    зДлина);
  ДобВстрЗадачу("ЗАДАНО",   зЗадано);
  ДобВстрЗадачу("МАКС",     зМакс);
  ДобВстрЗадачу("МОДУЛЬ",   зМодуль);
  ДобВстрЗадачу("МИН",      зМин);
  ДобВстрЗадачу("ОБНУЛИТЬ", зОбнулить);
  ДобВстрЗадачу("ЦЕЛЧАСТЬ", зЦелЧасть);
  ДобВстрЗадачу("ЧЕТ",      зЧет);
  ДобВстрЗадачу("ПОСТАВИТЬ",зПоставить);
  ДобВстрЗадачу("ПРОВЕРИТЬ",зПроверить);
  ДобВстрЗадачу("СМЕСТИТЬ", зСместить);
  ДобВстрЗадачу("РАЗМЕР",   зРазмер);
  ДобВстрЗадачу("СОЗДАТЬ",  зСоздать);
  ДобВстрЗадачу("СПИСАТЬ",  зСписать);
  ДобВстрЗадачу("СТОП",     зСтоп);
  ДобВстрЗадачу("УЗК",      зУзк);
  ДобВстрЗадачу("УВЕЛИЧИТЬ",зУвеличить);
  ДобВстрЗадачу("УМЕНЬШИТЬ",зУменьшить)
КОН ВД.
