Интерпретатор Little C

МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ
РОССИЙСКОЙ ФЕДЕРАЦИИ
ГОУ НИЖЕГОРОДСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ
УНИВЕРСИТЕТ
ИМ. Р.Е. АЛЕКСЕЕВА
ИНСТИТУТ РАДИОЭЛЕКТРОНИКИ И ИНФОРМАЦИОННЫХ
ТЕХНОЛОГИЙ
КАФЕДРА "ВЫЧИСЛИТЕЛЬНЫЕ СИСТЕМЫ И ТЕХНОЛОГИИ"
Дисциплина "Технология программирования"
Отчет
по лабораторной работе № 2
Тема: “Разработка технического задания ”
Вариант 23
Выполнил: Скорынин.С.С.
студент группы: 10-В-1
Проверил: Мартынов Д.С.
Нижний Новгород
2011
Введение. Постановка задачи.
Информационный поиск.
1)Функционально близкие объекты
а)язык Little C
б)язык Mini C++
2) Анализ алгоритмов работы функционально близких объектов
Количество зарезервированных слов языка С невелико, однако это богатый и
мощный язык.
Интерпретатор Little C (Малый С) предназначен для интерпретации довольно
узкого подмножества С, включающего, тем не менее, многие важные
средства языка. При определении конкретного состава подмножества языка
Little С использовались два главных критерия:

Неотделимо ли данное средство от языка?

Необходимо ли оно для демонстрации важных аспектов языка?
Например, такие средства, как рекурсивные функции, глобальные и
локальные переменные удовлетворяют обоим критериям. Интерпретатор
Little С поддерживает все три вида циклов (наличие всех их, конечно, не
обязательно в соответствии с первым критерием, но необходимо в
соответствии со вторым критерием). Однако оператор switch не включен в
интерпретатор, потому что он не является обязательным (он красив, но не
необходим) и не иллюстрирует ничего такого, что нельзя было бы
проиллюстрировать с помощью оператора if (который включен в
интерпретатор).
Исходя из этих соображений, в интерпретатор Little С включены следующие
средства языка:

Параметризованные функции с локальными переменными

Рекурсия

Оператор if

Циклы do-while, while и for

Локальные и глобальные переменные типов int и char

Параметры функций типов int и char

Целые и символьные константы

Строковые константы (ограниченная реализация)

Оператор return (как со значением, так и без него)

Ограниченный набор стандартных библиотечных функций

Операторы +, -, *, /, %, <, >, <=, >=, ==, !=, унарный -, унарный +

Функции, возвращающие целое значение

Комментарии вида /*...*/
Ограничение языка Little C
В грамматику Little С введены некоторые ограничения. Первое ограничение
заключается в том, что телом операторов if, while, do и for может быть только
блок, заключенный в фигурные скобки. Если телом является единственный
оператор, он также должен быть заключен в фигурные скобки. Например,
интерпретатор Little С не сможет правильно обработать следующий
фрагмент программы:
for(a=0; a<10; a=a+1)
for(b=0; b<10; b-b+1)
for(c=0; с<10; с=с+1)
puts("привет");
if (...)
if (...) х = 10;
Этот фрагмент должен быть написан так:
for(a=0; a<10; a=a+1) {
for(b=0; b<10; b-b+1) {
for(c=0; с<10; с=с+1) {
puts("привет");
}
}
}
if (...) {
if (...) {
х = 10;
}
}
Благодаря этому ограничению интерпретатору легче найти конец участка
программы, составляющего тело одного из операторов управления
программой. Другое ограничение заключается в том, что не поддерживаются
прототипы функций. Предполагается, что все функции возвращают тип int,
разрешен возвращаемый тип char, но он преобразуется в int. Проверка
правильности типа параметра не выполняется.
Все локальные переменные должны быть объявлены в самом начале
функции, сразу после открывающейся фигурной скобки. Локальные
переменные не могут быть объявлены внутри какого-либо блока. Поэтому
следующая функция в языке Little С является неправильной:
int myfunc()
{
int i; /* это допустимо */
if(1) {
int i; /* в языке Little С это не допустимо */
}
}
Здесь объявление переменной i внутри блока if для интерпретатора Little С
является недопустимым. Требование объявления локальных переменных
только в начале функции немного упрощает реализацию интерпретатора.
И, наконец, последнее ограничение: определение каждой функции должно
начинаться с зарезервированного слова char или int. Следовательно,
интерпретатор Little С не поддерживает традиционное правило "int по
умолчанию". Таким образом, следующее объявление является правильным:
int main()
{
/* ... */
}
однако следующее объявление в языке Little С неправильное:
main()
{
/* ... */
}
Определение значения выражения
Интерпретатор Little С поддерживает следующие операции: +, -, *, /, %, =,
операторы сравнения (<, = =, > и так далее) и скобки. В языке Little С
выражения определяются с помощью следующих порождающих правил:
выражение
-> [присваивание]
[значение_переменной]
присваивание
-> именующее_выражение =
значение_переменной
именующее_выражение -> переменная
значение_переменной -> часть [оператор_сравнения часть]
часть
-> терм [+терм] [-терм]
терм
-> множитель [*множитель]
[/множитель] [%множитель]
множитель
-> [+ или -] атом
атом
-> переменная, константа, функция,
или(выражение)
Здесь термин оператор_сравнения может обозначать любой из операторов
сравнения. Термины именующее_выражение и значение_переменной
означают объекты в левой и правой частях оператора присваивания.
Старшинство оператора определяется порождающим правилом. Чем выше
старшинство оператора, тем ниже в списке операторов он расположен.
Рассмотрим применение порождающих правил на примере вычисления
выражения
count = 10 - 5 * 3;
Сначала применяется правило 1, разделяющее выражение на три части:
count
=
^
^
^
|
|
|
именующее_выражение
10-5*3
присваивание
значение_переменной
Поскольку значение нетерминала значение_переменной не содержит
операторов сравнения, то оно может быть сгенерировано в результате
применения порождающего правила для нетерминала терм:
10
-
5*3
^
^
^
|
|
|
терм
минус
терм
Несомненно, второй терм составлен из двух множителей: 5 и 3. Эти два
множителя являются константами, они порождаются с помощью
порождающих правил более низкого уровня.
Теперь, чтобы вычислить значение выражения, будем двигаться, следуя
порождающим правилам, в обратном направлении. Сначала выполняется
умножение 5*3, что дает 15. Потом это значение вычитается из 10,
получается -5. И, наконец, последний шаг — присваивание этого значения
переменной count, оно же является значением всего выражения.
Синтаксический анализатор выражений.
В рассматриваемом интерпретаторе Little С используется рекурсивный
нисходящий синтаксический анализатор.Рекурсивный нисходящий
синтаксический анализатор представляет собой набор взаимно рекурсивных
функций, обрабатывающих выражение.
Синтаксический разбор исходного текста программы.
Специальная функция, читающая исходный текст программы и
возвращающая очередную логическую единицу, является фундаментальной
частью каждого интерпретатора и компилятора. Исторически сложившееся
название такой логической единицы — лексема. Во всех языках
программирования (в том числе и в языке С) программа рассматривается как
последовательность лексем. Другими словами, лексема — это неделимая
единица программы. Например, оператор равенства = = является лексемой.
Эти два знака равенства нельзя разделить, не изменив кардинальным образом
их значение. Аналогично, if — также лексема. Ни "i", ни "f" сами по себе не
имеют в программе на С никакого значения.
В языке С каждая лексема принадлежит одной из следующих категорий:
зарезервированные слова идентификаторы константы
строки
операторы
знаки пунктуации
Зарезервированные слова — это лексемы, составляющие язык С; к ним
относится, например, while. Идентификаторы — это имена переменных,
функций и типов, определенных пользователем (в Little С не реализованы).
Знаки пунктуации — это некоторые символы, такие как точка с запятой,
запятая, различные скобки и т.п. В зависимости от контекста, некоторые из
этих символов, могут быть операторами. Приведем пример разбиения на
лексемы при разборе оператора слева направо. Оператор
for(x=0; x<10; x=x+1) printf("алло %d", x);
состоит из следующих лексем:
Лексема
Категория
for
зарезервированное слово
(
знак пунктуации
x
идентификатор
=
оператор
0
константа
;
знак пунктуации
x
идентификатор
<
оператор
10
константа
;
знак пунктуации
x
идентификатор
=
оператор
x
идентификатор
+
оператор
1
константа
)
знак пунктуации
printf
идентификатор
(
знак пунктуации
"алло %d" строка
,
знак пунктуации
x
идентификатор
)
знак пунктуации
;
знак пунктуации
В интерпретаторе Little С определяются следующие категории лексем:
Тип лексемы
Включает
delimiter (разделитель)
знаки пунктуации и операторы
keyword (зарезервированное слово) зарезервированные слова
string (строка)
строки, заключенные в двойные кавычки
identifier (идентификатор)
имена переменных и функций
number (число)
числовая константа
block (блок)
{ или }
Основные функциисинтаксияеского анализатора языка Little С
Функция get_token() выделяет лексемы из исходного текста программы
Little С и возвращает их в качестве своего значения. Функция get_token()
начинает работу с удаления пробелов и символов перевода строки. Так как
никакая лексема языка С (кроме строковой константы) не содержит
пробелов, их нужно пропустить. Функция get_token() пропускает также
комментарии (в Little С допускаются только комментарии вида /*...*/). После
этого строка, представляющая каждую лексему, помещается в token и ее
тип (определенный в перечислении tok_types) записывается в
token_type. Если лексема представляет собой зарезервированное слово, то
его внутреннее представление присваивается tok с помощью функции
look_up(),если синтаксический анализатор находит синтаксическую
ошибку, то он вызывает функцию sntx_err() со значением перечислимого
типа, соответствующим типу найденной ошибки.
Интерпретатор Little C
Работа по интерпретации программы на С может быть выражена следующим
простым алгоритмом:
while (есть_лексемы_во_входном_потоке) {
читать следующую лексему;
выполнить соответствующее действие;
}
Нужно иметь в виду следующее: шаг "выполнить соответствующее
действие" может содержать чтение дополнительных лексем из входного
потока. Для лучшего понимания этого алгоритма мысленно выполним
интерпретацию следующего фрагмента программы:
int a;
a = 10;
if(a < 100) printf("%d", a);
Согласно алгоритму, прочтем первую лексему int. Эта лексема указывает
на то, что следующим действием должно быть чтение следующей лексемы
для того, чтобы узнать, как называется переменная (a), которую нужно
объявить и для которой нужно выделить область памяти. Следующая лексема
(точка с запятой) заканчивает строку. Соответствующее действие —
проигнорировать ее. Далее, начинаем следующую итерацию алгоритма и
считываем следующую лексему, это а из второй строки. Строка не
начинается с зарезервированного слова, следовательно, это выражение языка
С. Поэтому соответствующим действием является применение
синтаксического анализатора выражений для вычисления значения
выражения. Этот процесс "съедает" все лексемы во второй строке. Наконец,
читаем лексему if. Она указывает на то, что начинается оператор if.
Соответствующее действие — выполнить его. Аналогичный процесс
выполняется многократно, пока не будет считана последняя лексема
программы.
Интерпретатор Little C
В этом разделе рассматривается наиболее важная часть интерпретатора Little
С. Перед тем как приступить к подробному чтению текста программы
интерпретатора, нужно понять, как вообще работает интерпретатор. Понять
программу интерпретатора в некотором смысле легче, чем программу
синтаксического анализатора выражений, потому что работа по
интерпретации программы на С может быть выражена следующим простым
алгоритмом:
while (есть_лексемы_во_входном_потоке) {
читать следующую лексему;
выполнить соответствующее действие;
}
Этот алгоритм может показаться невероятно простым по сравнению с
синтаксическим анализатором выражений, но это именно то, что делает
интерпретатор. Нужно только иметь в виду следующее: шаг "выполнить
соответствующее действие" может содержать чтение дополнительных лексем
из входного потока. Для лучшего понимания этого алгоритма мысленно
выполним интерпретацию следующего фрагмента программы:
int a;
a = 10;
if(a < 100) printf("%d", a);
Согласно алгоритму, прочтем первую лексему int. Эта лексема указывает
на то, что следующим действием должно быть чтение следующей лексемы
для того, чтобы узнать, как называется переменная (a), которую нужно
объявить и для которой нужно выделить область памяти. Следующая лексема
(точка с запятой) заканчивает строку. Соответствующее действие —
проигнорировать ее. Далее, начинаем следующую итерацию алгоритма и
считываем следующую лексему, это а из второй строки. Строка не
начинается с зарезервированного слова, следовательно, это выражение языка
С. Поэтому соответствующим действием является применение
синтаксического анализатора выражений для вычисления значения
выражения. Этот процесс "съедает" все лексемы во второй строке. Наконец,
читаем лексему if. Она указывает на то, что начинается оператор if.
Соответствующее действие — выполнить его. Аналогичный процесс
выполняется многократно, пока не будет считана последняя лексема
программы. Это относится к любой программе на С. Пользуясь этим
алгоритмом, приступим к созданию интерпретатора.
Предварительный проход интерпритатора
Перед тем как интерпретатор начнет выполнять программу, должны быть
выполнены некоторые процедуры. Характерной чертой языков,
предназначенных больше для интерпретации, чем для компиляции, является
то, что выполнение программы начинается в начале текста программы и
заканчивается в его конце. Так выполняются программы, написанные на
старых версиях языка BASIC. Это, однако, не относится к языку С по трем
основным причинам.
Во-первых, все программы на С начинают выполняться с функции main().
Вовсе не обязательно, чтобы эта функция была первой в программе. Поэтому
интерпретатор, чтобы начать выполнение с нее, должен еще до начала
выполнения программы узнать, где она находится. Следовательно, должен
быть реализован некоторый метод, позволяющий начать выполнение
программы с нужной точки. (Глобальные переменные также могут
предшествовать функции main(), поэтому, даже если она является первой
функцией программы, все равно и в этом случае она не начинается с первой
строки.)
Во-вторых, все глобатьные переменные должны быть известны перед
началом выполнения main(). Операторы объявления глобальных
переменных никогда не выполняются интерпретатором, потому что они
находятся вне всех функций.
В-третьих, для повышения скорости выполнения необходимо знать, где в
программе расположена каждая функция; это позволит вызывать ее как
можно быстрее. Если это условие не будет выполнено, то при каждом вызове
функции понадобится длительный последовательный поиск этой функции в
тексте программы.
Эти проблемы решаются с помощью предварительного прохода
интерпретатора. Программа предварительного прохода читает исходный
текст программы перед ее выполнением и делает все, что нужно сделать до
выполнения. В интерпретаторе Little С она выполняет две важные задачи: вопервых, находит и запоминает положение всех пользовательских функций,
включая main(), и во-вторых, находит все глобальные переменные и
определяет область их видимости. В интерпретаторе Little С
предварительный проход выполняет функция prescan().Функция
prescan() работает следующим образом. Каждый раз, когда встречается
открывающаяся фигурная скобка, переменная brace увеличивается на 1, а
когда закрывающаяся — уменьшается на 1. Следовательно, если brace
больше нуля, то текущая лексема находится внутри функции. Поэтому
объявление переменной считается глобальным, если оно встретилось, когда
brace равно нулю. Аналогично, если при brace, равном нулю, встретилось
имя функции, значит, оно принадлежит определению функции (в Little С нет
прототипов функций).
Функция interp_block()
Если не считать вызовов функции exit() или подобных ей, то
интерпретация программы, написанной на языке С, кончается в одном из
следующих случаев: встретилась последняя закрывающаяся фигурная скобка
функции main(), или встретился оператор return из main(). Из-за того,
что при встрече последней закрывающейся фигурной скобки main()
программу нужно завершить, interp_block() выполняет только один
оператор или блок, а не всю программу, хоть она и состоит из блоков. Таким
образом, interp_block() вызывается каждый раз, когда встречается
новый блок. Это относится не только к блокам функций, но и к блокам
операторов (например, if). Следовательно, в процессе выполнения
программы интерпретатор Little С вызывает interp_block() рекурсивно.
Функция interp_block() работает следующим образом. Сначала из
входного потока считывается очередная лексема программы. Если это точка
с запятой, то выполняется единственный оператор и функция возвращает
управление. В противном случае, выполняется проверка, является ли
следующая лексема идентификатором; если да, то оператор является
выражением и вызывается синтаксический анализатор выражений.
Синтаксический анализатор должен прочесть все выражение, включая
первую лексему, поэтому перед его вызовом функция putback()
возвращает последнюю прочитанную лексему во входной поток. После
возврата управления из eval_exp() token содержит последнюю лексему,
прочитанную синтаксическим анализатором выражений. Если
синтаксических ошибок нет, то это должна быть точка с запятой. Если
token не содержит точку с запятой, то выводится сообщение об ошибке.
Если очередная лексема программы является открывающейся фигурной
скобкой, то переменная block устанавливается равной 1, а если
закрывающейся, то interp_block() возвращает управление вызвавшей
программе.
Обработка локальных переменных
Когда интерпретатор встречает зарезервированные слова int или char, он
вызывает функцию decl_local(), которая размещает локальные
переменные. Функция decl_local() сначала считывает тип объявленной
переменной (или переменных) и инициализирует переменные нулями. Затем
в цикле считывается список идентификаторов, разделенных запятыми. При
каждой итерации цикла информация об очередной переменной заносится в
стек локальных переменных. В конце функции decl_local() проверяется,
является ли последняя лексема точкой с запятой.
При выполнении программы интерпретатор не может встретить объявление
глобальной переменной, потому что выполняется только код программы,
записанный внутри функций. Следовательно, если встретилось объявление
переменной, то это локальная переменная. В структурированных языках
локальные переменные хранятся в стеке. В интерпретаторе Little С стек для
локальных переменных хранится в массиве local_var_stack. Каждый
раз, когда встречается локальная переменная, ее имя, тип и значение
(первоначально равное нулю) заносятся в стек при помощи функции
local_push(). Глобальная переменная lvartos является указателем
стека. (Соответствующей функции извлечения из стека нет. Вместо этого
стек локальных переменных переустанавливается каждый раз при возврате
управления из функции local_push().
Вызов функций, определенных пользователем
Все вызовы функций (кроме main()) осуществляются в синтаксическом
анализаторе выражений из функции atom() с помощью вызова функции
call(). Именно функция call() выполняет все необходимые при вызове
функций действия.
В первую очередь с помощью вызова функции find_func() функция
call() находит адрес точки входа вызываемой функции в исходном тексте
программы. Затем эта функция сохраняет текущее значение lvartos
индекса стека локальных переменных в переменной lvartemp. Потом она
вызывает функцию get_args(), которая обрабатывает все аргументы
функции. Функция get_args() считывает список выражений, разделенных
запятыми, и заносит их в стек локальных переменных в обратном порядке.
(Обратный порядок занесения переменных применяется потому, что так их
легче сопоставлять с соответствующими параметрами.) Значения
переменных, записанные в стек, не имеют имен (стек — это всего лишь
массив). Имена параметров даются им функцией get_params().
После обработки аргументов функции текущее значение указателя prog
сохраняется в temp. Эта переменная указывает на точку возврата функции.
После этого значение lvartemp заносится в стек вызова функций. Доступ к
этому стеку осуществляется с помощью функций func_push() и
func_pop(). В данный стек при каждом вызове функции записывается
значение lvartos. Значение lvartos представляет собой начальную точку
в стеке локальных переменных для переменных (и параметров) вызванной
функции. Значение на вершине стека вызова функций используется для
предотвращения доступа функции к переменным, которые в ней не
объявлены.
Следующие две строки функции call() устанавливают указатель
программы на начало функции и затем, вызывая функцию get_params(),
устанавливают соответствие между формальными параметрами и значениями
аргументов функции, которые уже находятся в стеке локальных переменных.
Фактическое выполнение функции осуществляется вызовом
interp_block(). После возврата управления из interp_block()
указатель программы prog переустанавливается; он будет указывать на
точку возврата, а индекс стека локальных переменных получит значение,
которое он имел до вызова функции. На этом последнем шаге из стека
фактически удаляются все локальные переменные функции.
Если вызванная функция содержит оператор return, то interp_block()
перед возвратом в call() вызывает func_ret(), которая вычисляет
возвращаемое значение.
Обработка цикла while
Функция exec_while() работает следующим образом. Сначала лексема
while возвращается во входной поток, а ее адрес сохраняется в переменной
temp. Этот адрес будет использован интерпретатором, чтобы возвратиться к
началу цикла (т.е. начать следующую итерацию с начала цикла while).
Далее лексема while считывается заново для того, чтобы удалить ее из
входного потока. После этого вызывается функция eval_exp(), которая
вычисляет значение условного выражения цикла while. Если условие
выполнено (т.е. условное выражение принимает значение ИСТИНА), то
рекурсивно вызывается функция interp_block(), которая
интерпретирует блок while. После возврата управления из
interp_block() программный указатель prog устанавливается на начало
цикла while и управление передается функции interp_block(), в
которой весь процесс повторяется. Если условное выражение оператора
while принимает значение ЛОЖЬ, то происходит поиск конца блока
while, а затем выход из функции exec_while().
Обработка цикла do-while
Главное отличие цикла do-while от цикла while состоит в том, что блок
do-while выполняется всегда как минимум один раз, потому что его
условное выражение находится после тела цикла. Поэтому exec_do сначала
запоминает адрес начала цикла в переменной temp, а затем рекурсивно
вызывает interp_block(), которая интерпретирует блок,
ассоциированный с циклом. После возврата управления из
interp_block() идет поиск соответствующего слова while и
вычисляется значение условного выражения. Если условие выполнено, то
prog устанавливается так, что его значение указывает на начало цикла, в
противном случае выполнение продолжается со следующего оператора.
Цикл for
Сначала функция обрабатывает инициализирующее выражение цикла for.
Часть инициализации for выполняется только один раз; эта часть не
подвергается циклической обработке. Затем указатель программы
устанавливается так, чтобы он указывал на символ, следующий сразу после
той точки с запятой, которой заканчивается часть инициализации. Наконец,
после этого значение указателя присваивается переменной temp. А затем
организовывается цикл, в котором проверяется условная часть цикла for и
переменной temp2 присваивается адрес начала части приращения. Далее
производится поиск начала тела цикла и его (тела) интерпретация, если
условное выражение принимает значение ИСТИНА. (В противном случае
производится поиск конца тела цикла и выполнение продолжается с
оператора, следующего после цикла for.) После рекурсивного вызова
interp_block() выполняется часть приращения, после чего весь процесс
повторяется.
Алгоритм работы языка Mini C++ такой же как у Little C.
Обзор литературы
1) «Герберт Шилдт. Полный справочник по С (4-ое издание)»
2) «Герберт Шилдт. Искусство программирования на С++»
3) «Гласс Г., Эйблс К. UNIX для программистов и пользователей»
4) http://www.realcoding.net/articles/chast-vii-interpretatory-yazyka.html
Постановка задачи.
В данной курсовой работе реализуется интерпретатор языка С(его
подмножества),для создания программ.
Техническое задание.
1) Наименование.
C subset interpreter (интерпретатор подмножества С- CSI)
2)Основание для выполнения.
Данная работа выполнена на основании приказа на курсовую работу, в
соответствии с учебным планом.
3)Исходные данные на курсовую работу.
тип синтаксического анализатора, набор средств языка, ограничения на язык,
алгоритм реализации интерпретатора.
4)Основное назначение образца это:
а)Интерпретирование исходного кода программы.
б)Предоставления по запросу справки о особенностях языка(ограничеиня на
язык, средства языка определенные в CSI)
5) Цель и назначения разработки.
Цель: Разработка языка CSI для создания программ.
CSI должен обеспечивать:
а)большую переносимость интерпретируемой программы — программа
будет работать на любой платформе, на которой есть интерпретатор.
б)упрощение отладки исходных кодов программ(по сравнению с
компилированными)
в)меньшие размеры кода по сравнению с машинным кодом, полученным
после обычных компиляторов.
г)легко поддаваться модификации и расширению.
6)Область применения разработки.
Разработка будет применятся в области программирования для написания
программ.
7)Функциональные требования .
Перед использованием данного продукта пользователь должен ознакомиться
с особенностями языка(правила синтаксиса, ограничения на язык, набор
средств языка). Программа должна получить исходные данные написанные
программистом. По запросу, интерпретатор выполняет реализацию
написанного кода по заданному алгоритму и программа выводит
информацию о результате работы на экран.
8)Требования к аппаратному обеспечению.
Лицензия на работу с Windows 2000/xp/Vista/7
9)Требования к программному обеспечению
В качестве платформы для запуска программного обеспечения программа
должна использовать Windows 2000/xp/Vista/7.
10) Требования по надежности.
Все части программы должны функционировать без внешних вмешательств в
исходный код и используемые программные средства.
11) Требования по эргономике и механической эстетике.
Данные на экране ПК должны быть однозначноинтерпретируемы. Элементы
пользовательского интерфейса на экране компьютера должны быть созданы
и расположены с учетом удобного визуального восприятия и цветопередачи.
12) Требования по эксплуатации, удобству технического обслуживания,
ремонту и хранению.
Эксплуатация данного продукта производиться в соответствии инструкции
которая встроена в программу и предоставляется по запросу пользователя.
По вопросам технического обслуживания и ремонта продукта обращаться в
информационно-вычислительный центр НГТУ им.Алексеева, данный
продукт храниться на флешкарте или оптическом носителе.
13) Требования по стандартизации и унификации.
CSI проектируется на языке программирования С++ с использованием
типовых информационных средств и сервисов.
14)Календарный план
Данный проект выполняется в течении 14-15 недель.