— Cobol Copybook Parser

Если вы используете синтаксический анализатор COBOL, предназначенный для этой цели, это относительно просто.

Такой парсер должен уметь разбирать не только целую программу, но для анализа различных подразделов, таких как тетрадь, содержащая абзац или объявление данных. Такой инструмент необходимо подготовить к справиться со сложностями, обнаруженными в реальных тетрадях, такими как объявления полей, строки PIC, REDEFINE, переменные уровня 77 и 88, всевозможные сумасшедшие буквальные значения, используемые в качестве инициализаторов, и беспорядочные / уродливые проблемы с продолжениями строк и ЗАМЕНА КОПИЙ обрабатывать только ванильные тетради.В зависимости от происхождения тетради, возможно, вам придется обрабатывать текст как EBCDIC. На самом деле создание синтаксического анализатора, обрабатывающего все это, требует больших усилий.

Если вы попытаетесь взломать его с помощью регулярных выражений или чего-то еще, что не может делать что-то вроде контекстно-независимого синтаксического анализа, полученный в результате инструмент просто не будет работать в любых сложных случаях.

Хороший синтаксический анализатор создаст абстрактное синтаксическое дерево, фиксирующее все эти детали в виде структуры данных. в памяти для обработки (это эффективно) или в виде XML-файла, который будет обработано каким-то другим инструментом.

Наш синтаксический анализатор COBOL для DMS может обрабатывать все вышеперечисленное и генерировать дамп AST или эквивалент XML.

Учитывая этот фрагмент тетради на COBOL:

  003110 ****************************************
003120 * GEGVD - GEGVD-0872-WS
003130 ***************************************
003140 01 GEGVDC.
003150 ***************************************
003160 ***************************************
003170 10 GEJVD-CDA PIC X (11)
003180 ЗНАЧЕНИЕ
003190 '<<  >>'. 003200 10 GEJVD-COUNT PIC 9 (9)
003210 ЗНАЧЕНИЕ НУЛЕВОЕ
003220 ВЫЧИСЛИТЕЛЬНЫЙ-3.
003230 10 GEJVD-ITER ПИК 9 (3)
003240 ЗНАЧЕНИЕ НУЛЕВОЕ
003250 ВЫЧИСЛИТЕЛЬНЫЙ-3.
003260 10 GEJVD-OP-CODE PIC X (1)
003270 ЗНАЧЕНИЕ.
003280 10 GEJVD-STATUS PIC X (2)
003290 ЗНАЧЕНИЕ.003300 10 GEJVD-OPEN-SW PIC X (1)
003310 ЗНАЧЕНИЕ.
003320 10 GEGVD-STATUS PIC X (2)
003330 ЗНАЧЕНИЕ.
003340 10 ИЗМЕНЕНИЙ КОДА СОСТОЯНИЯ
003350 GEGVD-STATUS PIC X (2).
003360 01 ГЕГВД.
003370 ***************************************
003380 ****************************************
003390 02 ГЕГВД-С.
003400 10 GEGVD-INPT-SCTN.003410 15 GEGVD-ACTL-SERL-LN-CD PIC X (1)
003420 ЗНАЧЕНИЕ.
003430 15 GEGVD-FORM-VER-CD PIC X (5)
003440 ЗНАЧЕНИЕ.
003450 10 GEGVD-OUTP-SCTN.
003460 15 GEGVD-GE-RULE-RSLT-CD PIC X (1)
003470 ЗНАЧЕНИЕ.
003480 10 GEGVD-WORK-SCTN.
003490 15 GEGVD-GE-RSN-00826-ID PIC S9 (5)
003500 ЗНАЧЕНИЕ +00826
003510 ВЫЧИСЛИТЕЛЬНЫЙ-3.003520 15 GEGVD-WS-N-LIT PIC X (1)
003530 ЗНАЧЕНИЕ "N".
003540 15 GEGVD-WS-S-LIT PIC X (1)
003550 ЗНАЧЕНИЕ "S".
003560 15 GEGVD-MPN-FORM-VER-CD PIC X (5)
003570 ЗНАЧЕНИЕ '99 -00 '.
003580 15 GEGVD-PLUS-MPN-FORM-VER-CD PIC X (5)
003590 ЗНАЧЕНИЕ '03-04 '.
  

наш синтаксический анализатор COBOL применяется непосредственно к файлу тетради, создает следующее абстрактное синтаксическое дерево:

  C: \ DMS \ Domains \ COBOL \ IBMEnterprise \ Tools \ Parser \ Source> запустить.1 # 92fa0c0: 3 [Keyword: 0] Строка 49 Колонка 61
   | | ) secondary_description_entry # 92fa0c0
   | | ) secondary_description_entry_list # 92fa180
   | | ) secondary_description_entry_list # 92fa200
   | |) secondary_description_entry_list # 92fa340
   | ) secondary_description_entry_list # 92fa3c0
   | ) secondary_description_entry # 92fa500
   | ) secondary_description_entry_list # 92fa6e0
   |) secondary_description_entry_list # 92fa7a0
   ) secondary_description_entry # 92fa840
  ) record_01_description_entry # 92faac0
 ) record_or_data_item_entry_list # 92fac80
) cobol_source_file # 92facc0

C: \ DMS \ Domains \ COBOL \ IBMEnterprise \ Tools \ Parser \ Source>
  

Когда у вас есть дерево, довольно просто пройти по дереву и извлечь факты об объявлениях символов COBOL.

основных запятых использует

2005, 2002, 1987 Маргарет Л. Беннер Все права защищены.

ЗАПЯТАЯ ПРАВИЛО № 1 ЗАПЯТАЯ В РЯДЕ : Используйте запятые для разделения элементов в серии.

Что такое серия?

Серия — это список из 3 или более элементов, последние два из которых являются присоединились и , или , или или .

_____________ , ______________ , и _____________

ПРИМЕРЫ:

Любое из них может быть заключено в приговор. форма.

Что важно помнить с использованием последовательно запятых:

1. Серия включает 3 или более элементов одного типа (слова или группы слова).

2. Последовательность связана с и , или , или или перед последним элементом.

3. Запятая разделяет элементы в серии, включая последний элемент перед ним. по и , или , или или .

Теперь нажмите на ссылку ниже, чтобы выполнить упражнение. 1.

Ссылка на упражнение 1

ЗАПЯТАЯ ПРАВИЛО № 2 ЗАПЯТАЯ С КООРДИНАТНЫМИ ПРИЛАГАЮЩИМИ : Используйте запятые между координатными прилагательными.

Что такое согласовывать прилагательные?

Координатные прилагательные — это прилагательные, помещенные рядом друг другу равные по важности.

Два следующие тесты для определения согласованности прилагательных:

1. Посмотрите, можно ли и можно ли плавно разместить между ними.

2. Посмотрите, можно ли поменять порядок прилагательных на обратный.

Взгляните на этот пример.

В этом примере запятая находится между счастливый и живой потому что они координируют прилагательные.

Проверка для подтверждения:

Сначала , попробуй и протестируй.

и помещается между 2 прилагательные звучат гладко.

Второй , попробуйте поменять местами прилагательные.

Когда прилагательные меняются местами, предложение по-прежнему имеет смысл.

Таким образом , счастлив и lively — это координатные прилагательные в примере, которые должны быть через запятую.

ВНИМАНИЕ: Не все пары прилагательных координировать прилагательные.Таким образом, не все прилагательные отделяются друг от друга запятой.

Взгляните на этот пример.

В этом примере запятая не принадлежит между двумя прилагательными молодой и золотой потому что они , а не координатных прилагательных.

Как мы можем узнать?

Сначала , попробуй и протестируй.

и помещены между двумя прилагательные не соответствуют .

Второй , попробуйте поменять местами прилагательные.

Когда два прилагательных меняются местами, они имеют смысл , а не .

Таким образом , молодой и золотой являются , а не координатными прилагательными и не должны разделяться запятой.

Теперь нажмите на ссылку ниже, чтобы выполнить упражнение. 2.

Ссылка на упражнение 2

ЗАПЯТАЯ ПРАВИЛО № 3 ЗАПЯТАЯ В А СОСТАВНОЕ ПРЕДЛОЖЕНИЕ : используйте запятую перед и, но, или, ни, для, так, или , но , чтобы соединить два независимые предложения, образующие составное предложение.

Что такое сложное предложение?

Соединение Предложение — это предложение, которое имеет 2 независимых предложения .

независимый пункт — это группа слов с подлежащим и глаголом, которые выражают полный мысль. Он также известен как простое предложение . Независимое предложение может стоять отдельно как предложение.

Два независимых предложения в К составному предложению можно присоединить:

A. Точка с запятой

ИЛИ

г.Запятая и одно из семи соединяющихся слов: для, и, ни, но, или еще, и так . (Взятые вместе первые буквы составляют ФАНБОЙКИ. )

Последний тип сложного предложения тот, на котором мы сконцентрируемся при использовании запятых.

В составном предложении должно быть два независимые предложения, а не просто два глагола, два существительных или две группы слов это , а не независимых статей.

Взгляните на этот пример.

В приведенном выше примере две группы глаголов присоединяются и . Вторая группа глаголов делает НЕ . есть тема; таким образом, это НЕ независимый пункт.

Следовательно, НЕТ запятая стоит перед и .

Этот пример представляет собой простой предложение с соединением глагол , а не сложное предложение.

Однако мы можем преобразовать это предложение в составное предложение, просто превратив последнюю часть глагола в независимую пункт.

Теперь у нас есть добросовестный состав приговор. Два независимых предложения разделяются запятой и словом и .

Вот еще несколько примеров, проиллюстрировать разницу между составными элементами в простых предложениях (нет запятая) и истинные составные предложения (запятая).

Теперь вы готовы попробовать упражнение.

Убедитесь, что вы:

1. Знайте семь присоединяющихся слова ( ф или, а nd, n или, b ut, o r, y et, с или ).

2. Банка различать простые предложения с составными элементами (без запятой) и составные предложения (запятая).

Теперь нажмите на ссылку ниже, чтобы выполнить упражнение. 3.

ССЫЛКА НА УПРАЖНЕНИЕ 3

ЗАПЯТАЯ ПРАВИЛО № 4 ЗАПЯТАЯ С ВВОДНЫЕ СЛОВА : поставьте запятую после вводные фразы, которые говорят , где , когда , почему , или как .

В частности . . . используйте запятую:

1. После длинной вступительной фразы.

Пример:

Обычно нет необходимости использовать запятая после коротких вводных предложных фраз.

Пример:

2. После вступительной фразы, состоящей из до плюс, глагол и любой модификаторы (инфинитив), которые говорят , почему .

Пример:

Используйте запятую даже после короткого to + глагол фраза, которая отвечает почему .

Пример:

Вы можете сказать, что у вас есть такой вводная фраза + глагол, когда вы можете расположить слова по порядку в перед фразой.

Пример:

Будьте осторожны! Не все вводные фразы говорят , почему .

3. После вступительного предложения, которое отвечает

когда? где? Зачем? как? в какой степени?

(Предложение — это группа слов с подлежащее и глагол.)

Примеры:

ПРИМЕЧАНИЕ. Когда такое предложение стоит в конце предложения, НЕ используйте запятую.

Примеры:

Теперь щелкните ссылку ниже, чтобы выполнить упражнение. 4.

Ссылка на упражнение 4

ЗАПЯТАЯ ПРАВИЛО № 5 ЗАПЯТАЯ С НЕЕССЕНЦИАЛЬНЫЕ СЛОВА, ФРАЗЫ И СТАТЬИ: отдельные через запятую любые несущественные слова или группы слов из остальной части приговор.

1. Отдельные слова прерывания, такие как , но , тем не менее , да , нет , конечно , из остального приговор.

Примеры:

2. Отделить переименователь ( аппозитив) от остальной части предложения с запятой.

Пример:

3. Отделяйте прилагательные от основных частей предложения.

(Прилагательное описывает или ограничивает существительное.)

Примеры:

В каждом из приведенных выше случаев Мэри Робертс пробежавшая по улице существенная часть предложения .Прилагательные словосочетания несущественные и должны быть отделены от остальной части предложения запятыми.

4. Отделите несущественные прилагательные от остальной части предложения.

Есть два видов прилагательных:

— тот, который нужен для того, чтобы приговор был полный (ESSENTIAL)

— тот, который НЕ нужен для того, чтобы предложение было полный (НЕОБХОДИМЫЙ)

Модель Essential Прилагательное предложение НЕ должно отделяться от предложения запятыми.

второстепенное Прилагательное предложение (как и другие несущественные элементы) СЛЕДУЕТ разделять запятые.

Два примера иллюстрируют разницу:

А.

г.

Посмотрите на пример A. Если мы удалим прилагательное, ограбившее банк, предложение читает, Мужчина был пойман сегодня.Без прилагательное предложение (кто ограбил банк), мы не знаем , который человек был пойман. Таким образом, прилагательное Предложение необходимо для завершения смысла предложений. Другими словами, это прилагательное существенное . Как отмечается в правилах, , а не , используйте запятые вокруг важных прилагательные.

Теперь посмотрим на пример B. Если мы удалим прилагательное, ограбившее банк, предложение Читает, Сэм Паук был пойман сегодня.Без Прилагательное предложение (кто ограбил банк), мы делаем знать, какой человек был пойман (Сэм Паук). Таким образом, Прилагательное предложение НЕ требуется для завершения смысла предложения. Другими словами, этот пункт несущественный . Следуя правилу, вы должны отделить это прилагательное от остальная часть предложения.

ПОМНИТЕ, есть 4 несущественных элементы, которые следует отделить от остальной части предложения запятыми:

1. такие слова прерывателя, как из конечно , однако

2. переименователи (аппозитивы)

3. несущественные прилагательные

Теперь нажмите на ссылку ниже, чтобы выполнить упражнение. 5.

Ссылка на упражнение 5

Теперь нажмите на ссылку ниже, чтобы выполнить пост-тест.

Ссылка на пост-тест

Урок 24 — Инфинитивы, винительный падеж и инфинитив

Инфинитив — это часть глагола, на которую не влияют лица или числа. В английском языке эту часть глагола легко узнать, так как ей предшествует «to». Например: «позвонить».

Активные инфинитивы

В латинском языке есть три формы инфинитива в активном залоге.

1. Настоящее время активно

В словаре настоящая активная форма инфинитива глагола показана как вторая основная часть, и мы уже встречались с ней несколько раз.

VOCO, VOCARE , VOCAVI, VOCATUM (1) для звонка

Обычно окончание первого глагола спряжения — ‘-are’ , второго глагола спряжения ‘–ere’ , третьего глагола спряжения ‘-ere’ и четвертого глагола спряжения ‘-ire’ .

Например:

2.Perfect active

Чтобы образовать совершенный активный инфинитив глагола, добавьте ‘-sse’ к третьей главной части глагола.

Например:

Подсказка

Если в конце корня стоит ‘-v’ , иногда используется сокращенная форма инфинитива, исключающая ‘-vi’ .

Например:

clamavisse может стать clamasse
servivisse может стать servisse

3. Будущее активно

Чтобы сформировать будущий активный инфинитив глагола, используйте причастие будущего (образованное путем удаления ‘-m’ из супиного и добавления ‘-rus’ ) и прибавления ‘esse’ .

Например:

Запомнить

Причастие будущего действует как прилагательное, согласуясь с подлежащим глагола, и отклоняется как «бонус, -а, -ум» .

Пассивные инфинитивы

В латыни также есть три формы инфинитива в пассивном залоге.

1. Настоящее пассивное

Чтобы образовать существующий пассивный инфинитив глагола первого, второго или четвертого спряжения, удалите окончание «- e » из настоящего инфинитива и добавьте «- i ».

Например:

Чтобы образовать настоящий пассивный инфинитив глагола третьего спряжения, удалите окончание «- ere » из настоящего инфинитива и добавьте «- i ».

Например:

Таким образом:

2.Идеальный пассив

Чтобы образовать идеальный пассивный инфинитив глагола, удалите «- m » от супин, добавьте «- s », чтобы получить причастие прошедшего времени, а затем добавьте « esse ».

Например:

3.

Чтобы сформировать будущий пассивный инфинитив глагола, удалите «- m » из супин и добавьте «- s », чтобы получить причастие прошедшего времени, а затем добавьте « перед ».

Подсказка

Если вы уже изучали классическую латынь раньше, вы заметите, что вместо supine + « iri » в средневековой латыни используется причастие прошедшего времени + « fore » для образования будущего пассивного инфинитива.

Например:

Запомнить

Причастие прошедшего времени действует как прилагательное, согласуясь с подлежащим глагола, и отклоняется как «бонус, -а, -ум» .

Инфинитивы депонента

Инфинитивы депонентных глаголов подчиняются правилам пассивных инфинитивов, как показано выше.

Прилагательная часть винительного и инфинитивного падежа

В средневековых документах, с которыми вы сталкиваетесь, вы часто можете встретить инфинитив в сочетании с винительным падежом. Это называется винительным и инфинитивным придаточным падежом или косвенным утверждением и переводится определенным образом.

Например:
Credo Johannem dedisse Matheo terram.
Я считаю, что Иоанн отдал землю Мэтью. (Буквально — я верю, что Иоанн отдал Матфею землю.)

Подсказка

Вы часто сможете заметить винительный и инфинитивный придаточный падеж, происходящий от типа глагола, который ему предшествует.

Например:

Контрольный список

Вы уверены в

• значение активного инфинитива?
• форма активного инфинитива?
• значение пассивного инфинитива?
• форма пассивного инфинитива?
• значение винительного и инфинитивного придаточного падежа?
• форма винительного и инфинитивного придаточного падежа?

Что дальше?

10.2.2. Модуль загрузчика COBOL — Анализ исходного кода COBOL для загрузки схемы — Читатель файлов на основе схемы Stingray

Анализ схемы электронной таблицы относительно прост: см. Модуль загрузчика схемы — Загрузка встроенной или внешней схемы. Однако анализ схемы COBOL немного сложнее. Нам нужно разобрать Исходный код COBOL для декодирования элементов определения данных (DDE) и создания удобное представление DDE, соответствующее модели схемы Stingray.

Мы закончим с двумя представлениями схемы COBOL:

Новая схема .loader.ExternalSchemaLoader подкласс требуется для анализа подъязыка DDE в COBOL. Раздел COBOL Schema Loader Class подробности об этом. Загрузчик построит иерархическую DDE из источника COBOL, украсьте его информацией о размере и смещении, затем сведите его к простой схеме . Schema instance.

10.2.2.1. Загрузить схему сценария использования

Цель варианта использования — загрузить схему, закодированную в COBOL. Это ломается на два шага.

1. Разобрать исходный файл COBOL «тетрадь».
2. Создание экземпляра схемы .Schema , который можно использовать для доступа к данным. в файле COBOL.

В идеале это будет выглядеть примерно так.

 с открытым ("sample / zipcty.cob", "r") как cobol:
    schema = stingray.cobol.loader.COBOLSchemaLoader (cobol) .load ()
    # pprint.pprint (схема)
для имени файла в 'sample / zipcty1', 'sample / zipcty2':
    с stingray.cobol.Character_File (filename, schema = schema) как wb:
        лист = wb.sheet (имя файла)
        counts = process_sheet (лист)
        pprint.pprint (считает)
 

Шаг 1 — открыть файл «тетрадь» COBOL DDE, zipcty.cob , который определяет макет. Мы строим схему, используя cobol.loader.COBOLSchemaLoader .

Шаг 2 — открыть исходные данные, zipcty1 с данными. Мы сделали лист. Лист из файла: имя листа "zipcty1" , Схема является внешней, предоставленной, когда мы открыли cobol.Character_File .

Как только лист станет доступен, мы можем запустить некоторую функцию process_sheet на простынь.Это будет использовать API листа . Sheet для обработки строк и ячеек простынь. Каждый фрагмент исходных данных загружается как своего рода ячейка Cell .

Затем мы можем использовать соответствующие преобразования для восстановления объектов Python. Это подводит нас ко второму варианту использования.

Вот как в этом контексте может выглядеть функция process_sheet () .

 def process_sheet (лист):
    schema_dict = dict ((a.name, a) для a в sheet.schema)
    schema_dict.update (dict ((a.путь, а) для а в лист.схеме))

    counts = {'read': 0}

    row_iter = sheet. rows ()
    header = header_builder (следующий (row_iter), schema_dict)
    печать (заголовок)
    для строки в row_iter:
        detail = row_builder (строка, schema_dict)
        печать (деталь)
        подсчитывает ['прочитано'] + = 1
    количество возвратов
 

Во-первых, мы создали две версии схемы, индексированные по имени элемента нижнего уровня. и полный путь к элементу. В некоторых случаях элементы DDE низкого уровня уникальны, и пути не требуются.В остальных случаях пути обязательны.

Мы инициализировали несколько счетчиков записей, что всегда является хорошей практикой.

Мы получили первую запись и использовали некоторую функцию с именем header_builder () для преобразовываем запись в заголовок, который печатаем.

Мы извлекли все остальные записи и использовали функцию с именем row_builder () , чтобы трансформируем каждую следующую запись в детали, которые мы также печатаем.

Это показывает физическую обработку "голова-хвост".В некоторых случаях есть атрибут который различает заголовки, кузов и трейлеры.

10.2.2.2. Пример использования схемы

Целью этого варианта использования является создание пригодных для использования объектов Python из данных исходного файла.

Для каждой строки выполняется двухэтапная операция.

1. Доступ к элементам каждой строки с помощью структуры COBOL DDE.
2. Создайте объекты Python из ячеек, найденных в строке.

Как правило, мы должны использовать ленивое вычисление, как показано в этом примере:

 def header_builder (строка, схема):
    return dict (
        file_version_year = строка.ячейка (схема ['ФАЙЛ-ВЕРСИЯ-ГОД']). to_str (),
        file_version_month = row.cell (схема ['FILE-VERSION-MONTH']). to_str (),
        copyright_symbol = row.cell (схема ['COPYRIGHT-SYMBOL']). to_str (),
        tape_sequence_no = row.cell (схема ['TAPE-SEQUENCE-NO']). to_str (),
    )

def row_builder (строка, схема):
    return dict (
        zip_code = row. cell (схема ['ПОЧТОВЫЙ ИНДЕКС']). to_str (),
        update_key_no = row.cell (схема ['UPDATE-KEY-NO']). to_str (),
        low_sector = row.cell (schema ['COUNTY-CROSS-REFERENCE-RECORD.ZIP-ADD-ON-RANGE.ZIP-ADD-ON-LOW-NO.ZIP-SECTOR-NO ']). To_str (),
        low_segment = row.cell (схема ['COUNTY-CROSS-REFERENCE-RECORD.ZIP-ADD-ON-RANGE.ZIP-ADD-ON-LOW-NO.ZIP-SEGMENT-NO']). to_str (),
        high_sector = row.cell (схема ['COUNTY-CROSS-REFERENCE-RECORD.ZIP-ADD-ON-RANGE.ZIP-ADD-ON-HIGH-NO.ZIP-SECTOR-NO']). to_str (),
        high_segment = row.cell (схема ['COUNTY-CROSS-REFERENCE-RECORD.ZIP-ADD-ON-RANGE.ZIP-ADD-ON-HIGH-NO.ZIP-SEGMENT-NO']). to_str (),
        state_abbrev = row.cell (схема ['STATE-ABBREV']).to_str (),
        county_no = row.cell (схема ['COUNTY-NO']). to_str (),
        county_name = row.cell (схема ['COUNTY-NAME']). to_str (),
    )
 

Доступ к каждой ячейке осуществляется в три этапа.

1. Получить информацию о схеме через схему ['краткое имя'] Схема или ['полный.путь.name']
2. Создайте Cell , используя информацию о схеме через row.cell (...) .
3. Преобразуйте Cell в наш целевой тип через ...to_str () .

Мы, , должны делать это поэтапно, потому что записи COBOL могут иметь недопустимые поля, или ПОВТОРЯЕТ или ПРОИСХОДИТ В ЗАВИСИМОСТИ от статей .

Если мы хотим создавать чистые объекты Python более высокого уровня, связанные с некоторыми приложение, мы сделаем это.

def build_object (строка, схема):
    вернуть объект (** row_builder (строка, схема))
 

Мы просто гарантируем, что ключи словаря строки являются правильными аргументами ключевого слова для определения классов нашего приложения.

Когда нам нужно выполнить индексацию, это лишь немного сложнее. Результирующий объект будет структурой списка, и мы применяем индексы в порядке от оригинала Определение DDE для разделения списков.

10.2.2.3. Расширения и особые случаи

Типичные варианты использования выглядят примерно так:

 с открытым ("sample / zipcty.cob", "r") как cobol:
    schema = stingray.cobol.loader.COBOLSchemaLoader (cobol) .load ()
со stingray.cobol.Character_File (имя файла, схема = схема) как wb:
    лист = wb.sheet (имя файла)
    для строки в sheet.rows ():
        дамп (схема, строка)
 

Это будет использовать синтаксический анализ по умолчанию для создания схемы из DDA и обработки файл, сбрасывая каждую запись.

Есть два распространенных расширения:

• новый лексический сканер и
• различных ОДО по обработке.

Чтобы изменить лексические сканеры, мы создаем новый подкласс парсера.

Мы используем это, создав подкласс коболов.COBOLSchemaLoader .

 класс MySchemaLoader (cobol.COBOLSchemaLoader):
    lexer_class = cobol.loader.Lexer_Long_Lines
 

При синтаксическом анализе файла DDE будет использоваться другой лексический сканер.

Нам также может потребоваться изменить фабрику звукозаписи. Это включает в себя два отдельных расширения. Мы должны расширить cobol.loader.RecordFactory , чтобы изменить функции. Затем мы можем расширить cobol.loader.COBOLSchemaLoader , чтобы использовать эту запись фабрика.

 класс ExtendedRecordFactory (cobol.loader.RecordFactory):
    происходит_dependingon_class = stingray.cobol.defs.OccursDependingOnLimit
    # По умолчанию is_dependingon_class = stingray.cobol.defs.OccursDependingOn

класс MySchemaLoader (cobol.loader.COBOLSchemaLoader):
    record_factory_class = ExtendedRecordFactory
 

Это будет использовать другую фабрику записей для детализации DDE.

10.2.2.4. Конструкция загрузчика DDE

DDE содержит рекурсивное определение DDE на уровне группы COBOL. Существует два основных вида COBOL DDE: элементарные элементы, которые имеют пункт PICTURE , и элементы уровня группы, которые содержат элементы более низкого уровня. Есть несколько дополнительных особенности каждого DDE, включая предложение OCCURS и предложение REDEFINES . В дополнение к обязательному предложению изображения элементарные элементы имеют необязательное предложение USAGE , и необязательный пункт SIGN .

Единый класс cobol.defs.DDE определяет свойства элемента уровня группы. Он поддерживает происходит и переопределяет функции. Он может содержать несколько элементов DDE. Листья дерева определяют свойства элементарного предмета.

Подробнее см. Модуль определений COBOL - Обработка DDE в COBOL.

Предложение PICTURE определяет, как интерпретировать последовательность байтов. Изображение предложение взаимодействует с дополнительным предложением USAGE , предложением SIGN и предложением SYNCHRONIZED чтобы полностью определить кодировку. В предложении изображения используется сложный формат кодовых символов. для определения либо отдельных байтов символа (когда используется отображение), либо пар байтов десятичных цифр (при использовании КОМП-3 ).

Предложение OCCURS определяет массив элементов. Если появляется условие на элементе уровня группы подзапись повторяется. Если появляется условие на элементарном элементе этот элемент повторяется.

Ошибка происходит в зависимости от (ODO), поэтому позиции каждого поля зависят от фактического данные, присутствующие в записи. Это редкое, но необходимое осложнение.

Предложение REDEFINES определяет псевдоним для входных байтов.Когда какое-то поле R переопределяет ранее определенное поле F , байты памяти используются как для R , так и для F . Сама структура записи не позволяет однозначно интерпретировать байты. Логика программы должна быть исследована, чтобы определить условия, при которых допустима каждая интерпретация. Вполне возможно, что в любой интерпретации есть недопустимые поля.

10.2.2.4.1. Постобработка DDE

У нас есть несколько функций для обхода структуры DDE для записи отчеты по структуре.В DDE есть метод __iter __ () , который обеспечивает полный предварительный просмотр записи в глубину состав.

Вот несколько функций, которые проходят через всю структуру DDE.

Когда данные доступны, у нас есть эти дополнительные функции.

Обратите внимание, что cobol.defs.setSizeAndOffset () является рекурсивным, а не итеративным. Ему необходимо управлять промежуточными итогами на основе подъема и спуска в иерархии.

10.2.2.4.2. Парсер DDE

A кобол.loader.RecordFactory объект читает файл текста и либо создает DDE или вызывает исключение. Если текст является допустимой записью COBOL определение, создается DDE. Если есть синтаксические ошибки, исключение Поднялся.

Загрузчик cobol.loader .RecordFactory зависит от загрузчика cobol.loader .Lexer экземпляр для лексического сканирования Источник COBOL. Лексический сканер можно разделить на подклассы для предварительной обработки COBOL. источник. Это необходимо из-за разнообразия исходных форматов, которые разрешены.Стандарты магазина могут включать или исключать такие функции, как идентификация программы, номера строк, управление форматом и др. украшение входа.

Метод cobol.loader.RecordFactory.makeRecord () анализирует ли определение записи. Анализируется каждый отдельный оператор DDE. В информация о номере уровня используется для определения правильной группировки элементы. Когда структура (-ы) разбирается, она украшается размером и информация о смещении для каждого элемента.

Обратите внимание, что в одной тетради COBOL возможно несколько уровней 01.Это сбивает с толку и потенциально сложно, но это происходит в реале.

10.2.2.4.3. Значения полей

Язык COBOL и расширения IBM, предусматривают ряд вариантов использования. В этом приложении три основных типа поддерживаемых стратегий использования:

• ДИСПЛЕЙ . Это байты, по одному на символ, описанные в предложении picture. Они могут быть в формате EBCDIC или ASCII. Мы используем модуль кодеков для конвертировать символы EBCDIC в Unicode для дальнейшей обработки.
• КОМП . Это двоичные поля размером 2, 4 или 8 байтов, размер которых определяется условием изображения.
• КОМП-3 . Это упакованные десятичные поля, размер которых определяется предложением изображения; в каждом байте упакованы две цифры с дополнительным полубайтом для знака.

Для этого требуются разные стратегии декодирования входных байтов.

Дополнительные типы включают COMP-1 и COMP-2, которые являются числами с плавающей запятой одинарной и двойной точности.Они настолько редки, что мы их игнорируем.

10.2.2.4.4. Возникает в зависимости от

Поддержка «Происходит в зависимости от» основана на нескольких функциях COBOL.

Синтаксис ODO более сложный: OCCURS [int TO] int [TIMES] DEPENDING [ON] name . Сравните это с простым OCCURS int [TIMES] .

Это приводит к переменным позициям байтов для элементов данных, которые следуют за предложением происходит, на основе имени , значения .

Это означает, что смещение не обязательно фиксируется при наличии сложного ODO.Нам нужно сделать смещение (и размер) свойством, имеющим одну из двух стратегий.

• Статически расположен. Базовый случай, когда смещения статичны.
• Различное расположение. Сложная ситуация с ODO, когда есть запись ODO. Все поля ODO «зависит от» становятся частью вычисления смещения. Это означает нам нужен индекс для пунктов зависит от.

Техническая модная фраза - это «элемент данных, следующий за таблицей переменной длины в той же записи уровня 01, но не подчиненный ей. ”

См. Http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/index.jsp?topic=%2Fcom.ibm.aix.cbl.doc%2Ftptbl27.htm

Это правила «Приложения D, Комплексный ODO».

Следствия проектирования таковы.

1. Существует три вида отношений между элементами DDE: Предшественник / Преемник, Родитель / Дочерний (или Группа / Элементарный), и переопределяет. В настоящее время отношение прогнозирования / успешности подразумевается родителем, имеющим последовательность потомков. Мы не можем легко найти предшественника без ужасных поисков.

2. Есть две стратегии для выполнения вычислений смещения / размера.

   • Статически. Можно использовать функцию cobol.defs.setSizeAndOffset () один раз, сразу после анализа схемы.

   • Различно расположен. Расчет размера и смещения основан на реальных данных. Функция cobol.defs.setSizeAndOffset () должна использоваться после строка выбирается, но до любой другой обработки.

     Это делается автоматически с помощью листа .Объект LazyRow .

Расчет смещения можно рассматривать как рекурсивный переход «вверх» по дереву. следующие переопределения, отношения предшественников и родителей (в указанном порядке) чтобы рассчитать размер всего, что предшествует рассматриваемому элементу. Мы могли бы сделать смещение и общий размер в свойствах, которые делают это рекурсивным расчет.

«Размер» элементарных предметов по-прежнему просто основан на картинке. Однако для групповых элементов размер зависит от общего размера, который в в свою очередь, может быть основана на данных ODO.[COBOLSchemaLoader], [COBOLSchemaLoader] -> [Lexer], [COBOLSchemaLoader] -> [RecordFactory], [RecordFactory] <> - [DDE].

10.2.2.5. Накладные расходы

В конечном итоге мы пишем новый schema.loader.ExternalSchemaLoader . Целью этого является создание экземпляра схемы . из источника COBOL, а не из другого источника.

 "" "stingray.cobol.loader - проанализируйте COBOL DDE и создайте удобную схему." ""
импорт ре
из коллекции import namedtuple, Iterator
импорт журнала
импорт weakref
предупреждения об импорте
import sys

импортный скат.schema.loader
импорт stingray.cobol
импортировать stingray.cobol.defs
 

Мы добавим номер версии, просто для поддержки некоторой отладки.

Регистратор на уровне модуля.

 logger = logging.getLogger (__name__)
 

10.2.2.6. Разбор исключений

класс кобол. Погрузчик. SyntaxError

Это проблемы компиляции. У нас есть синтаксис, который совершенно сбивает с толку.

 класс SyntaxError (Исключение):
    "" "Синтаксическая ошибка COBOL."" "
    проходить
 

10.2.2.7. Разбор раздела изображений

Анализ предложения Picture выполняется при создании элемента DDE. Не для великого причина. Это производные данные из условия исходного изображения.

Это тоже можно сделать в парсере.

Поскольку 9 (5) V99 является обычным явлением, точность легко определяется символами после "." или «V». Однако может быть несколько () ’d групп чисел 9 (5) V9 (3) чего-то вроде. Таким образом, точность в последнем случае равна 3, что немного усложняет задачу.

Кроме того, мы не очень изящно обращаемся с отдельными вывесками. Это кажется малоиспользуемым, так что нам комфортно игнорировать это.

класс кобол. Погрузчик. Изображение

Определите различные атрибуты предложения COBOL PICTURE.

финал

финальное изображение

альфа

логический; Истинно, если любой "X" или "A" ; Неверно, если все "9" и связанные с ним

длина

длина финального снимка

масштаб

количество "P" позиций, часто ноль

точность

цифр справа от десятичной точки

с подписью

логический; Верно, если любой "S" , "-" или родственный

десятичное

". " или " V " или Нет

 Picture = namedtuple ('Изображение',
    'final, alpha, length, scale, precision, signed, decimal')
 

кобол. Загрузчик. picture_parser ( рис )

Разобрать текст определения ИЗОБРАЖЕНИЯ.

 def picture_parser (рис.):
    "" "Перепишите предложение изображения, чтобы исключить (), S, V, P и т. Д.
    : param pic: Сообщать текст.: returns: Экземпляр изображения: final, alpha, len (final), scale,
        точность, знаковая, десятичная
    "" "
    out = []
    масштаб, точность, знак, десятичный = 0, 0, ложь, нет
    char_iter = iter (рис.)
    для c в char_iter:
        если c in ('A', 'B', 'X', 'Z', '9', '0', '/', ',', '+', '-', '*', '$ '):
            out.append (c)
            если десятичный: точность + = 1
        elif c == 'D':
            nc = следующий (char_iter)
            assert nc == "B", "ошибка изображения в {0! r}". формате (рис.)
            out.append ("БД")
            signed = True
        elif c == 'C':
            nc = следующий (char_iter)
            assert nc == "R", "ошибка изображения в {0! r}".формат (рис.)
            out.append ("CR")
            signed = True
        elif c == '(':
            irpt = 0
            пытаться:
                для c в char_iter:
                    если c == ')': перерыв
                    irpt = 10 * irpt + int (c)
            кроме ValueError как e:
                поднять SyntaxError ("ошибка изображения в {0! r}". формате (рис.))
            assert c == ')', "ошибка изображения в {0! r}". формате (рис.)
            out.append ((irpt-1) * out [-1])
            если десятичный: точность + = irpt-1
        elif c == 'S':
            # молча опустите букву "S".# Обратите внимание, что "S" плюс опция SIGN SEPARATE увеличивает размер изображения!
            signed = True
        elif c == 'P':
            # "P" задает масштаб и не отображается. 
            масштаб + = 1
        elif c == "V":
            # "V" задает точность и не отображается.
            десятичный = "V"
        elif c == ".":
            decimal = "."
            out.append (".")
        еще:
            поднять SyntaxError ("Ошибка изображения в {! r}". формате (рис.))

    final = "" .join (выход)
    альфа = ('A' в финале) или ('X' в финале) или ('/' в финале)
    регистратор.отладка ("PIC {0} {1} alpha = {2} scale = {3} prec = {4}". format (pic, final, alpha, scale, precision))
    # Примечание: Фактическое потребление байтов зависит от len (final) и использования!
    return Picture (final, alpha, len (final), scale,
        точность, знаковая, десятичная)
 

10.2.2.8. Лексическое сканирование

Лексический сканер можно разделить на подклассы, чтобы расширить его возможности. По умолчанию лексический сканер предоставляет метод Lexer.clean () , который просто удаляет комментарии. Это может потребоваться переопределить, чтобы удалить номера строк (с позиций 72-80), идентификация модуля (с позиций 1-5) и директивы управления форматом.

Также нам приходится иметь дело с «инструкциями по управлению компилятором»: EJECT, SKIP1, SKIP2 и SKIP3. Это просто шум, который может появиться в источнике.

класс кобол. Погрузчик. Lexer

Базовый лексер, который просто удаляет комментарии и первые шесть позиций каждой строки.

 класс Лексер:
    "" "Лексический сканер COBOL. Перебирает токены в исходном тексте." ""
    separator = re.compile (r '[.,;]? \ s')
    quote1 = re."] *" ')
    def __init __ (self, замена = None):
        self.log = logging.getLogger (self .__ class __.__ qualname__)
        self.replacing = замена или []
 

Lexer. чистый ( строка )

Процесс очистки строки по умолчанию. Просто запишите конечные пробелы.

 def clean (self, line):
    "" "Очиститель по умолчанию удаляет позиции 0: 6. " ""
    строка возврата [6:]. rstrip ()
 

Lexer. сканирование ( текст )

Найдите последовательность токенов во входном потоке.

 сканирование по умолчанию (собственное, текст):
    "" "Найдите следующий токен во входном потоке.
    - Чистые 6-символьные вводные и конечные пробелы
    - Добавьте один дополнительный пробел, чтобы отличить конец строки `` ''. '' '
      из пункта изображения.
    "" "
    если isinstance (текст, (str, bytes)):
        текст = текст.splitlines ()
    self.all_lines = (self.clean (строка) + ''
        для строки в тексте)
    # Удалить комментарии, пустые строки и директивы компилятора
    себя.lines = (строка
        для строки в self.all_lines
            если строка и строка [0] не входят в ('*', '/')
            и line.strip () не входит в ("EJECT", "SKIP1", "SKIP2", "SKIP3"))
    # Разбить оставшиеся строки на слова
    для строки в self.lines:
        если len (строка) == 0: продолжить
        logger.debug (строка)
        # Применить все правила замены.
        на старые, новые в самостоятельной замене:
            line = line.replace (старый, новый)
        если self.replacing: logger.debug ("Пост-замена {! r}". формат (строка))
        текущая = строка.lstrip ()
        пока текущий:
            если текущий [0] == "'":
                # строка апострофа, разрыв при балансировке апострофа
                match = self.quote1.match (текущий)
                пробел = match.end ()
            elif current [0] == '"':
                # строка цитаты, разрыв при балансировке цитаты
                match = self.quote2.match (текущий)
                пробел = match.end ()
            еще:
                match = self.separator.search (текущий)
                пробел = совпадение.Начало()
                если пробел == 0: # начинается с разделителя
                    пробел = match.end () - 1
            токен, текущий = текущий [: пробел], текущий [пробел:].  lstrip ()
            self.log.debug (токен)
            жетон доходности
 

класс кобол. Погрузчик. Lexer_Long_Lines

Более сложный лексер, удаляющий первые шесть позиций каждой строки. Если строка превышает 72 позиции, она также удаляет позиции [71:80].Поскольку это расширение для cobol.loader.Lexer , оно также удаляет комментарии.

 класс Lexer_Long_Lines (Lexer):

    def clean (self, line):
        "" "Убрать позиции 72:80 и 0: 6." ""
        если len (строка)> 72:
            строка возврата [6:72] .strip ()
        строка возврата [6:]. rstrip ()
 

Мы используем это, создав подкласс cobol.COBOLSchemaLoader .

 класс MySchemaLoader (cobol.COBOLSchemaLoader):
    lexer_class = cobol.Lexer_Long_Lines
 

10.2.2.9. Разбор

Класс cobol.loader.RecordFactory - это синтаксический анализатор для определений записей. У парсера есть три основных набора методов:

1. методы анализа статьи,
2. методов разбора элементов и
3. полный разбор макета записи.

класс кобол. Погрузчик. RecordFactory

Разобрать макет записи. Это означает анализ последовательности DDE и собирая их в надлежащую структуру.Каждый элемент состоит из последовательности отдельные статьи.

 класс RecordFactory:
    "" "Разобрать тетрадь, создав структуру DDE." ""
    noisewords = {"КОГДА", "ЕСТЬ", "ВРЕМЯ"}
    ключевые слова = {"ПУСТО", "НОЛЬ", "НУЛИ", "НУЛИ", "ПРОБЕЛЫ",
        «ДАТА», «ФОРМАТ», «ВНЕШНИЙ», «ГЛОБАЛЬНЫЙ»,
        «ПРОСТО», «ОБОСНОВАНО», «СЛЕВА», «ПРАВО»
        «ПРОИСХОДИТ», «В ЗАВИСИМОСТИ», «НА», «ВРЕМЯ»,
        «КАРТИНКА», «КАРТИНКА»,
        "ПОВТОРЯЕТ", "ПЕРЕИМЕНОВАЕТ",
        «ЗНАК», «ВЕДУЩИЙ», «СЛЕДУЮЩИЙ», «ОТДЕЛЬНЫЙ», «ХАРАКТЕР»,
        «СИНХРОНИЗАЦИЯ», «СИНХРОНИЗИРОВАННАЯ»,
        «ИСПОЛЬЗОВАНИЕ», «ДИСПЛЕЙ», «КОМП-3»,
        "ЗНАЧЕНИЕ",". "}

    redefines_class = stingray.cobol.defs.Redefines
    successor_class = stingray.cobol.defs.Successor
    group_class = stingray.cobol.defs.Group
    display_class = stingray.cobol.defs.UsageDisplay
    comp_class = stingray.cobol.defs.UsageComp
    comp3_class = stingray.cobol.defs.UsageComp3
    происходит_класс = stingray.cobol.defs.Occurs
    происходит_fixed_class = stingray.cobol.defs.OccursFixed
    происходит_dependingon_class = stingray.cobol.defs.OccursDependingOn

    def __init __ (сам):
        себя.lex = Нет
        self.token = Нет
        self.context = []
        self.log = logging.getLogger (self .__ class __.__ qualname__)
 

Каждая из этих функций синтаксического анализа имеет предварительное условие последнего проверенного токена. в self.token . У них есть пост-условие - оставить , а не -проверено. токен в self.token .

 def (собственное):
    "" "Разобрать предложение PICTURE." ""
    self.token = следующий (self.lex)
    если self.token == "IS":
        self.token = next (self.lex)
    pic = self.token
    self.token = следующий (self.lex)
    вернуть картинку
 

 def blankWhenZero (self):
    "" "Изящно пропустите предложение BLANK WHEN ZERO." ""
    self.token = следующий (self.lex)
    если self.token == "КОГДА":
        self.token = следующий (self.lex)
    если self.token в {"ZERO", "ZEROES", "ZEROS"}:
        self.token = следующий (self.lex)
 

 def оправдано (самостоятельно):
    "" "Изящно пропустите ОБОСНОВАННОЕ предложение." ""
    self.token = следующий (self.lex)
    если self.token == "ПРАВИЛЬНО":
        себя.токен = следующий (self.lex)
 

 def происходит (сам):
    "" "Разобрать предложение OCCURS." ""
    происходит = следующий (self.lex)
    если происходит == "TO":
        # формат 2: происходит в зависимости от предполагаемого значения 1 для нижнего предела
        вернуть self.occurs2 ('')
    self.token = следующий (self. lex)
    если self.token == "TO":
        # формат 2: происходит в зависимости от
        return self.occurs2 (происходит)
    еще:
        # формат 1: фиксированная длина
        если self.token == "ВРЕМЯ":
            self.token = следующий (self.lex)
        себя.происходит_cruft ()
        return self.occurs_fixed_class (происходит)

def происходит_cruft (self):
    "" "Впитайте дополнительные ключевые и индексные подпункты." ""
    если self.token в {"ASCENDING", "DESCENDING"}:
        self.token = следующий (self.lex)
    если self.token == "КЛЮЧ":
        self.token = следующий (self.lex)
    если self.token == "IS":
        self.token = следующий (self.lex)
    # получить имена ключевых данных
    в то время как self.token не входит в self.keywords:
        self.token = следующий (self.lex)
    если self.token == "INDEXED":
        себя.токен = следующий (self.lex)
    если self.token == "BY":
        self.token = следующий (self.lex)
    # получить имена проиндексированных данных
    в то время как self.token не входит в self.keywords:
        self.token = следующий (self.lex)

def происходит2 (self, нижний):
    "" "Анализировать [встречается n TO] m раз в зависимости от имени" ""
    self.token = следующий (self.lex)
    upper = self.token # Может иметь значение как размер по умолчанию.
    default_size = int (верхний)
    self.token = следующий (self.lex)
    если self.token == "ВРЕМЯ":
        self.token = следующий (self.lex)
    если сам.токен == "ЗАВИСИТ":
        self.token = следующий (self.lex)
    если self.token == "ON":
        self.token = следующий (self.lex)
    name = self.token
    self.token = следующий (self.lex)
    self.occurs_cruft ()

    вернуть self.occurs_dependingon_class (имя, размер по умолчанию)
    #raise stingray.cobol.defs.UnsupportedError ("Возникает в зависимости от")
 

 def переопределяет (себя):
    "" "Разобрать предложение REDEFINES." ""
    redef = следующий (self.lex)
    self.token = следующий (self.lex)
    вернуть self. redefines_class (name = redef)
 

 def переименовывает (самостоятельно):
    "" "Вызвать исключение для предложения RENAMES." ""
    ren1 = следующий (self.lex)
    self.token = следующий (self.lex)
    если self.token в {"THRU", "THROUGH"}:
        ren2 = следующий (self.lext)
        self.token = следующий (self.lex)
    warnings.warn ("Предложение RENAMES найдено и проигнорировано.")
    # Альтернативные ПЕРЕИМЕНОВАНИЯ
    # поднять stingray.cobol.defs.UnsupportedError ("Пункт переименования")
 

 def sign1 (self):
    "" "Вызвать исключение для предложения SIGN." ""
    self.token = следующий (self.lex)
    если self.token == "IS":
        self.token = следующий (self.lex)
    если self.token в {"LEADING", "TRAILING"}:
        self.sign2 ()
    # TODO: это может изменить размер, чтобы добавить байт знака
    поднять stingray.cobol.defs.UnsupportedError ("Предложение подписи")
def sign2 (self):
    "" "Вызвать исключение для предложения SIGN." ""
    self.token = следующий (self.lex)
    если self.token == "ОТДЕЛЬНО":
        себя.токен = следующий (self.lex)
    если self.token == "ХАРАКТЕР":
        self.token = следующий (self.lex)
    поднять stingray.cobol.defs.UnsupportedError ("Предложение подписи")
 

 def синхронизировано (самостоятельно):
    "" "Вызвать исключение в предложении SYNCHRONIZED." ""
    self.token = следующий (self.lex)
    если self.token == "LEFT":
        self.token = следующий (self.lex)
    если self.token == "ПРАВИЛЬНО":
        self.token = следующий (self.lex)
    поднять stingray.cobol.defs.UnsupportedError ("Синхронизированное предложение")
 

 def (самостоятельно):
    "" "Разобрать предложение USAGE. " ""
    self.token = следующий (self.lex)
    если self.token == "IS":
        self.token = следующий (self.lex)
    использовать = self.token
    self.token = следующий (self.lex)
    вернуть self.usage2 (использовать)
def usage2 (self, use):
    "" "Создайте правильный экземпляр Usage на основе предложения USAGE." ""
    если используется == "DISPLAY": вернуть self.display_class (использовать)
    elif use == "ВЫЧИСЛИТЕЛЬНЫЙ": вернуть self.comp_class (использовать)
    elif use == "COMP": вернуть self.comp_class (использовать)
    elif use == "COMPUTATIONAL-3": вернуть self.comp3_class (использовать)
    elif use == "COMP-3": вернуть self.comp3_class (использовать)
    else: поднять SyntaxError ("Неизвестное условие использования {! r}". формат (использование))
 

 значение по умолчанию (собственное):
    "" "Разобрать предложение VALUE." ""
    если self.token == "IS":
        self.token = следующий (self.lex)
    lit = [следующий (self.lex),]
    себя.токен = следующий (self.lex)
    в то время как self.token не входит в self.keywords:
        lit.append (собственный токен)
        self.token = следующий (self.lex)
    возвращение горит
 

 def dde_iter (self, lexer):
    "" "Создайте единый DDE из записи предложений." ""
    self.lex = лексический анализатор

    для self. token в self.lex:
        # Начните с уровня.
        level = self.token

        # Выберите имя, если оно есть
        self.token = следующий (self.lex)
        если self.token в self.keywords:
            name = "НАПОЛНИТЕЛЬ"
        еще:
            name = self.token
            self.token = следующий (self.lex)

        # По умолчанию
        usage = self.display_class ("")
        pic = Нет
        происходит = self.occurs_class ()
        redefines = None # установите значение Redefines ниже или с помощью addChild () выберите Group или Successor

        # Накапливайте соответствующие предложения, отбрасывая шумные слова и не относящиеся к делу предложения.
        в то время как self.token и self.token! = '.':
            если self.token == "BLANK":
                self.blankWhenZero ()
            elif self.token в {"ВНЕШНИЙ", "ГЛОБАЛЬНЫЙ"}:
                self.token = следующий (self.lex)
            elif self.token in {"JUST", "JUSTIFIED"}:
                себя.оправдано ()
            elif self.token == "ПРОИСХОДИТ":
                происходит = self.occurs ()
            elif self.token в {"PIC", "PICTURE"}:
                pic = self.picture ()
            elif self.token == "ПОВТОРЯЕТ":
                # Должен быть первым и никакие другие предложения не допускаются.
                # Особый случай: проще, если уровень 01 игнорирует это предложение.
                clause = self.redefines ()
                если level == '01':
                    self.log.info («Игнорирование ПОВТОРЕНИЙ верхнего уровня»)
                еще:
                    redefines = clause
            elif self.token == "ПЕРЕИМЕНОВАТЬ":
                self.renames ()
            elif self.token == "ЗНАК":
                self.sign1 ()
            elif self.token in {"LEADING", "TRAILING"}:
                self.sign2 ()
            elif self.token == "СИНХРОНИЗИРОВАННЫЙ":
                self.synchronized ()
            elif self.token == "ИСПОЛЬЗОВАНИЕ":
                использование = self.usage ()
            elif self.token == "ЗНАЧЕНИЕ":
                self.value ()
            еще:
                пытаться:
                    # ИСПОЛЬЗОВАНИЕ ключевого слова необязательно
                    usage = self.usage2 (self.token)
                    self.token = следующий (self.lex)
                кроме SyntaxError как e:
                    поднять SyntaxError ("{! r} unrecognized" .format (self.token))
        assert self.token == "."

        # Создать и передать DDE
        если рис:
            # Разобрать картинку; обновите предложение USAGE, добавив подробные сведения.
            sizeScalePrecision = picture_parser (рис)
            usage.setTypeInfo (sizeScalePrecision)

            # Создаем элементарный DDE
            dde = скат.cobol.defs.DDE (
                уровень, имя, использование = использование, происходит = происходит, переопределяет = переопределяет,
                pic = pic, sizeScalePrecision = sizeScalePrecision)
        еще:
            # Создание DDE на уровне группы
            dde = stingray.cobol.defs.DDE (
                уровень, имя, использование = использование, происходит = происходит, переопределяет = переопределяет)

        yield dde
 

 def makeRecord (self, lexer):
    "" "Разобрать весь блок текста тетради." ""
    # Разобрать первый DDE и установить стек контекста.
    ddeIter = self.dde_iter (лексический анализатор)
    top = next (ddeIter)
    top.top, top.parent = weakref.ref (верх), Нет
    top.allocation = stingray.cobol.defs.Group ()
    self.context = [вверху]
    для dde в ddeIter:
        #print (dde, ":", self.context [-1])
        # Если уровень ниже или тот же, всплывает контекст
        пока сам.context и dde.level <= self.context [-1] .level:
            self.context.pop ()

        если len (self.context) == 0:
            # Частный случай нескольких уровней 01.
            self.log.info ("Несколько уровней {0}" .format (top.level))
            self.decorate (вверху)
            верхняя доходность
            # Создайте новую вершину с этим DDE.
            top = dde
            top.top, top.parent = weakref.ref (верх), Нет
            top.allocation = stingray.cobol.defs.Group ()
            self.context = [вверху]
        еще:
            # Общий случай.# Сделать этот DDE частью родительского DDE наверху контекстного стека
            self.context [-1] .addChild (dde)
            # Помещаем этот DDE в стек контекста
            self.context.append (dde)
            # Обработка особого случая дочерних элементов уровня "88".
            если dde.level == '88':
                assert dde.parent (). picture, "88 not under elementary item"
                dde.size = dde.parent (). размер
                dde.usage = dde.parent (). использование

    self.decorate (вверху)
    верхняя доходность
 

 def декорировать (самостоятельно, вверху):
    "" "Три этапа постобработки: преобразователь, размер и смещение, размерность." ""
    stingray.cobol.defs.resolver (вверху)
    stingray.cobol.defs.setDimensionality (вверху)
    если верх.variably_located:
        # Невозможно установить все смещения и общие размеры.
        pass # Записать предупреждение?
    еще:
        stingray.cobol.defs.setSizeAndOffset (вверху)
 

 http://yuml.me/diagram/scruffy;/class/
#cobol_loader_final,
[COBOLSchemaLoader] -> [Lexer],
[COBOLSchemaLoader] -> [RecordFactory],
[RecordFactory] <> - [DDE],
[DDE] <> - [DDE].
 

 make_attr_log = logging.getLogger ("make_attr")
make_schema_log = logging.getLogger ("make_schema")
 

 def make_attr (aDDE):
    attr = stingray.cobol.RepeatingAttribute (
        # Важные особенности:
        name = aDDE.name,
        size = aDDE.size,
        create = aDDE.usage.create_func,

        # Расширения COBOL:
        dde = weakref.ref (aDDE),
    )
    aDDE.attribute = weakref.ref (attr)
    make_attr_log.debug ("Атрибут {0} <=> {1}". формат (aDDE, attr))
    вернуть attr
 

 def make_schema (dde_iter):
    schema = stingray.schema.Schema (dde = [])
    для записи в dde_iter:
        make_schema_log.debug ("Запись {0}". формат (запись))
        schema.info ['dde']. append (запись)
        для aDDE в записи:
            attr = make_attr (aDDE)
            схема.добавить (attr)
    схема возврата
 

 класс COBOLSchemaLoader (stingray.schema.loader.ExternalSchemaLoader):
    "" "Разберите COBOL DDE и создайте схему.
    Подкласс может определять lexer_class для настройки
    парсинг."" "
    lexer_class = Лексер
    record_factory_class = RecordFactory
    def __init __ (self, source, replace = None):
        self.source = источник
        self.lexer = self.lexer_class (заменяющий)
        self.parser = self.record_factory_class ()
 

 def нагрузка (самостоятельно):
    dde_iter = self.parser.makeRecord (self.lexer.scan (self.source))
    схема = make_schema (dde_iter)
    схема возврата
 

 с открытым ("sample / zipcty.cob", "r") как cobol:
    schema = stingray.cobol.loader.COBOLSchemaLoader (cobol) .load ()
 

 класс MySchemaLoader (cobol.COBOLSchemaLoader):
    lexer_class = cobol.loader.Lexer_Long_Lines
 

 def COBOL_schema (источник, lexer_class = Lexer, замена = None,):
    lexer = lexer_class (заменяющий)
    parser = RecordFactory ()
    dde_list = список (parser.makeRecord (lexer.scan (исходный код)))
    схема = make_schema (dde_list)
    вернуть dde_list, схему