(3 оценок, среднее: 4,67 из 5)
Загрузка...
Учебная работа. Курсовая работа: Конвертер программы с подмножества языка Си в Паскаль с использованием LL1 метода синтаксическог
Курсовая работа
Выполнили студенты группы ИАС-00 Мардасова У. А. Шалудько В. А.
Кемеровский Муниципальный Институт, Факультет Информационных Технологий
Новокузнецк, 2002г.
Введение
При знакомстве с языком СИ, в особенности опосля исследования Паскаля и Бейсика, погружение в детали его изобразительных средств может затушевать важную идея: хотя на СИ можно написать фактически всякую прикладную программку, он вначале для этого не предназначен. СИ является результатом эволюционного развития языков сотворения системных программных средств. Если в прикладном программировании эволюция шла от Фортрана к Алголу, Коболу, Паскалю и т.д., то в системном — от Ассемблеров, привязанных к архитектуре ЭВМ , к СИ, для которого сделаны трансляторы, делающие его хоть и независящим от архитектуры, но не меняющим основного назначения.
При помощи СИ можно создать то, что на Паскале создать нереально (либо практически нереально) — к примеру, написать фрагмент операционной системы (либо новейшую операционную систему), утилиты и т.п. Так, ряд трансляторов с Паскаля написаны на СИ; оборотное нереально представить. В то же время, не раз отмечалось, что прикладные программки, написанные на Паскале, различаются большей надежностью, чем написанные на СИ; их легче читать, передавать от 1-го программера другому для совершенствования и сопровождения. Это соединено с тем, что Паскаль содержит значительно больше ограничений и является языком наиболее высочайшего уровня с мощной типизацией данных. Для языка же, который предназначен для разработки системного программного обеспечения, чем меньше ограничений, тем лучше; так, в СИ вероятны неявные преобразования всех базисных типов данных и указателей друг в друга, что очень лучше при разработке системных средств, но при невнимательности программера приводит к ошибкам, не улавливаемым транслятором с СИ (Паскаль же подобные недопустимые операции пресекает немедля).
Очевидно, произнесенное выше не следует абсолютизировать. Программеры, привыкшие к СИ, удачно пишут на нем программки разных классов. Это касается не только лишь СИ — вспомяните о экспертных системах, написанных на Бейсике. В то же время, при массовом программировании придерживаться «разделение труда» меж языками представляется наиболее естественным.
Широкой популярности Паскаля посреди программистов содействуют последующие предпосылки:
Благодаря собственной компактности, удачному начальному описанию Паскаль оказался довольно лёгким для исследования.
язык программирования Паскаль отражает фундаментальные и более принципиальные концепции (идеи) алгоритмов в тривиальной и просто воспринимаемой форме, что предоставляет программеру средства, помогающие проектировать программки.
Язык Паскаль дозволяет чётко воплотить идеи структурного программирования и структурной организации данных.
язык Паскаль сыграл огромную роль в развитии способов аналитического подтверждения корректности программ и дозволил реально перейти от способов отладки программ к системам автоматической проверки корректности программ.
Применение языка Паскаль существенно подняло «планку» надёжности разрабатываемых программ за счёт требований Паскаля к описанию применяемых в программке переменных, проверки согласованности программки при компиляции без её выполнения.
Внедрение в Паскале обычных и гибких структур управления: ветвлений, циклов.
С иной стороны язык программирования СИ — это всепригодный язык с богатым набором операторов и малогабаритным методом записи выражений. Благодаря гибкости, выразительности и компактности собственной конструкции СИ захватил самую большую популярность в среде проф программистов и обширно употребляется при разработке системных и прикладных программ.
язык СИ представляет собой успешный соглашение меж желанием располагать теми способностями, которые обычно предоставляют программеру настолько понятные и комфортные языки высочайшего уровня, и рвением отлично применять индивидуальности компа. Не считая набора средств, присущих современным языкам программирования высочайшего уровня (структурность, модульность, определяемые типы данных) в него включены средства для программирования «практически» на уровне ассемблера (внедрение указателей, побитовые операции, операции сдвига). большенный набор операторов дозволяет писать малогабаритные и действенные программки. Но, такие массивные средства требуют от программера осторожности, аккуратности и неплохого познания языка со всеми его преимуществами и недочетами. В отличие от языков программирования типа Паскаль, требующих твердой дисциплины программирования ограничивающих свободу программера, способствующих устранению почти всех ошибок еще на стадии их трансляции, язык СИ предоставляет программеру самую большую свободу. Но, ответственность за правильность программ при всем этом на сто процентов ложится на программера.
В истинное время имеется огромное количество систем программирования на СИ для различных типов компов. Создано много библиотек модулей, инструментальных средств разработки и отладки, облегчающих создание новейших программ. Программки на СИ владеют высочайшей мобильностью, без каких или конфигураций они переносятся, транслируются и производятся на машинках различного типа.
В рамках учебного проекта реализована программная система, именуемая в предстоящем конвертором, позволяющая заавтоматизировать процесс преобразования программ на Паскале в программки на языке СИ. На вход конвертора подается синтаксически верная программка на Паскале, на выходе его формируется эквивалентная ей программка на языке СИ.
Задачка разработки конвертора относится к классу задач автоматизации реинженеринга программ с устаревших языков на современные языки программирования и новейшие платформы. Разработка конвертора для языка Паскаль является довольно трудоёмкой в силу особенностей синтаксиса и семантики языка Паскаль.
язык Паскаль не допускает использования принципов умолчаний и сокращений, просит серьезного соблюдения соответствия типов данных, в нём жёстко регламентированы структура и пространство описания программных объектов.
В силу выше произнесенного, даже ручной перевод программки на Паскале на язык СИ просит от программера приложения значимых умственных усилий, а реализация конвертора для языка Паскаль вероятна только при наличии существенных временных и вещественных ресурсов. Кроме синтаксических ограничений входная программка конвертора имеет ряд чисто семантических ограничений, связанных с реализацией фактически конвертора. Перечислим главные из их:
Ограниченное внедрение типов данных, в полном объёме поддерживаются лишь арифметические типы данных.
Вложенность блоков, в каких употребляются одноименные объекты, не обязана превосходить 2-ух уровней.
Процедурные блоки не должны быть снутри BEGIN-блоков, вложенность процедурных блоков не ограничивается.
Допускается применять лишь одномерные массивы с открытой правой границей (динамические массивы) в качестве характеристик процедурных блоков; при всем этом адресуются элементы массива в Паскаль программке, начиная с нулевого элемента.
Ограниченное внедрение смешения разных типов данных.
Выражения в Паскале
Система языка, задающая порядок выполнения деяния над элементами данных, именуется выражением. Выражение состоит из операндов (operand — элемент данных, участвующий в операции), — величин и выражений, над которыми делается операция (константы и переменные всех типов, воззвания к функциям); круглых скобок и символов операций. Операции определяют деяния, которые нужно выполнить над операндами. к примеру, в выражении (X+Y-10) X, Y и 10 — операнды; а «+» и «-» — знаки операций сложения и вычитания.
В простом случае выражение может состоять из одной переменной либо константы. Круглые скобки ставятся так же, как и в обыденных арифметических выражениях для управления ассоциативностью и порядком выполнения операций.
Операции в языке Паскаль делятся на арифметические, дела, логические (булевские), операцию @, строковые и др. Выражения соответственно именуются арифметическими, дела, булевскими, строковыми и т.д. зависимо от того, какого типа операнды и операции в их употребляются.
Тип значения, вычисляемого при помощи выражения, определяется типом его операндов и знаками выполняемых над ними операций.
Операции могут быть унарными и бинарными. В первом случае операция относится к одному операнду и постоянно записывается перед ним, во 2-м — операция выражает отношение меж 2-мя операндами и записывается меж ними.
к примеру, -А — унарная операция, Х+У — бинарная.
Арифметические выражения и операции.
Арифметическим именуется выражение, составленное из операндов арифметического типа и использующее лишь знаки арифметических операций и круглые скобки. порядок вычисления определяется скобками и старшинством операций.
Арифметическое выражение порождает целое либо действительное (вещественное)
Целая либо действительная константа без знака;
Целая либо действительная переменная;
Элемент массива целого либо реального типа;
Функция, принимающая целое либо действительное
Арифметические операции делают арифметические деяния в выражениях над значениями операндов целочисленных и вещественных типов. Арифметические операции языка Паскаль представлены в таблице1.
Арифметические операции
Операция
действие
Типы операндов
Тип результата
Бинарные
+
—
*
/
DIV
MOD
AND
SHL
SHR
OR
XOR
Сложение
Вычитание
Умножение
Деление
Целочисленное деление
Остаток от деления
Арифметическое И
Сдвиг на лево
Сдвиг на Право
Арифметическое ИЛИ
Исключающая дизъюнкция
Целый
Вещественный
Целый
Вещественный
Целый
Вещественный
Целый
Вещественный
Целый
Целый
Целый
Целый
Целый
Целый
Целый
Целый
Вещественный
Целый
Вещественный
Целый
Вещественный
Вещественный
Вещественный
Целый
Целый
Целый
Целый
Целый
Целый
Целый
Унарные
+
—
NOT
Сохранение знака
Отрицание знака
Арифметическое отрицание
Целый
Вещественный
Целый
Вещественный
Целый
Целый
Вещественный
Целый
Вещественный
Целый
Выражения и операции дела.
Выражением дела именуется словосочетание языка, в каком два выражения соединены знаком операции дела. Выражение дела описывает истинность либо ложность результата. Операции дела делают сопоставление 2-ух операндов и определяют, поистине
В языке Паскаль операции дела и рассмотренные ниже булевские операции наиболее важны при написании программ, чем в остальных языках, потому что они активно употребляются для реализации разветвляющихся и повторяющихся алгоритмов. В таблице 2 приведены операции дела, допустимые в версии языка Паскаль для ПЭВМ.
Сравниваемые величины могут принадлежать к хоть какому скалярному либо перечисляемому типу данных. Итог постоянно имеет булевский тип и воспринимает одно из 2-ух значений: True (правда) либо False (ересь).
Операции дела.
Операция
Заглавие
Выражение
Итог
=
<>
>
<
>=
<=
in
Равно
Не равно
больше
Меньше
Больше либо равно
Меньше либо равно
Принадлежность
A=B
A<>B
A>B
A<B
A>=B
A<=B
A in M
True, если А равно В
True, если А не равно В
True, если А больше В
True, если А меньше В
True, если А больше либо равно В
True, если А меньше либо равно В
True, если А находится в перечне М
Логические выражения и операции.
Результатом выполнения логического (булевского) выражения является логическое
Простейшими видами логических выражений являются последующие:
Логическая константа;
Логическая переменная;
Элемент массива логического типа;
Логическая функция;
Выражение дела.
Остальные логические выражения строятся из перечисленных выше методом внедрения логических операций и круглых скобок. Перечень логических операций приведен в таблице 3.
Логические операции.
Операция
действие
Выражение
А
В
Итог
Not
And
Or
xor
Логическое отрицание
Логическое И
Логическое ИЛИ
Исключающее ИЛИ
not A
A and B
A or B
A xor B
True
False
True
True
False
False
True
True
False
False
True
True
False
False
True
False
True
False
True
False
True
False
True
False
True
False
False
True
True
False
False
False
True
True
True
False
False
True
True
False
Операция @.
При помощи операции @ можно сделать указатель на переменную. В таблице 4 показаны операнд и типы результата.
Операция сотворения указателя.
Операция
действие
Тип операнда
Тип результата
@
Получение указателя
ссылка на переменную, функцию либо идентификатор функции
Указатель (совместимый с nil)
Операция @ является унарной. В качестве операнда может употребляться ссылка на переменную, функцию либо идентификатор функции. Опосля выполнения операнду ворачивается соответственный указатель, тип которого является таковым же, как тип указателя nil, и, как следует, его можно присвоить хоть какому указателю переменной.
Выражения в СИ.
Конструкции, включающие константы (литералы), переменные, знаки операций, скобки для управления порядком выполнения операций, воззвания к функциям, именуют выражениями.
Если в выражениях встречаются операнды разных типов, то они преобразуются к общему типу в согласовании с определенными правилами:
Переменные типа char интерпретируются как целые без знака (unsigned);
Переменные типа short автоматом преобразуются в int; если один из операндов имеет тип unsigned, то иной (остальные) также преобразуется к типу unsigned и итог имеет тип unsigned;
Если один из операндов имеет тип int, то иной (остальные) также преобразуется к типу int и итог имеет тип int;
Если один из операндов имеет тип char, то иной (остальные) также преобразуется к типу char и итог имеет тип char;
Во время операции присваивания значения правой части преобразуются к типу левой части, который и становится типом результата;
В процессе преобразования int в char излишние 8 бит просто отбрасываются.
Не считая того, существует возможность буквально указывать требуемый тип данных, к которому нужно привести некую величину (в скобках перед данной для нас величиной). Скобки и имя типа вкупе образуют операцию, именуемую приведением типов.
к примеру: z=(int)x+(int)y;
Композиция символов операций и операндов, результатом которой является определенное
В языке СИ присваивание также является выражением, и значением такового выражения является величина, которая присваивается.
При вычислении выражений тип всякого операнда быть может преобразован к другому типу. Преобразования типов могут быть неявными, при выполнении операций и вызовов функций, либо очевидными, при выполнении операций приведения типов.
Операнд — это константа, литерал, идентификатор, вызов функции, индексное выражение, выражение выбора элемента либо наиболее сложное выражение, сформированное композицией операндов, символов операций и круглых скобок. Хоть какой операнд, который имеет постоянное
Выражения со знаками операций могут участвовать в выражениях как операнды. Выражения со знаками операций могут быть унарными (с одним операндом), бинарными (с 2-мя операндами) и тернарными (с 3-мя операндами).
Унарное выражение состоит из операнда и предыдущего ему знаку унарной операции и имеет последующий формат:
знак-унарной-операции операнд
Бинарное выражения состоит из 2-ух операндов, разбитых знаком бинарной операции:
операнд1 символ-бинарной-операции операнд2
Тернарное выражение состоит из 3-х операндов, разбитых знаками тернарной операции (?) и (:), и имеет формат:
операнд1 ? операнд2 : операнд3
По количеству операндов, участвующих в операции, операции также разделяются на унарные, бинарные и тернарные.
В языке Си имеются последующие унарные операции:
-арифметическое отрицание (отрицание и дополнение);
~ побитовое логическое отрицание (дополнение);
! логическое отрицание;
& вычисление адреса;
+ унарный плюс;
++ повышение (инкремент);
—уменьшение (декремент);
sizeof размер .
Унарные операции производятся справа влево.
Операции роста и уменьшения наращивают либо уменьшают символ операции записан перед операндом (префиксная форма), то изменение операнда происходит до его использования в выражении. Если символ операции записан опосля операнда (постфиксная форма), то операнд сначала употребляется в выражении, а потом происходит его изменение.
В отличие от унарных, бинарные операции, перечень которых приведен в табл.7, производятся слева вправо.
Таблица 7
символ операции
Операция
Группа операций
*
Умножение
Мультипликативные
/
Деление
%
Остаток от деления
+
Сложение
Аддитивные
—
Вычитание
<<
Сдвиг на лево
Операции сдвига
>>
Сдвиг на Право
<
Меньше
Операции дела
<=
Меньше либо равно
>=
больше либо равно
= =
Равно
!=
Не равно
&
Поразрядное И
Поразрядные операции
|
Поразрядное ИЛИ
^
Поразрядное исключающее ИЛИ
&&
Логическое И
Логические операции
||
Логическое ИЛИ
,
Последовательное вычисление
Поочередного вычисления
=
Присваивание
Операции присваивания
*=
Умножение с присваиванием
/=
Деление с присваиванием
%=
Остаток от деления с присваиванием
-=
Вычитание с присваиванием
+=
Сложение с присваиванием
<<=
Сдвиг на лево с присваиванием
>>=
Сдвиг на Право присваиванием
&=
Поразрядное И с присваиванием
|=
Поразрядное ИЛИ с присваиванием
^=
Поразрядное исключающее ИЛИ с присваиванием
Мультипликативные операции
К этому классу операций относятся операции умножения
, деления (/) и получение остатка от деления (%). Операндами операции (%) должны быть целые числа. Отметим, что типы операндов операций умножения и деления могут различаться, и для их справедливы правила преобразования типов. Типом результата является тип операндов опосля преобразования.
Операция умножения
делает умножение операндов. Операция деления (/) делает деление первого операнда на 2-ой. Если две целые величины не делятся нацело, то итог округляется в сторону нуля. При попытке деления на ноль выдается сообщение во время выполнения. Операция остаток от деления (%) дает остаток от деления первого операнда на 2-ой.
Аддитивные операции
К аддитивным операциям относятся сложение (+) и вычитание (-). Операнды могут быть целого либо плавающего типов. В неких вариантах над операндами аддитивных операций производятся общие арифметические преобразования. Но преобразования, выполняемые при аддитивных операциях, не обеспечивают обработку ситуаций переполнения и утраты значимости. информация пропадает, если итог аддитивной операции не быть может представлен типом операндов опосля преобразования. При всем этом сообщение о ошибке не выдается.
Результатом выполнения операции сложения является сумма 2-ух операндов. Операнды могут быть целого либо плавающего типа либо один операнд быть может указателем, а 2-ой — целой величиной.
Операция вычитания (-) вычитает 2-ой операнд из первого. Вероятна последующая композиция операндов:
1. Оба операнда целого либо плавающего типа.
2. Оба операнда являются указателями на один и этот же тип.
3. 1-ый операнд является указателем, а 2-ой — целым.
Отметим, что операции сложения и вычитания над адресами в единицах, хороших от длины типа, могут привести к непредсказуемым результатам.
Логические операции
К логическим операциям относятся операция логического И (&&) и операция логического ИЛИ (||). Операнды логических операций могут быть целого типа, плавающего типа либо типа указателя, при всем этом в каждой операции могут участвовать операнды разных типов.
Операнды логических выражений рассчитываются слева вправо. Если значения первого операнда довольно, чтоб найти итог операции, то 2-ой операнд не рассчитывается.
Логические операции не вызывают обычных арифметических преобразований. Они оценивают любой операнд исходя из убеждений его эквивалентности нулю. Результатом логической операции является 0 либо 1, тип результата int.
Операция логического И (&&) производит значения. Если один из операндов равен 0, то итог также равен 0. Если
Операция логического ИЛИ (||) делает над операндами операцию включающего ИЛИ. Она производит
Операция поочередного вычисления
Операция поочередного вычисления обозначается запятой (,) и употребляется для вычисления 2-ух и наиболее выражений там, где по синтаксису допустимо лишь одно выражение. Эта операция вычисляет два операнда слева вправо. При выполнении операции поочередного вычисления, преобразование типов не делается. Операнды могут быть всех типов. Итог операции имеет значения и тип второго операнда. Отметим, что запятая может употребляться также как знак разделитель, потому нужно по контексту различать, запятую, применяемую в качестве разделителя либо знака операции.
Условная операция
В языке СИ имеется одна тернарная операция — условная операция, которая имеет последующий формат:
операнд-1 ? операнд-2 : операнд-3
Операнд-1 должен быть целого либо плавающего типа либо быть указателем. Он оценивается исходя из убеждений его эквивалентности 0. Если операнд-1 не равен 0, то рассчитывается операнд-2 и его
1. Если операнд-2 либо операнд-3 имеет целый либо плавающий тип (отметим, что их типы могут различаться), то производятся обыденные арифметические преобразования. Типом результата является тип операнда опосля преобразования.
2. Если операнд-2 и операнд-3 имеют один и этот же тип структуры, объединения либо указателя, то тип результата будет этим же самым типом структуры, объединения либо указателя.
3. Если оба операнда имеют тип void, то итог имеет тип void.
4. Если один операнд является указателем на объект хоть какого типа, а иной операнд является указателем на vold, то указатель на объект преобразуется к указателю на vold, который и будет типом результата.
Если один из операндов является указателем, а иной постоянным выражением со значением 0, то типом результата будет тип указателя.
Операции роста и уменьшения
Операции роста (++) и уменьшения (—) являются унарными операциями присваивания. Они соответственно наращивают либо уменьшают значения операнда на единицу. Операнд быть может целого либо плавающего типа либо типа указатель и должен быть модифицируемым. Операнд целого либо плавающего типа растут (уменьшаются) на единицу. Тип результата соответствует типу операнда. Операнд адресного типа возрастает либо миниатюризируется на размер объекта, который он адресует. В языке допускается префиксная либо постфиксная формы операций роста (уменьшения), потому значения выражения, использующего операции роста (уменьшения) зависит от того, какая из форм обозначенных операций употребляется.
Если символ операции стоит перед операндом (префиксная форма записи), то изменение операнда происходит до его использования в выражении и результатом операции является увеличенное либо уменьшенное
В этом случае если символ операции стоит опосля операнда (постфиксная форма записи), то операнд сначала употребляется для вычисления выражения, а потом происходит изменение операнда.
Построение управляющих таблиц
Определим выражение в виде БНФ для языка СС++ и Turbo Pascal 7.0.
СС++:
В::= ++i | —i | i++ | i— | B*B | B/B | B%B | B+B | B-B | B<B | B>B | B>=B | B<=B | B!=B | B==B | B&&B | B|| | (k)B | B?B:B | i=B | i*=B | i-=B | i+=B | i/=B | i%=B | i | i(S) | (B)
S::=B | B, S
Где В – выражение;
S – перечень выражений;
i — индификатор.
Turbo Pascal 7.0.
В::=П | П=П | П<П | П> П | П<> П | П>= П | П<= П
П::=+C | -C | П+C | П-C | П or C
C::=M | C*M | C/M | C div M | C mod M | C and M
M::=i | i(S) | (B)
S::=B | B, S
Где В – выражение;
S – перечень выражений;
П – обычное выражение;
С – слагаемое;
М – множитель:
i — индификатор.
N
сейчас приведём данные БНФ к КС-грамматике: G=<N, T, P, S>
СС++ Turbo Pascal 7.0
B- (k)B B-П
B-++i B-П=П
B—i B-П<П
B-i++ B-П>П
B-B*B B-П<=П
B-B/B B-П>=П
B-B+B B-П<>П
B-B-B П-П+C
B-B<B П-П-C
B-B>B П-П or C
B-B>=B П-+C
B-B<=B П—C
B-B!=B C-M
B-B==B C-C*M
B-B&&B C-C/M
B-B||B C-C div M
B-B?B:B C-C mod M
B-i=B C-C and M
B-i*=B M-i
B-i/=B M-i(S)
B-i%=B M-(B)
B-i+=B S-B
B-i-=B S-B, S
B-i
B-i(S)
B-(B)
S- B
S-B, S
N(CC++)={B, П, S}
T(CC++)=
N(TP)={B, П, C, M, S}
T(TP)={ i, +, -, =, <>, <, >, <=, >=, *, /, div, mod, and, or, (, ), ,}
Устранив цепные правила, левую рекурсию, получим LL(1)-грамматику.
CC++
B-i B1
B1-= BB’
B1-*=BB’
B1-+=BB’
B1—BB’
B1-/BB’
B1—B’
B1-++B’
B1-(SS1
S1-)B’
B-(B2
B2-i B1C
C-)B’
B2-(B2C
B2—C1 C
C1-i B’
B2-++C1 C
B2-k C2
C2-)BB’
B—C1
B-++C1
B1-%BB’
B1-*BB’
B1-/BB’
B1-+BB’
B1—BB’
B1->BB’
B1-<BB’
B1-<=BB’
B1->=BB’
B1-==BB’
B1-!=BB’
B1-&&BB’
B1-||BB’
B1-?BB3
B3-:BB’
B1-$
B’-%BB’
B’-*BB’
B’-/BB’
B’-+BB’
B’—BB’
B’->BB’
B’-<BB’
B’->=BB’
B’-<=BB’
B’-==BB’
B’-!=BB’
B’-&&BB’
B’-||BB’
B’-?BB3
B1-%=BB’
B’-$
S-i B1 S’
S- (B2S’
S—C1S’
S-++C1S’
S’-, S
S’-$
ДОПУСТИТЬ
0.Отторгнуть
Turbo Pascal 7.0
B-+CП’B’
B— CП’B’
B-i M’C’П’B’
B-(BM1C’П’B’
B’-=П
B’-<П
B’->П
B’-<>П
B’->=П
B’-<=П
B’-$
П-+CП’
П—CП’
П- i M’C’П’
П-(BM1C’П’
П’-+CП’
П’—CП’
П’- or C’П’
П’-$
M-I M’
M-(BM1
M’-(SM1
M’-$
M1-)
C-i M’C’
C-(BM’C’
C’-*MC’
C’-/MC’
C’-div MC’
C’-mod MC’
C’-and MC’
C’-$
S-+CП’B’S’
S—CП’B’S’
S-i M’C’П’B’S’
S-(B M1C’П’B’
S’-, S
S’-$
ДОПУСТИТЬ
Отторгнуть
Потому что данные LL(1)-грамматики являются грамматиками Грейбаха, то по ним можно выстроить управляющие таблицы.
Управляющая таблица для выражения на языке СС++
|-
37
53
59
60
%=
52
/=
6
-=
5
+=
4
*=
3
=
2
,
37
53
58
:
36
?
35
51
&&
33
49
||
34
50
==
31
47
!=
32
48
<=
29
46
>=
30
45
>
27
43
<
28
44
—
26
42
+
25
41
/
24
40
*
23
39
%
22
38
—
56
20
7
15
++
57
21
8
17
K
18
I
54
1
12
16
)
37
53
13
19
59
10
(
55
11
9
14
S
B
B1
B2
B3
B’
C
C1
C2
S’
S1
#
Управляющая таблица для выражения на языке Turbo Pascal 7.0
|-
11
32
23
19
38
39
Or
32
23
18
<=
10
32
23
19
>=
9
32
23
19
>
7
32
23
19
<
6
32
23
19
<>
8
32
23
19
=
5
32
23
19
And
31
23
Mod
30
23
Div
29
23
/
28
23
*
27
23
—
34
2
32
23
13
17
+
33
1
32
23
12
16
,
11
32
23
19
37
I
35
3
25
20
14
)
11
32
23
24
19
38
(
36
4
26
21
22
15
S
B
B’
C
C’
M
M’
M1
П
П’
S’
#
Пример работы программки
Ввели выражение на языке СИ:
КУРСОВАЯ РАБОТА ПО ЯПМТ
Выберете язык: 1 — СИСИ++ 2 — Turbo Pascal 7.0
1
Напишите выражение на языке С:
(e+e==7)
Дескрипторный текст:
0 2 9 2 16 2 1
Поменять(S’,В2) Сдвиг
Поменять(C,В1) Сдвиг
Поменять(В’,В) Сдвиг
Поменять(В1) Сдвиг
Поменять(В’,В) Сдвиг
Поменять(В1) Сдвиг
Вытолкнуть Держать
Вытолкнуть Держать
Вытолкнуть Держать
Поменять(В’) Сдвиг
Вытолкнуть Держать
Вытолкнуть Держать
ДОПУСТИТЬ
Выходная лента:
55 12 25 1 31 1 37 53 53 13 53 59 60
Ввели не выражение:
КУРСОВАЯ РАБОТА ПО ЯПМТ
Выберете язык: 1 — СИСИ++ 2 — Turbo Pascal 7.0
1
Напишите выражение на языке С:
t+
Дескрипторный текст:
2 9
Поменять(S’,В1) Сдвиг
Поменять(В’,В) Сдвиг
Отторгнуть
Выходная лента:
54 25 0
Ввели выражение на Паскале:
КУРСОВАЯ РАБОТА ПО ЯПМТ
Выберете язык: 1 — СИСИ++ 2 — Turbo Pascal 7.0
2
Напишите выражение на языке TP:
ww=s+1
Дескрипторный текст:
2 11 2 4 2
Поменять(В’П’C’M’) Сдвиг
Вытолкнуть Держать
Вытолкнуть Держать
Вытолкнуть Держать
Поменять(П) Сдвиг
Поменять(П’C’M’) Сдвиг
Вытолкнуть Держать
Вытолкнуть Держать
Поменять(П’C) Сдвиг
Поменять(C’M’) Сдвиг
Вытолкнуть Держать
Вытолкнуть Держать
Вытолкнуть Держать
ДОПУСТИТЬ
Выходная лента:
3 23 32 19 5 14 23 32 16 25 23 32 19 39
Ввели не выражение
КУРСОВАЯ РАБОТА ПО ЯПМТ
Выберете язык: 1 — СИСИ++ 2 — Turbo Pascal 7.0
2
Напишите выражение на языке TP:
f=s+
Дескрипторный текст:
2 11 2 4
Поменять(В’П’C’M’) Сдвиг
Вытолкнуть Держать
Вытолкнуть Держать
Вытолкнуть Держать
Поменять(П) Сдвиг
Поменять(П’C’M’) Сдвиг
Вытолкнуть Держать
Вытолкнуть Держать
Поменять(П’C) Сдвиг
Отторгнуть
Выходная лента:
3 23 32 19 5 14 23 32 16 0
Листинг программки:
#include<stdio.h>
#include<conio.h>
#define n 100
#define t 17
#define m 53
#define g 11
char s1[n],s[n],a[n];
int j=0,h,vl[n],y=0;
/*—————————ВВОД ВЫРАЖЕНИЯ——————————*/
int vvod()
{
int i;
printf(«tttКУРСОВАЯ РАБОТА ПО ЯПМТn»);
printf(«Выберете язык: 1 — СИСИ++ 2 — Turbo Pascal 7.0n»);
scanf(«%d»,&y);
if(y==1)
printf(«Напишите выражение на языке С:n»);
{for(i=0;i<=n-1;i++)
{
scanf(«%c»,&s1[i]);
if (s1[i]==’n’){j=i;break;}
}
}
if(y==2)
printf(«Напишите выражение на языке TP:n»);
{for(i=0;i<=n-1;i++)
{
scanf(«%c»,&s1[i]);
if (s1[i]==’n’){j=i;break;}
}
}
return y;
};
/*————————————————————————*/
/*—————————ИНДИФИКАТОР———————————-*/
int perem(int be,int l)
{
int i,j,k,d(0),i1,d1=0,z(0),chiclo(0),di(0);
char b[m]={‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’,’i’,’j’,’k’,’l’,’m’,’n’,’o’,
‘p’,’q’,’r’,’s’,’t’,’u’,’v’,’w’,’x’,’y’,’z’,’A’,’B’,’C’,’D’,
‘F’,’G’,’H’,’I’,’J’,’K’,’L’,’M’,’N’,’O’,’P’,’Q’,’R’,’S’,’T’,
‘U’,’V’,’W’,’X’,’W’,’Z’,’E’,’_’};
char c[g]={‘1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9′,’0′,’.’};
for(j=0;j<=m-1;j++)
{
if(s1[be]==b[j]) {d=1;break;}
}
if(d==1)
{
for(i=be+1;i<=l;i++)
{
d=0;
for(j=0;j<=m-1;j++)
{
if(s1[i]==b[j]) {d=1;break;}
}
if (d==0)
{
d1=0;
for(k=0;k<=g-1;k++)
{
if(s1[i]==c[k]) {d1=1;break;}
}
if(d1==0)break;
}
}
}
chiclo=0;
for(i=be;i<=l;i++)
for(j=0;j<=g-1;j++)
{
if(s1[i]==c[j]) {chiclo=chiclo++;break;}
}
if(d1==1||d==1||chiclo==l-be+1&&z==0) {z=1;/*printf(«DA»);*/} else {z=0;/*printf(«NET»);*/}
return z;
};
/*———————КОНЕЦ ИНДИФИКАТОРА———————————*/
/*—————————LL(1) — анализатор——————————*/
int analiz()
{
int z[6],v,z1,i(0),j,k;
int tab[12][29]={{55,0,54,0,57,56,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{11,0,1,0,21,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{9,37,0,0,8,7,22,23,24,25,26,28,27,30,29,32,31,34,33,35,0,0,2,3,4,5,6,52,37},
{14,0,12,18,17,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,36,0,0,0,0,0,0,0,0},
{0,53,0,0,0,0,38,39,40,41,42,44,43,45,46,48,47,50,49,51,0,53,0,0,0,0,0,0,53},
{0,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,59,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,58,0,0,0,0,0,0,59},
{0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,60}};
printf(«n»);
z1=0;
z[z1]=11;z1++;z[z1]=0;
v=0;j=0;
do
{
switch(tab[z[z1]][a[v]])
{
case 1: z[z1]=2;v++;
printf(«tЗаменить(В1)tСдвигn»);vl[j]=1;break;
case 2: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=2;break;
case 3: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=3;break;
case 4: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=4;break;
case 5: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=5;break;
case 6: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=8;break;
case 7: z[z1]=5;v++;
printf(«tЗаменить(В’)tСдвигn»);vl[j]=7;break;
case 8: z[z1]=5;v++;
printf(«tЗаменить(В’)tСдвигn»);vl[j]=8;break;
case 9: z[z1]=10;z1++;z[z1]=0;v++;
printf(«tЗаменить(S1,S)tСдвигn»);vl[j]=9;break;
case 10: z[z1]=5;v++;
printf(«tЗаменить(В’)tСдвигn»);vl[j]=10;break;
case 11: z[z1]=3;v++;
printf(«tЗаменить(В2)tСдвигn»);vl[j]=11;break;
case 12: z[z1]=6;z1++;z[z1]=2;v++;
printf(«tЗаменить(C,В1)tСдвигn»);vl[j]=12;break;
case 13: z[z1]=5;v++;
printf(«tЗаменить(В’)tСдвигn»);vl[j]=13;break;
case 14: z[z1]=6;z1++;z[z1]=3;v++;
printf(«tЗаменить(C,В2)tСдвигn»);vl[j]=14;break;
case 15: z[z1]=6;z1++;z[z1]=7;v++;
printf(«tЗаменить(C,C1)tСдвигn»);vl[j]=15;break;
case 16: z[z1]=5;v++;
printf(«tЗаменить(В’)tСдвигn»);vl[j]=16;break;
case 17: z[z1]=6;z1++;z[z1]=7;v++;
printf(«tЗаменить(C,C1)tСдвигn»);vl[j]=17;break;
case 18: z[z1]=8;v++;
printf(«tЗаменить(C2)tСдвигn»);vl[j]=18;break;
case 19: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=19;break;
case 20: z[z1]=7;v++;
printf(«tЗаменить(C1)tСдвигn»);vl[j]=20;break;
case 21: z[z1]=7;v++;
printf(«tЗаменить(C1)tСдвигn»);vl[j]=21;break;
case 22: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=22;break;
case 23: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=23;break;
case 24: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=24;break;
case 25: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=25;break;
case 26: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=26;break;
case 27: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=27;break;
case 28: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=28;break;
case 29: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=29;break;
case 30: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=30;break;
case 31: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=31;break;
case 32: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=32;break;
case 33: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=33;break;
case 34: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=34;break;
case 35: z[z1]=4;z1++;z[z1]=1;v++;
printf(«tЗаменить(В3,В)tСдвигn»);vl[j]=35;break;
case 36: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=36;break;
case 37: z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=37;break;
case 38: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=38;break;
case 39: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=39;break;
case 40: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=40;break;
case 41: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=41;break;
case 42: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=42;break;
case 43: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=43;break;
case 44: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=44;break;
case 45: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=45;break;
case 46: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=46;break;
case 47: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=47;break;
case 48: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=48;break;
case 49: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=49;break;
case 50: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=50;break;
case 51: z[z1]=4;z1++;z[z1]=1;v++;
printf(«tЗаменить(В3,В)tСдвигn»);vl[j]=51;break;
case 52: z[z1]=5;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’,В)tСдвигn»);vl[j]=52;break;
case 53: z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=53;break;
case 54: z[z1]=9;z1++;z[z1]=2;v++;
printf(«tЗаменить(S’,В1)tСдвигn»);vl[j]=54;break;
case 55: z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(S’,В2)tСдвигn»);vl[j]=55;break;
case 56: z[z1]=9;z1++;z[z1]=7;v++;
printf(«tЗаменить(S’,C1)tСдвигn»);vl[j]=56;break;
case 57: z[z1]=9;z1++;z[z1]=7;v++;
printf(«tЗаменить(S’,C1)tСдвигn»);vl[j]=57;break;
case 58: z[z1]=0;v++;
printf(«tЗаменить(S)tСдвигn»);vl[j]=58;break;
case 59: z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=59;break;
case 60: printf(«ДОПУСТИТЬn»);i=1;vl[j]=60;break;
case 0: printf(«Отвергнутьn»);i=2;vl[j]=0;break;
}
if(i==1|i==2)break;else j++;
}
while(tab[z[z1]][a[v]]!=0||tab[z[z1]][a[v]]!=60);
printf(«Выходная лента:n»);
for(k=0;k<=j;k++)
{
printf(«%d «,vl[k]);
}
return i;
};
/*————————————————————————-*/
/*—————————ТЕРМИНАЛЬНЫЕ СИМВОЛЫ—————————*/
int termin(char s)
{
char term[t]=’,’>’,'<‘,’=’,’n’,’!’,’/’,’*’,’:’,’?’,’%’,'(‘,’)’,’,’;
int k,di=0;
for(k=0;k<=t-1;k++)
{
if(s==term[k]||s==’d’||s==’i’||s==’v’||s==’m’||s==’o’||s==’r’||s==’a’||s==’n’)
{di=1;break;}
}
return di;
};
/*———————КОНЕЦ ТЕРМИНАЛЬНЫЕ СИМВОЛЫ—————————*/
/*————————ДЕСКРИПТОРНЫЙ текст———————————*/
int lexica()
{ int di(0),q(0),w(0),i1,i;
i=0;
printf(«Дескрипторный текст:n»);
do
{
di=termin(s1[i]);
if(di==1)
{
switch(s1[i])
{
case ‘(‘: a[w]=0;break;
case ‘)’: a[w]=1;break;
case ‘%’: if(s1[iactiveX{a[w]=27;i++;}else a[w]=6;break;
caseactiveXif(s1[i+1]==’=’){a[w]=23;i++;}else a[w]=7;break;
case ‘/’: if(s1[iactiveX{a[w]=26;i++;}else a[w]=8;break;
caseactiveXif(s1[i+1]==’=’){a[w]=16;i++;}else a[w]=22;break;
case ‘!’: if(s1[iactiveXa[w]=15;i++;break;
case ‘>’: if(s1[i+1]==’=’){a[w]=13;i++;}else a[w]=12;break;
case ‘<‘: if(s1[iactiveX{a[w]=14;i++;}else a[w]=11;break;
caseactiveXif(s1[i+1]==’+’){a[w]=4;i++;}else if(s1[i+1]==’=’){a[w]=24;i++;}else a[w]=9;break;
caseactiveXif(s1[i+1]==’-‘){a[w]=5;i++;}else if(s1[i+1]==’=’){a[w]=25;i++;}else a[w]=10;break;
case ‘&’: if(s1[i+1]==’&’)a[w]=18;i++;break;
case ‘|’: if(s1[i+1]==’|’)a[w]=17;i++;break;
case ‘,’: a[w]=21;break;
case ‘?’: a[w]=19;break;
case ‘:’: a[w]=20;break;
}
i++;
}
else
{
i1=i;
while(di!=1)
{
i++;
di=termin(s1[i]);
}
q=perem(i1,i-1);
if(q==1)a[w]=2;else {printf(«ERROR.nЛЕКСИЧЕСКАЯ ОШИБКА»);break;}
}
printf(«%d «,a[w]);
w++;
}
while(s1[i]!=’n’);
a[w]=28;
};
/*———————КОНЕЦ ДЕСКРИПТОРНОГО текста—————————*/
int lexica1()
{ int di(0),q(0),w(0),i1,i;
i=0;
printf(«Дескрипторный текст:n»);
do
{
di=termin(s1[i]);
if(di==1)
{
switch(s1[i])
{
case ‘(‘: a[w]=0;break;
case ‘)’: a[w]=1;break;
caseactiveXa[w]=6;break;
case ‘/’: a[w]=7;break;
caseactiveXa[w]=11;break;
case ‘>’: if(s1[i+1]==’=’){a[w]=15;i++;}else a[w]=14;break;
case ‘<‘: if(s1[iactiveX{a[w]=16;i++;}else a[w]=13;break;
caseactiveXa[w]=4;break;
case ‘-‘: a[w]=5;break;
case ‘,’: a[w]=3;break;
case ‘d’: if(s1[i+1]==’i’&&s1[i+2]==’v’)a[w]=8;i++;i++;break;
case ‘m’: if(s1[i+1]==’o’&&s1[i+2]==’d’)a[w]=9;i++;i++;break;
case ‘a’: if(s1[i+1]==’n’&&s1[i+2]==’d’)a[w]=10;i++;i++;break;
case ‘o’: if(s1[i+1]==’r’)a[w]=17;i++;break;
}
i++;
}
else
{
i1=i;
while(di!=1)
{
i++;
di=termin(s1[i]);
}
q=perem(i1,i-1);
if(q==1)a[w]=2;else
{printf(«ERROR.nЛЕКСИЧЕСКАЯ ОШИБКА»);break;}
}
printf(«%d «,a[w]);
w++;
}
while(s1[i]!=’n’);
a[w]=18;
};
int analiz1()
{
int z[10],v,z1,i(0),j,k;
int tab[12][19]={{36,0,35,0,33,34,0,0,0,0,0,0,0,0,0,0,0,0,0},
{4,0,3,0,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,11,0,11,0,0,0,0,0,0,0,5,8,6,7,9,10,0,11},
{26,0,25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,32,0,32,32,32,27,28,29,30,31,32,32,32,32,32,32,32,32},
{21,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{22,23,0,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23},
{0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{15,0,14,0,12,13,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,19,0,19,16,17,0,0,0,0,0,19,19,19,19,19,19,18,19},
{0,38,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,38},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,39}};
printf(«n»);
z1=0;
z[z1]=11;z1++;z[z1]=1;
v=0;j=0;
do
{
switch(tab[z[z1]][a[v]])
{
case 1: z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(В’П’C)tСдвигn»);vl[j]=1;break;
case 2: z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(В’П’C)tСдвигn»);vl[j]=2;break;
case 3: z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=4;z1++;z[z1]=6;v++;
printf(«tЗаменить(В’П’C’M’)tСдвигn»);vl[j]=3;break;
case 4: z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=4;z1++;z[z1]=7;z1++;z[z1]=1;v++;
printf(«tЗаменить(В’П’C’M1,B)tСдвигn»);vl[j]=4;break;
case 5: z[z1]=8;v++;
printf(«tЗаменить(П)tСдвигn»);vl[j]=5;break;
case 6: z[z1]=8;v++;
printf(«tЗаменить(П)tСдвигn»);vl[j]=6;break;
case 7: z[z1]=8;v++;
printf(«tЗаменить(П)tСдвигn»);vl[j]=7;break;
case 8: z[z1]=8;v++;
printf(«tЗаменить(П)tСдвигn»);vl[j]=8;break;
case 9: z[z1]=8;v++;
printf(«tЗаменить(П)tСдвигn»);vl[j]=9;break;
case 10:z[z1]=8;v++;
printf(«tЗаменить(П)tСдвигn»);vl[j]=10;break;
case 11:z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=11;break;
case 12:z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(П’C)tСдвигn»);vl[j]=12;break;
case 13:z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(П’C)tСдвигn»);vl[j]=13;break;
case 14:z[z1]=9;z1++;z[z1]=4;z1++;z[z1]=6;v++;
printf(«tЗаменить(П’C’M’)tСдвигn»);vl[j]=14;break;
case 15:z[z1]=9;z1++;z[z1]=4;z1++;z[z1]=7;v++;
printf(«tЗаменить(П’C’M1,B)tСдвигn»);vl[j]=15;break;
case 16:z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(П’C)tСдвигn»);vl[j]=16;break;
case 17:z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(П’C)tСдвигn»);vl[j]=17;break;
case 18:z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(П’C)tСдвигn»);vl[j]=18;break;
case 19:z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=19;break;
case 20:z[z1]=6;v++;
printf(«tЗаменить(M’)tСдвигn»);vl[j]=20;break;
case 21:z[z1]=7;z1++;z[z1]=1;v++;
printf(«tЗаменить(M1,B)tСдвигn»);vl[j]=21;break;
case 22:z[z1]=7;z1++;z[z1]=0;v++;
printf(«tЗаменить(M1,S)tСдвигn»);vl[j]=22;break;
case 23:z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=23;break;
case 24:z1—;v++;
printf(«tВытолкнутьtСдвигn»);vl[j]=24;break;
case 25:z[z1]=4;z1++;z[z1]=6;v++;
printf(«tЗаменить(C’M’)tСдвигn»);vl[j]=25;break;
case 26:z[z1]=4;z1++;z[z1]=6;z1++;z[z1]=1;v++;
printf(«tЗаменить(C’M’B)tСдвигn»);vl[j]=26;break;
case 27:z[z1]=4;z1++;z[z1]=6;v++;
printf(«tЗаменить(C’M’)tСдвигn»);vl[j]=27;break;
case 28:z[z1]=4;z1++;z[z1]=6;v++;
printf(«tЗаменить(C’M’)tСдвигn»);vl[j]=28;break;
case 29:z[z1]=4;z1++;z[z1]=5;v++;
printf(«tЗаменить(C’M)tСдвигn»);vl[j]=29;break;
case 30:z[z1]=4;z1++;z[z1]=5;v++;
printf(«tЗаменить(C’M)tСдвигn»);vl[j]=30;break;
case 31:z[z1]=4;z1++;z[z1]=5;v++;
printf(«tЗаменить(C’M)tСдвигn»);vl[j]=31;break;
case 32:z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=32;break;
case 33:z[z1]=10;z1++;z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(S’B’П’С)tСдвигn»);vl[j]=33;break;
case 34:z[z1]=10;z1++;z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=3;v++;
printf(«tЗаменить(S’B’П’С)tСдвигn»);vl[j]=34;break;
case 35:z[z1]=10;z1++;z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=4;z1++;z[z1]=6;v++;
printf(«tЗаменить(S’B’П’С’M’)tСдвигn»);vl[j]=35;break;
case 36:z[z1]=2;z1++;z[z1]=9;z1++;z[z1]=4;z1++;z[z1]=7;z1++;z[z1]=1;v++;
printf(«tЗаменить(B’П’С’M1,B)tСдвигn»);vl[j]=36;break;
case 37:z[z1]=0;v++;
printf(«tЗаменить(S)tСдвигn»);vl[j]=37;break;
case 38:z1—;
printf(«tВытолкнутьtДержатьn»);vl[j]=38;break;
case 39: printf(«ДОПУСТИТЬn»);i=1;vl[j]=39;break;
case 0: printf(«Отвергнутьn»);i=2;vl[j]=0;break;
}
if(i==1|i==2)break;else j++;
}
while(tab[z[z1]][a[v]]!=0||tab[z[z1]][a[v]]!=39);
printf(«Выходная лента:n»);
for(k=0;k<=j;k++)
{
printf(«%d «,vl[k]);
}
return i;
};
/*—————————УДАЛЕНИЕ ПРОБЕЛОВ—————————————*/
/*int probel()
{
int i(0),k(0);
for(i=0;i<=j-1;i++)
{
if(s[i]!=’ ‘){s1[k]=s[i];k++;}
}
j=k;
};*/
/*————————————————————————-*/
int main()
{
int w,i;
clrscr();
//probel();
y=vvod();
w=0;
a[w]=0;
if(y==1)
{lexica();
i=analiz();}
if(y==2)
{
lexica1();
i=analiz1();
}
getch();
return 0;
}
]]>