Сертификат "Разработка компиляторов"
  • Сертификат "Разработка компиляторов"
  • Сертификат "Разработка компиляторов"
Сертификат "Разработка компиляторов"
  • Сертификат "Разработка компиляторов"
  • Сертификат "Разработка компиляторов"

Разработка компиляторов

700,00 руб.
В течение часа!
Экзамен "Разработка компиляторов" для пользователей и системных администраторов.
Количество
Есть в наличии!

Форма сдачи теста: Экстерн
Количество вопросов: 30
Проходной балл: 90% и выше
Срок действия сертификата: неограничен

Сертификат появляется в профиле ресурса INTUIT, и Вы можете заказать его бумажную версию на сайте INTUIT.
11853 шт.
Внимание !
Вопросы к тесту выложены исключительно в ознакомительных целях: количество вопросов может не совпадать с действительным, актуальность не поддерживается,- за решением теста Welcome to the cashier!

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

SIL
IL
Microsoft Intermediate Language
MSIL


Во время трансляции в .NET промежуточное представление не интерпретируется, а вместо этого используется механизм:

трансляции времени исполнения, который не генерирует машинный код
компиляции времени исполнения, который не генерирует машинный код
компиляции времени исполнения, который генерирует машинный код
трансляции времени исполнения, который генерирует машинный код


Когда появилась платформа .NET?

2000 году
1999 году
2001 году
2002 году


С помощью какого механизма в .NET происходит обработка ошибок?

исключительных ситуаций
внутренней верификации
встроенной верификации
исключительных событий


При создании .NET основной упор был сделан на следующие языки:

Java-подобные
C++-подобные
Pascal-подобные
Lisp-подобные
Perl-подобные


В .NET все сервисы, предоставляемые программисту платформой, оформлены в виде:

единой иерархии типов
единой иерархии классов
единой иерархии объектов
единой иерархии блоков


Извлечение из MSIL исходных текстов путем дизассемблированя вряд ли имеет смысл, так как имена локальных переменных, констант и параметров сохраняются только:

в тестовой версии
в программной версии
в буферной версии
в отладочной версии


Существуют следующие версии MSIL:

для мобильных 16-разрядных устройств
стандартная 32-разрядная версия
специальная версия для работы с 64-разрядными устройствами
для мобильных 8-разрядных устройств


Основные сервисы .NET сосредоточены в пространстве имен:

Services
Object
System
Class


В .NET единая модель объектов распространяется сразу на:

все языки программирования
все платформы
все средства разрботки приложений
все операционные системы


В единой объектно-ориентированная модель классов .NET которой все классы унаследованы от:

базового класса Type
базового класса System
базового класса Object
базового класса Block


В первом приближении сборка - это:

аналог DLL
аналог COM
аналог EXE
аналог BAT


Для того чтобы сборки действительно были независимыми от системы и от других сборок, необходимо, чтобы они сопровождались явным описанием:

предоставляемых ими сервисов
зависимостей от внешнего мира
системных зависимостей


Причиной появления понятия сборки можно считать:

комплексность установки Windows-приложений
многоэтапность установки Windows-приложений
простоту установки Windows-приложений
трудности установки Windows-приложений


Манифест: описание сборки позволяет:

открыть потребителю детали реализации
ничего не скрывать от потребителя
все скрыть от потребителя
скрыть от потребителя детали реализации


Каждая сборка имеет уникальное имя, которое состоит из следующих частей:

префикса
информации о локализации
простого текстового имени
номера версии


Общие сборки сопровождаются номером версии в следующем формате:

incompatible.hotfix
compatible.hotfix
incompatible.compatible.path
incompatible.compatible.hotfix


Поддерживает ли .NET удаленный вызов объектов?

Нет
Да
Да, только в Linux


Моделями обеспечения безопасности в .NET являются:

модель прав
модель политик доступа
модель ролей
модель полномочий
модель ограничений


Типами проверок безопасности в .NET являются:

императивная безопасность
декларативная безопасность
общая безопасность
подлинность кода
разрешения на доступ к ресурсам
безопасность типов


Какие типы данных являются основными в системе типов данных .NET:

объектные типы
типы-значения
интерфейсные типы
ссылочные типы


В Common Type System все типы делятся на следующие категории:

специальные типы
примитивные типы, типы-значения и ссылочные типы
объектные и интерфейсные типы
блочные и системные типы



В С# возможно определение:
string s = "Hello C#";
под которым подразумевается следующее присваивание:

System.String s = .String();
s = "Hello C#";

System.String s = new System.String();
s = "Hello C#";

System.String = System.String();
s = "Hello C#";

.String s = new System.String();
s = "Hello C#";


Полный набор примитивных типов .NET поддерживает:

Java
C++
C#
C


Типы данных, напрямую поддержанные компилятором и допускающие определенные сокращения записи - это:

блочные типы
системные типы
примитивные типы
ссылочные типы


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

структуры
эффективности
модульности
переносимости


В C# ссылочные типы можно создать так:

class RectRef {public int x, y, cx, cy; }
class.RectRef {public.int x, y, cx, cy; }
class {public int x, y, cx, cy; }
class RectRef { x, y, cx, cy; }
RectRef {public int x, y, cx, cy; }
class { x, y, cx, cy; }


Для типа-значения верно:

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


При создании ссылочные типы инициализируются значением:

1
true
null
false


В ходе распаковки проверяется, что исходная ссылочная переменная:

не равняется 1
равняется null
не равняется null
не равняется 1
не равняется false
не равняется true


В следующем примере:

ArrayList a = new ArrayList();
for (int i=0; i < 10; i++) {
  Point p;
  p.x = p.y = i;
  a.Add(p);
}

мы добавляем тип-значение:

в секцию
в блок
в массив
в коллекцию


Процесс преобразования типа-значения в ссылочный тип называется:

распаковкой
дешифованием
упаковкой
шифрованием


Языки программирования C# или Visual Basic.NET, поддерживают операции упаковки и распаковки:

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


В данном примере:

public static void Main() {
  Int32 v = 5;
  Object o = v;
  v = 123;


  Console.WriteLine (v + ", " + (Int32) o);
}

операция упаковки производится:

3 раза
2 раза
1 раз
0 раз


Для языка C# верны следующие утверждения:

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


Fall-through в C# - это:

проблема "провала"
проблема компиляции
ветка
переполнение
неявные преобразования
наследование


Упрощение языка C# выразилось в:

запрещении множественного наследования
запрете прямой манипуляции памятью
более строгих правилах преобрзования типовв
отказе от провала в следующую ветку в switch


Все ссылочные типы произведены от базового типа object, являющегося точным эквивалентом класса:

System.Object
System.Link
Object.Goto
System.Object.Links


В C# значениям переменных булевского типа:

не соответствует никаких численных эквивалентов
соответствуют специальные численные эквиваленты
соответствуют численные эквиваленты


C# поддерживает структурную обработку исключений с помощью конструкций:

foreach
finally
catch
try


Ссылочными типами в C# являются:

Массивы
представители
интерфейсы
object
class
string


В C# имеются следующие модификаторы:

типов
доступа
элементов класса
стека
секций
класса


Классы в C# предоставляют следующие возможности:

свойства и доступ к ним
события и представители
конструкторы/деструкторы
индексаторы
интерпретаторы
методы классов и их параметры
модификаторы доступа


Все активные действия программ на C# выполняются:

в методах объектов
в методах секций
в методах классов
в методах блоков


Корректными примерами конструкторов являются следующие:


public Matrix()
{
   for (int i=0; i<n; i++)
      for (int j=0; j<n; j++)
         elements[i,j] = 0;
}

public Matrix (val)
{
   for ( i=0; i<n; i++)
      for (int j=0; j<n; j++)
         elements[i];
}

public Matrix (int val)
{
   for (int i=0; i<n; i++)
      for (int j=0; j<n; j++)
         elements[i,j] = val;
}


Проверку допустимости присваиваемого значения можно провести с помощью следующего кода:

Hashtable ziphash = new Hashtable();
...
foreach (string zip in ziphash.Keys)
{
   Console.WriteLine(zip + "          " + ziphash[zip]);
}


private int m_AgeOfClient;
public int AgeOfClient {
   get { if (AccessToPersonalInfoAllowed()) return m_AgeOfClient; }
   set { if (value > 0 && value <= 120)
             m_AgeOfClient = value;
         else
             MessageBox.Show("This client is not recommended for insurance");
       }
}


private int m_stateOfVeryCriticalResource;
public int stateOfVeryCriticalResource {
  get { if (IsAllowedUser())
           return m_stateOfVeryCriticalResource; }
  set { if (IsAdmin())
           m_stateOfVeryCriticalResource = value; }
}
...
stateOfVeryCriticalResource = vcrCompletelyScrewedUp; 
В данном примере:

using System;
public delegate void EventHandler (string strText);
class EventSource {
  public event EventHandler TextOut;
  public void TriggerEvent() {
    if (TextOut != null) TextOut("Event triggered..."); }
}
class TestApp {
  public static void Main() {
    EventSource evsrc = new EventSource();
    evsrc.TextOut += new EventHandler(CatchEvent);  evsrc.TriggerEvent();
    evsrc.TextOut -= new EventHandler(CatchEvent);  evsrc.TriggerEvent();
    TestApp theApp = new TestApp();
    evsrc.TextOut += new EventHandler(theApp.InstanceCatch);
    evsrc.TriggerEvent();
  }
public static void CatchEvent(string strText) { WriteLine(strText); }
public void InstanceCatch(string strText) { WriteLine("Instance "+strText); }

происходят:

обработка события с помощью зарегистрированного обработчика
подписка на событие
получение события
отказ от дальнейшей обработки события


При таком описании класса:

public class Matrix
{
    public const int n = 10;
    public int[,] elements = new int[n,n];

    public int this[int i, int j]
    {
        get { return elements[i,j]; }
        set { elements[i,j] = value; }
    }
}

допустимо следующее использование:

b[0,0] = -4; b[1,5] = 10;
Matrix b = new Matrix();
Matrix a = new Matrix();
a[0,0] = 1; a[1,5] = 5;


Модификаторами класса в C# являются:

const
sealed
abstract
public


Данный пример:

private int m_stateOfVeryCriticalResource;
public int stateOfVeryCriticalResource {
  get { if (IsAllowedUser())
           return m_stateOfVeryCriticalResource; }
  set { if (IsAdmin())
           m_stateOfVeryCriticalResource = value; }
}
...
stateOfVeryCriticalResource = vcrCompletelyScrewedUp;

позволяет проверить достаточность полномочий запрашивающего приложения:

для доступа к данному полю
для доступа к данной строке
для доступа к данному классу
для доступа к данному объекту


Для реализации модели "публикация/подписка" в C# используются:

представители
модификаторы
события
индексаторы


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

присваивание
индексирование
перегрузка операторов
упорядочивание операторов


В данном случае:int v2 = v1; происходит:

приведение переменной v1 к типу int
явное приведение переменной v1 к типу int
неявное приведение переменной v1 к типу int
сопоставление переменной v1 с типом int


Для params верно:

быть первым параметром
не должен сопровождаться типом параметров
должен сопровождаться типом параметров
быть последним параметром


В C# есть специальное ключевое слово params, которое позволяет:

задать целый список параметров
задать целый список значений
задать целый список атрибутов
задать целый список объектов


Из привычного набора макросов в препроцесоре C# оставлены следующие:

механизм условной компиляции, основанный на директивах #if, #else, #endif
#define и #undef для определения идентификаторов и отмены определения
генерация предупреждений и ошибок с помощью макросов #warning и #error


В C# механизм условной компиляции, основан на директивах:

#warning,#error
#if,#else,#endif
#define,#undef


Для препроцессор C# верны следующие утверждения:

в C# запрещены подстановки текста
реализован механизм #if DEBUG… #else … #endif
реализована генерация ошибок и предупреждений
#define, #undef служат для определения/отмены идентификаторов


Атрибуты в C# представляют собой:

"примечания" к параметрам методов исходного текста программы
"примечания" к элементам исходного текста программы
"примечания" к методам исходного текста программы
"примечания" к классам исходного текста программы


В C# информация, записанная в атрибутах, во время компиляции:

сохраняется в специальном блоке
сохраняется в метаданных программы
не сохраняется в метаданных программы
теряется


Для того, чтобы определить собственные, пользовательские атрибуты достаточно создать класс, унаследованный от:

Users.Attribute
New.Attribute
Special.Attribute
System.Attribute


Для написания опасного кода необходимо пометить метод или блок ключевым словом:

fixed
safe
unsafe
undef


Информация, записанная в пользовательских атрибутах, может быть использована во время исполнения программы с помощью:

механизма упаковки
механизма рефлексии
механизма распаковки
механизма перезагрузки операторов


Какие механизмы реализованы в C#:

исключения
контроль версий
межъязыковая разработка и отладка
работа с переполнением


Какие механизмы реализованы в C#:

межъязыковая разработка и отладка
работа с переполнением
контроль версий
исключения


Отключить контроль переполнения можно с помощью ключевого слова:

unchecked
unsafe
syscontrol
control
checked
fixed


Из типов данных язык Cи-бемоль поддерживает следующие:

одномерные массивы
встроенные типы
интерфейсы
классы
тип данных "множество"
многомерные массивы


Из управляющих конструкций в языке Cи-бемоль допускаются:

do-while
вызовы
if-then-else
repeat-until
присваивания
while-do


Язык Cи-бемоль был разработан:

путем усечения C++
путем усечения C#
путем дополнения C++
путем дополнения C#


Трансляторы бывают следующих типов:

analysis
compiler
synthesis
interpreter


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

begin
analysis
synthesis
interpreter


Если оператор языка ассемблера отображается при трансляции чаще всего в одну машинную инструкцию, предложения языков более высокого уровня отображаются

в несколько машинных инструкций
в произвольную машинную инструкцию
в пустую машинную инструкцию
в одну машинную инструкцию


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

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


Цепочка символов, составляющая исходную программу на языке программирования является:

процессом компиляции
процессом интерпретации
входом компилятора
выходом компилятора


Можно сказать, что результатом работы интерпретатора является:

"программа"
"число"
"исполняемый файл"
"код"


Крайне важной частью процесса трансляции является:

исправление ошибок, допущенных во входной программе
точная диагностика ошибок, допущенных во входной программе
игнорирование ошибок, допущенных во входной программе


Создание единого перемещаемого объектного сегмента из набора различных сегментов осуществляется программой, которая называется:

редактором сегментов
редактором связей
редактором объектов
редактором наборов


Объектная программа может быть:

программой на некотором другом языке
последовательностью абсолютных машинных команд
последовательностью перемещаемых машинных команд
программой на языке ассемблера


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

S-диаграммы
T-диаграммы
R-диаграммы
P-диаграммы
D-диаграммы
E-диаграммы


Преимуществами трансляции в ассамблер являются:

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


Подход при котором применяется трансляция программы в ассемблер:

усложняет конструирование компилятора
удлиняет технологическую цепочку выполнения программы
сокращает технологическую цепочку выполнения программы
упрощает конструирование компилятора


Написание компилятора может потребоваться в следующих условиях:

при создании новой компьютерной архитектуры
для целевых платформ
для различных языков


Методиками разработки компиляторов являются следующие:

метод раскрутки
компиляция "на лету"
метод генерации
использование кросс-трансляторов
использование виртуальных машин


Для того, чтобы справиться с проблемой большой потери времени при написании и отладке компилятора на языке ассемблера был разработан:

метод генерации
метод распаковки
метод упаковки
метод раскрутки


Компиляторы генерирующие объектную программу на языке более высокого уровня, чем язык ассемблера называют:

исполнителями
конвертерами
кросс-компиляторами
генераторами


Под переносимой (portable) программой понимается программа, которая:

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


Сегодня идея виртуальных машин приобрела широкую известность благодаря языку:

C++
Fortran
C
Java


Компиляторы языка Java генерируют:

бит-код
объектный код
байт-код


Одна из первых широко известных виртуальных машин была разработана в 70-х годах Н. Виртом:

при написании компилятора Pascal-P
при написании компилятора Simula
при написании компилятора Pascal
при написании компилятора Simula-P


Для того, чтобы увеличить скорость работы приложений, была разработана технология:

Just compiling
Just-In-Time compiling
Fats compiling
compiling


Процесс создания компилятора можно свести к решению нескольких задач, которые принято называть:

compilation steps
compilation phases
compilation stages
compilation rounds


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

"компилятор+интерпретатор+JIT-компилятор+интепретатор"
"интерпретатор+JIT-компилятор"
"компилятор+интерпретатор"
"компилятор+интерпретатор+JIT-компилятор"


Обычно компилятор состоит из следующих фаз:

видозависимый анализ
генерация кода
лексический анализ
синтаксический анализ
оптимизация


На этапе лексического анализа обычно выполняются такие действия, как:

обработка директив условной компиляции
игнорирование комментариев
обработка операторов
удаление комментариев


В разборе входной цепочки и выделении некоторых более "крупных" единиц, которые удобнее для последующего разбора заключается задача:

фазы видозависимого анализа
фазы генерации кода
фазы синтаксического анализа
фазы лексического анализа


В дереве разбора программы внутренние узлы соответствуют:

операциям
операндам
подклассам
классам


После синтаксического анализа можно считать, что исходная программа преобразована:

в некоторое промежуточное представление
в объектное представление
в некоторое промежуточное состояние
в исполняемый файл


Видозависимый анализ иногда называют:

syntax analysis
code optimization
semantic analysis
lexical analysis


На этапе генерации кода необходимо решить множество следующих сопутствующих проблем:

распределение блоков
распределение регистров
распределение памяти
распределение стеков


Обязательность описания переменных может служить примером:

временных условий
предварительных условий
дополнительных условий
контекстных условий


Наиболее распространенными оптимизациями являются:

уменьшение силы операций
константные вычисления
выделение общих подвыражений
чистка циклов


Backpatching - это:

тестирование программы
техника "заплат"
внешний интерфейс
внутренний интерфейс


Какие фазы иногда объединяют вместе под названием front-end?

видозависимый анализ
некоторые оптимизации
лексический анализ
синтаксический анализ


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

audit
analysis
passes
control


Получение любого предложения языка в грамматике начинается с этого:

специальный символ
теорема
аксиому
начальный символ


Грамматики представляют собой:

наиболее распространенный блок описаний языков
наименее распространенный блок описаний языков
наиболее распространенный класс описаний языков
наименее распространенный класс описаний языков


В формальном определении грамматики нетерминалы обозначаются:

прописными буквами
строчными буквами
пустой строкой


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

в виртуальной машине
в трансляторе
в интерпретаторе
в компиляторе


Определение грамматик не накладывает никаких ограничений на количество:

пустых строк в левой части правил
терминалов в левой части правил
нетерминалов в левой части правил


Различные грамматики могут порождать:

один и тот же язык
эквивалентные языки
различные языки


Согласно иерархии Хомского, если любое правило из P имеет вид A->a, где A - нетерминал, a - нетерминал или терминал то грамматика G называется:

праволинейной
бесконтекстной
контекстно-зависимой
контекстно-свободной
неукорачивающей
выровненной вправо


Согласно иерархии Хомского, если любое правило из P имеет вид A->xB или A->x, где A, B - нетерминалы, а x - терминал, то грамматика G называется:

выровненной вправо
без ограничений
бесконтекстной
праволинейной


Иерархия Хомского - это классификация грамматик согласно:

их внешнему виду
их времени появления
их внутренней структуре
их принципов создания


В качестве примеров распознавателей можно назвать:

конечные автоматы
бесконечные автоматы
машину Тьюринга
магазинные автоматы


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

грамматика
виртуальная машина
язык
лексема


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

распознаватель
интерпретатор
определитель


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

завершается в состоянии перехода
завершается в начальном состоянии
завершается в заключительном состоянии
завершается в состоянии распознавания


Основная часть конечного автомата - это:

функция распознавания
функция определения
функция остановки
функция перехода


Язык распознается конечным автоматом, если:

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


Следующий набросок программы:

q = q0;
c = GetChar();
while (c != eof) {
  q = move (q, c);
  c = GetChar();
}
if (q is in F) return "yes";
else return "no";
 

демонстрирует (предполагается, что входная лента заканчивается символом end_of_file):

моделирование конечного автомата
моделирование магазинного автомата
моделирование бесконечного автомата
моделирование машины Тьюринга


Удобная форма записи конечных автоматов – это:

дерево переходов
графы переходов
диаграммы переходов
графики переходов


Если мы предположим, что начальные состояния конечных автоматов эквивалентны, то мы можем получить:

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

Внимание !
Вопросы к тесту выложены исключительно в ознакомительных целях: количество вопросов может не совпадать с действительным, актуальность не поддерживается,- за решением теста Welcome to the cashier!

Классы языков, определяемых праволинейной грамматикой являются:

формализмами
эквивалентными
не эквивалентными


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

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


Два детерминированных автомата называются эквивалентными, если они:

распознают один и тот же язык
распознают специальные языки
распознают определенное множество языков
распознают один язык


Любая КС-грамматика может быть приведена к нормальному виду Хомского, в котором все правила имеют один из следующих видов:

A->BC, где А, B и C - нетерминалы
AB->a, где a - терминал
A->a, где a - терминал
BC->A, где А, B и C - нетерминалы


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

трансляции
интерпретации
компиляции


Если существует, по крайней мере, одна выводимая в грамматике цепочка, для которой существует более одного вывода, то такая грамматика является:

неоднозначной
произвольной
естественной
однозначной


Магазинные автоматы, известны также как:

автоматы с магазинной памятью
МП-автоматы
МА-автоматы


На каждом шаге работы МП-автомат может либо:

снять какие-то значения с его вершины
удалить вершину
занести что-то в магазин
удалить магазин


В нормальной форме Грейбах все правые части правил начинаются:

с инструкций
с нетерминалов
с формул
с терминалов


МП-автоматы обладают одним существенным недостатком:

они детерминированны по своей природе
они имеют простую структуру
они недетерминированны по своей природе
они имеют сложную структуру


Форма Бэкуса-Наура был разработана для описания:

Паскаля
Кобола
Фортрана
Алгола-60


Детерминированные МП-автоматы описывают только подмножество всего класса КС-языков - это подмножество называется:

недетерминированными языками
недетерминированными КС-языками
детерминированными КС-языками
детерминированными языками


При определении синтаксиса языков Pascal и Modula-2 Вирт использовал расширенную форму Бэкуса-Наура (EBNF):

символ равенства используется вместо символа ::=
нетерминалы записываются как отдельные слова
комментарии заключаются между символами (* … *)
символ точка используется для обозначения конца правила


Синтаксические диаграммы или синтаксические схемы имеют форму:

прямоугольников
квадратов
блок-схем
блоков



Следующее правило:

REF to MODE NEST assignation:
REF to MODE NEST destination, becomes token,
MODE NEST source.

определяет:

присваивание
цикл с постусловием
массив
цикл с предусловием


Одна из первых задач, возникающих в процессе компиляции - это:

определение рассматриваемого языка программирования
определение типа необходимого лексического анализа
определение типа рассматриваемого языка программирования
определение типа необходимого семантического анализа


Идея создания некоторого обобщенного алгоритма, проверяющего за конечное число шагов принадлежность данной цепочки языку является альтернативой:

механизму анализа на входе
механизму видозависимого анализа
механизму грамматик
механизму интерпретации


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

простыми
разными
одинаковыми
сложными


Во время лексического анализа программа разбивается на:

последовательность строк
последовательность секций
блоки
лексемы


Множество лексем разбивается:

на непересекающиеся подмножества
на пересекающиеся подмножества
на специальные классы
на лексические классы


В следующем операторе языка Pascalconst pi = 3.1416;"pi" представляет лексический класс:

Semicolon_LC
Identifier_LC
Const_LC
Number_LC


В следующем операторе языка Pascalconst pi = 3.1416;";" представляет лексический класс:

Number_LC
Identifier_LC
Semicolon_LC
Relation_LC
Const_LC


В большинстве языков программирования имеются следующие лексические классы:

Идентификаторы
строковые литералы
числовые константы
ключевые слова


Какие особенности некоторых языков могут существенно затруднять лексический анализ:

трактовка пробела как незначащего символа
использование ключевых слов как идентификаторов
фиксированный формат программы


Основной тенденцией современных языков программирования является:

закрытое размещение текста программы
открытое размещение текста программы
свободное размещение текста программы


В Алголе 68 и Фортране, пробелы являются значащими только:

в структурах
в массивах
в логических значениях
в строковых литералах


Если определен тип, соответствующий указателю в эту таблицу - ReprInd, и тип, служащий для представления позиции в исходном файле - FilePos, то можно полностью определить лексему следующим образом:

struct LEXEME {
   ReprInd ReprTabPtr;
   FilePos beg;
   FilePos end;
}


struct LEXEME {
   ushort LexClass;
   ReprInd ReprTabPtr;
   FilePos beg;
   FilePos end;
}

struct LEXEME {
   ushort LexClass;
   ReprInd ReprTabPtr;
   FilePos beg;
   FilePos end;
   FilePos out;
}


struct LEXEME {
   ushort LexClass;
   ReprInd ReprTabPtr;
   FilePos beg;
}


Простейший вид таблицы представлений – это:

массив указателей на числа
массив указателей на строки
массив указателей на символы
массив указателей на индексы


Какой специальный класс содержит система классов .NET, с помощью которого легко реализовать функциональность хэш-таблиц:

HashTable
TableFunc
TableHash
Hash


Для настройки хэш-таблицы на необходимый тип данных нужно реализовать методы:

Equals
GetHashCode
HashFunc
GetHash


На практике чаще используется эквивалентный праволинейным грамматикам механизм:

хэш-массивов
встроенных анализаторов
хэш-функций
регулярных выражений


Для любых регулярных выражений P и Q следующие множества также являются регулярными выражениями:

P+Q
PQ
P|Q
P-Q


Пустое множество и множество, состоящее только из пустой строки, являются:

хэш-функцией
таблицами представлений
регулярными выражениями


Lex, состоит из:

Lex-компилятора
Lex-языка
Lex-транслятора
Lex-интерпретатора


Спецификации лексического анализатора на языке Lex подготавливаются в виде программы:

lex.1x
lex
lex.l
.lex


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

стандартный анализатор вручную
семантический анализатор вручную
синтаксический анализатор вручную
лексический анализатор вручную


В Lex действия, связанные с реакцией на встреченные регулярные выражения, пишутся непосредственно на:

C++
Pascal
C#
C


Большинство средств для создания лексических анализаторов основывается:

на таблицах представлений
на хэш-функциях
на специальных функциях
на регулярных выражениях


Общая схема работы Lex заключается в преобразовании Lex-программы:

в открытую программу на целевом языке
в объектную программу на целевом языке
в исходный код
в регулярные выражения


В Lex-программе секция описаний включает:

Констант
определения макросимволов
регулярных определений
описания переменных


В Lex-программе функция yywrap() определяет:

что делать при достижении автоматом конца входного файла
что делать при достижении автоматом конца выходного файла
что делать при достижении автоматом конца инструкции
что делать при достижении автоматом конца строки


Lex-программа состоит из следующих частей:

Процедур
правил трансляции
методов
описаний


В регулярных выражениях в Lex-программе допустимы следующие способы кодирования символа а:

a
/a
"a"
\a


Следующая грамматика регулярного выражения:<p><p> в Lex-программе обозначает:

конкатенацию
любое из выражений
фрагмент в начале строки
фрагмент в конце строки
повторение m раз
необязательный фрагмент


В регулярных выражениях в Lex-программе специальные символы записываются после префикса:

"$"
"/"
"\"
"#"


В Lex-программе регулярному выражению< соответствует следующий лексический класс:

if_LC
relop_LC
else_LC
Identifier_LC


В Lex'е вернуть последние n символов цепочки обратно во входной поток можно с помощью:

yyunput(c)
yyleng
yytext
yyless(n)


В Lex'е указателем на отождествленную цепочку символов, оканчивающуюся нулем является:

yymore()
yylval
yyleng
yytext


При лексическом анализе программ на C# после прочтения символа > необходимо прочитать:

специальные символы
последующие символы
предыдущие символы


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

Text
Match
RegularExpressions
Regex


Процесс замены идентификаторов на ссылку в таблицу представлений называется:

подменой
подстановкой
разветыванием
свертыванием


Сколько атрибутов обычно имеет лексема:

0
3
2
1


В данном примере:

void DumpHrefs(String inputString)
{
  Regex r;
  Match m;
  r = new Regex("href\\s*=\\s*(?:\"(?<1>[^\"]*)\"|(?<1>\\S+))",  
     RegexOptions.IgnoreCase|RegexOptions.Compiled);
  for (m = r.Match(inputString); m.Success; m = m.NextMatch())
  {
    Console.WriteLine("Found href " + m.Groups[1] + " at "
    + m.Groups[1].Index);
  }
}

класс Regex:

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


Наиболее удобным формализмом для описания синтаксических конструкций языка программирования являются:

контекстно-свободные
праволинейные
бесконтекстные
контекстно-зависимые


Компиляторы, разработанные на базе грамматик:

не могут быть достаточно легко расширены
не могут быть расширены
могут быть легко расширены
могут быть расширены


Грамматики представляют собой мощный формализм:

определения языков программирования
написания языков программирования
описания языков программирования


Анализаторы реально используемых языков обычно имеют:

контекстную сложность
сложность построения
системную сложность
линейную сложность
квадратную сложность


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

семантический анализ
видозависимый анализ
синтаксический анализ
лексический анализ


Если программа выводима в грамматике, это еще не означает, что она полностью:

семантически правильна
синтаксически правильна
лексически правильна


Дерево разбора и таблицы - это:

выход семантического анализатора
вход семантического анализатора
выход синтаксического анализатора
вход синтаксического анализатора


Синтаксический анализатор обращается к лексическому анализатору каждый раз, когда у него появляется потребность:

в очередном операнде
в очередном терминальном символе
в пустой строке
в очередном нетерминальном символе
в очередном операторе


Большинство методов анализа принадлежит к следующим классам:

линейные анализаторы
нисходящие анализаторы
нелинейные анализаторы
восходящие анализаторы


В узлах синтаксического дерева листьями являются:

терминальные символы
нетерминальные символы
аксиомы грамматики
пустые строки


В узлах синтаксического дерева листьями являются:

нетерминальные символы
аксиомы грамматики
терминальные символы


В узлах синтаксического дерева корнем являются:

нетерминальные символы
аксиомы грамматики
терминальные символы
пустые строки


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

в left-down алгоритмах
в top-down алгоритмах
в bottom-down алгоритмах
в right-down алгоритмах


LL-грамматики обладают следующими свойствами:

они могут быть проанализированы без возвратов
первая буква L означает, что мы просматриваем входную цепочку слева направо
они не могут быть проанализированы без возвратов
вторая буква L означает, что строится левый вывод цепочким


От листьев к корню узлы синтаксического дерева строятся:

в top-down алгоритмах
в left-down алгоритмах
в right-down алгоритмах
в bottom-down алгоритмах


Одним из наиболее популярных методов нисходящего синтаксического анализа является:

recursive method
recursive top-down method
descent method
recursive descent method


С помощью каких грамматик можно определить большинство использующихся в настоящее время языков программирования?

LR-грамматики
LT-грамматики
LN-грамматики
LL-грамматики


С восходящими анализаторами связаны:

LL-грамматики
LM-грамматики
LP-грамматики
LR-грамматики


К простейшим формулам можно отнести:

сложение
деление
вычитание
числа


К формулам, содержащим операции типа умножения можно отнести:

деление
умножение
числа
вычитание
сложение


Можно разделить все формулы на следующие классы:

формулы, содержащие операции типа деления
формулы, содержащие операции типа сложения
формулы, содержащие операции типа умножения
простейшие формулы


Обрабатывать формулы, содержащие операции типа умножения будет процедура:

p_Plus
Term
P_Term
Plus


Как мы можем понять, что имеем дело с формулой, содержащей операции типа умножения?

в момент встречи операции умножения
в момент встречи операции деления
в момент встречи сложения
в момент встречи вычитания


Следующая процедура:

int Factor ()
{
   char ch = getChar();
   if (isDigit (ch)) return getValue(ch);
   if (ch == '(')
   {
      int result = Formula ();
      if (getChar() == ')') return result;
      error ("Неожиданный символ");
      return 0;
   }
   return error ("Неожиданный символ");
}

вычисляет значение:

простейшие формулы
формулы, содержащие операции типа умножения
формулы, содержащие операции типа сложения


Параметром процедуры Expression является:

строковое значение
логическое значение
вещественное значение
целочисленное значение


Общий вид формулы, содержащей операции типа сложения:

T1+T2*Tn
T1+T2+…+ Tn
T1+T2+…Tn
T1+T2*Tn


Обрабатывать формулы, содержащие операции типа сложения будет процедура:

P_Term
Expression
Term
P_Expression


Метод getChar:

извлекает из входного потока все цифры
возвращает неиспользованную литеру обратно во входной поток
используется для вывода сообщений об ошибках
выдает очередную литеру из входного потока


Метод рекурсивного спуска без возвратов можно использовать только для:

LL(1)-грамматик
LM(1)-грамматик
LR(1)-грамматик
LP(1)-грамматик


Метод returnChar:

извлекает из входного потока все цифры
возвращает true только в том случае, когда ее параметр является цифрой
выдает очередную литеру из входного потока
возвращает неиспользованную литеру обратно во входной поток


Грамматика называется леворекурсивной, если среди ее нетерминалов имеется по крайней мере один:

леворекурсивный терминал
леворекурсивный нетерминал
праворекурсивный нетерминал
праворекурсивный терминал


В LL(k)-грамматике для любых двух левых выводов:

S =>* wAv => wuv =>* wx
S =>* wAv => wu1v =>* wy

для которых FIRSTk (x) = FIRSTk (y)вытекает, что:
u=u1
k=k1
wx=wy
k(x)=k(y)


Для данной грамматики:

S -> B A
A -> +B A
A -> e
B -> D C
C -> * D C
C -> e
D -> (S)
D -> a

множества FIRST определяются следующим образом:

FIRST (D) = {(, a}, FIRST (C) = {*, d }, FIRST (B) = FIRST (D), FIRST (A)={+, c },
FIRST (S) = {(, a}

FIRST (D) = {(, e}, FIRST (C) = {*, a }, FIRST (B) = FIRST (D), FIRST (A)={+, a },
FIRST (S) = {(, e}

FIRST (D) = {(, e}, FIRST (C) = {*, a }, FIRST (B) = FIRST (D), FIRST (A)={+, e },
FIRST (S) = {(, a}

FIRST (D) = {(, a}, FIRST (C) = {*, e }, FIRST (B) = FIRST (D), FIRST (A)={+, e },
FIRST (S) = {(, a}


Данная грамматика:

E -> T | TE'
E' -> +T | +TE'
T  -> F | FT'
T'-> *F | *FT'
F -> (E) | num

обладает свойством:

LR(k)
LL(k)
LL(1)
LR(1)


Синтаксический разбор в демонстрационном компиляторе Си-бимоль реализован с помощью:

линейного спуска с возвратами
рекурсивного спуска без возвратов
линейного спуска без возвратами
рекурсивного спуска с возвратами


Леворекурсивные грамматики не обладают свойством:

LN(k) ни для какого k
LR(k) ни для какого k
LL(k) ни для какого k
LM(k) ни для какого k


В следующей грамматике:

S->aABe
A->Abc
A->b
B->d

цепочка abbcde может быть свернута в аксиому следующим образом:

abbcde, aAbcde, aAde, aABe, abbd, S
abbcde, aAbcde, aAde, aABe
aAbcde, aAde, aABe, S
abbcde, aAbcde, aAde, aABe, S


Процесс построения дерева разбора, начиная с листьев и двигаясь вверх к корню дерева разбора может быть представлен как:

"свертка" символа w к аксиоме грамматики
"перенос" исходной строки w к аксиоме грамматики
"свертка" исходной строки w к аксиоме грамматики
"перенос" символа строки w к аксиоме грамматики


Предназначен для построения дерева разбора, начиная с листьев и двигаясь вверх к корню дерева разбора:

нисходящий анализатор
восходящий анализ
системный анализатор
линейный анализатор


При LR(k)-анализе применяется метод:

reduce-shift
reduce-reduce
shift-shift
shift-reduce


Метод "перенос-свертка" использует:

конечный автомат
бесконечный автомат
машину Тьюринга
магазинный автомат


LR(k) означает, что:

не более l символов цепочки используются для принятия решения
выполняется правый вывод
входная цепочка обрабатывается слева направо
не более k символов цепочки используются для принятия решения


Управляющая программа:

различна для всех LR-анализаторов
не существует для LR-анализаторов
одинакова для всех LR-анализаторов


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

операция "перенос""
"shift"
операция "свертка"
"reduce"


LR(k)-анализатор состоит из:

Магазин
Выхода
управляющей программы и таблицы
входной цепочким


Функция goto получает:

состояние и символ грамматики
блок и символ грамматики
блок и секцию грамматики
состояние и секцию грамматики


LR(0)-анализатор принимает решение о своих действиях только на основании содержимого магазина:

не учитывая символы выходной цепочки
учитывая символы входной цепочки
не учитывая символы входной цепочки
учитывая символы выходной цепочки


Комбинация символа состояния на вершине магазина и текущего входного символа используется:

для определения операции переноса
для индексирования контекстной таблицы
для индексирования управляющей таблицы
для определения операции переноса-свертки


LR(0)-ситуации не должны содержать:

контекстной цепочки
специальной цепочки
нетерминальной цепочки
терминальной цепочки


Входная цепочка может начнаться с любого:

нетерминального символа
терминального символа
контекстного символа


Данная ситуация:

[S'->.S]
[S-gt;.x]
[S-gt;.(L)]

определяет состояние:

0
3
2
1


Данная ситуация:

[S->(.L)]
[L->.L, S]
[L->.S]
[S->.(L)]
[S->.x]

определяет состояние:

2
3
1
0


Данная ситуация:[S->x.]определяет состояние:

3
2
0
1


Данная ситуация:[S'->S.$]определяет состояние:

0
2
3
1


В данном примере:

goto (I, X)
{
   J={};     
   for (каждой ситуации [A->w.Xv] из I) {
      J+=[A->wX.v];
   }
   return closure (J);
}

происходит:

переход из одного состояния в другое под воздействием символа I
переход из одного состояния в другое под воздействием символа X
переход из одного состояния в другое под воздействием символа A
переход из одного состояния в другое под воздействием символа J


Поскольку для символа $ операция goto (I, $) не определена, можно выполнить:

действие to
действие accept
действие close
действие alt


Какая операция добавляет ситуации к множеству ситуаций, у которых точка стоит слева от нетерминала:

closure
add
goto
point


Сколько символов входной цепочки использует для принятия решения LR(1)-анализатор:

3
4
1
0
2
5


В данном примере:

R = empty set;
for (each state I in T)
{
   for (each item [A->w.] in I)
   {
      R+={(I, A->w)};
   }
}

вычисляется:

множество сверток R
множество сверток T
множество сверток I
множество сверток A


LR(1)-ситуация состоит из:

правила грамматики
одного символа входной строки
позиции правой части


Для данной грамматики:

(1)    E->T
(2)    E->T
(3)    T->T*F
(4)    T->F
(5)    F-> (E)
(6)    F->id

si - это:

перенос и переход в состояние i
свертка по правилу i
переход в состояние i


LALR анализатор имеет значительное преимущество в размере таблиц по сравнению с:

TR
LR
TL
LP


При пополнении какой грамматики правилом S' -> Sможно получить следующие состояния:

0: {[S'-gt;.S, $], [S-gt;.AA, $], [A-gt;.aA, a], [A-gt;.aA, b], [A-gt;.b, a], [A-gt;.b, b]}
1: {[S'-gt;S., $]}
2: {[S'-gt;A.A, $], A-gt;.aA, $], [A-gt;.b, $]}
3: {[A-gt;a.A, a], [A-gt;a.A, b], [A-gt;.a.A, a], [A-gt;.a.A, b], [A-gt;.b, a], [A-gt;.b, b]}
4: {[A-gt;b., a], [A-gt;b., b]}
5: {[S-gt;AA. $]}
6: {[A-gt;a.A, $], [A-gt;.aA, $], [A-gt;.b, $]}
7:  {[A-gt;b., $]}
8:  {[A-gt;aA.,a], [A-gt;aA.,b]}
9:  {[A-gt;aA.,$]}

:
грамматика G1 с правилами:
S -> Ab
A -> aA
A -> A
грамматика G1 с правилами:
S -> AA
A -> aA
A -> b
грамматика G1 с правилами:
S -> AA
A -> a
A -> b
грамматика G1 с правилами:
S -> Ab
A -> ab
A -> b


Имеется следующая входная цепочка: if E1 then if E2 then S1 else S2, при содержимом стека - $ if E1 then if E2 then S1 необработанной частью входной цепочки является:

S1 else S2
then S1 else S2
E2 then S1 else S2
E1 then if E2 then S1 else S2
if E1 then if E2 then S1 else S2
else S2


Неоднозначность грамматики приводит:

к непротиворечивости управляющей таблицы анализатора LR(k)-языка
к конфликтам при построении управляющей таблицы анализатора LR(k)-языка
к компактности управляющей таблицы анализатора LR(k)-языка


Алгоритм построения управляющей таблицы автомата состоит из следующих шагов:

построение множества состояний
пополнение грамматики
построение множества переходов
построение множества сверток


Конфликт перенос-свертка может быть решен следующими методами:

вводя новые терминалы matched_statement и unmatched_statement
вводя новые нетерминалы matched_statement и unmatched_statement
явным образом разрешая конфликт при его возникновении


Альтернативой построению новой грамматики может служить "соглашение", что в случае конфликта перенос-свертка:

происходит игнорирование переноса
свертка является предпочтительным действием
перенос является предпочтительным действием


Конфликт перенос-перенос возникает, когда на вершине стека анализатора возникает строка терминалов, к которой:

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


В данной грамматике:E –> id | num | E* E | E + E операции сложения и умножения выполняются:

в соответствии с приоритетами операций
в порядке появления во выходной последовательности
в порядке появления во входной последовательности


В процессе разбора входной цепочки id (id, id), при содержимом стека - $ id (id, необработанная часть представляет собой:

id, id)
(id, id)
, id)
(id, id)

Вы можете обратится к нам напрямую, через:

skype По Skype: molodoyberkut
telegram По Telegram: @MolodoyBerkut
icq По ICQ: 657089516

Или через форму обратной связи на нашем сайте
Пока сочиняется...
4.png