Исследование методов и алгоритмов работы трансляторов предметно-ориентированных языков
Обзор методов и алгоритмов работы интерпретатора языка МИЛАН. Грамматика модифицированного языка в виде диаграмм Вирта. Описание лексического анализатора и интерпретатора модифицированного языка МИЛАН. Программная реализация и тестирование интерпретатора.
| Рубрика | Программирование, компьютеры и кибернетика |
| Вид | курсовая работа |
| Язык | русский |
| Дата добавления | 19.05.2015 |
| Размер файла | 1012,7 K |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
</form> </body></html>');
exit; //!! производится завершение работы интерпретатора и ожидание ввода данных
}
$Cifra=$ct_readBUF[$ct_readCount++];
if (!Stek_Integer(2, $StekRes, $TopRes, $Cifra))
{
/* Переполнение стека $StekRes */
$Code_Error=26;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
break;
Case _LPAREN_ :
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
/* Обработка конструкции <выражение> */
ProcedureE();
/* Проверка на ошибки, появившиеся в процессе обработки конструкции <выражение>*/
if ($Code_Error!=-1)
return 0;
if ($Tab_Lexems[$Number_Lexem]->Code==_RPAREN_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
}
else
{
/* Конструкция <множитель>. Нет закрывающей скобки. */
$Code_Error=30;
return 0;
}
break;
endswitch;
return 0;
} /* End ProcedureP */
/*********************************************************************/
/* Процедура ProcedureT - обработка конструкции <терм> */
/* <терм>::=<множитель>|<множитель><операция типа умножения><множитель> */
/*********************************************************************/
Function ProcedureT()
{
global $Code_Error;
global $Tab_Lexems;
global $Number_Lexem;
global $StekMul;
global $TopMul;
global $StekRes;
global $TopRes;
global $Bi;
global $Ai;
$c = 0;
$kmul = 0;
/* Обработка конструкции множитель */
ProcedureP();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <множитель> */
if ($Code_Error!=-1)
return 0;
while (TRUE)
{
if ($Tab_Lexems[$Number_Lexem]->Code == _MUL_)
{
/* y5: занесение в стек $StekMul значение операции типа умножения */
/* $Tab_Lexems[$Number_Lexem]->Value-->StekMul */
if (!Stek_Integer(2, $StekMul, $TopMul, $Tab_Lexems[$Number_Lexem]->Value))
{
/* Переполнение стека $StekMul */
$Code_Error=28;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
/* Обработка конструкции <множитель> */
ProcedureP();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <множитель> */
if ($Code_Error!=-1)
return 0;
/* y6: в переменную $Bi снять элемент со стека $StekRes ($Bi<--$StekRes), */
/* в переменную $Ai снять элемент со стека $StekRes ($Ai<--$StekRes), */
/* в переменную kmul снять элемент со стека $StekMul ($kmul<--$StekMul), */
/* выполнить операцию типа умножение $Ai otu($kmul) $Bi и результат */
/* занести в стек $StekRes */
if (!Stek_Integer(1, $StekRes, $TopRes,$Bi))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if (!Stek_Integer(1, $StekRes, $TopRes, $Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if (!Stek_Integer(1, $StekMul, $TopMul, $kmul))
{
/* Нехватка элементов в стеке $StekMul */
$Code_Error=27;
return 0;
}
/* Выполнение умножения */
$c=$Ai*$Bi;
$mode= _SLASH_;
if ($kmul==$mode)
{
if ($Bi!=0)
{
$c=intval($Ai / $Bi); //присвоим $c целую часть от деления $Ai и $Bi
}
else
{
/* Деление на ноль */
$Code_Error=29;
return 0;
}
}
/* занесение результата в стек $StekRes */
if (!Stek_Integer(2, $StekRes, $TopRes, $c))
{
/* Переполнение стека $StekRes */
$Code_Error=26;
return 0;
}
}
return 0;
}
}
/* End ProcedureT */
/*********************************************************************/
/* Процедура ProcedureE - обработка конструкции <выражение> */
/* <выражение>::=<терм>|<операция типа сложения><терм> | */
/* <терм><операция типа сложения><терм> | */
/* <операция типа сложения><терм><операция типа сложения><терм> */
/*********************************************************************/
Function ProcedureE()
{
global $TopSum;
global $TopRes;
global $StekSum;
global $StekRes;
global $Tab_Lexems;
global $Number_Lexem;
global $Code_Error;
global $Ai;
global $Bi;
$c =0;
$ksum =0;
if ($Tab_Lexems[$Number_Lexem]->Code==_SUMM_)
{
/* y7: занесение в стек $StekSum кода операции типа сложения */
if (!Stek_Integer(2, $StekSum, $TopSum, $Tab_Lexems[$Number_Lexem]->Value))
{
/* Переполнение стека $StekSum */
$Code_Error=31;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
/* Обработка конструкции <терм> */
ProcedureT();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <терм> */
if ($Code_Error!=-1)
return 0;
/* y8: в переменную ksum снять со стека $StekSum значение */
/* лексемы ots ($ksum<--$StekSum), если ksum=1, то снять */
/* в переменную Ai элемент со стека $Stekres ($Ai<--$StekRes), */
/* сменить знак этого числа и занести его в стек $StekRes */
/* -$Ai-->$StekRes */
if (!Stek_Integer(1, $StekSum, $TopSum, $ksum))
{
/* Нехватка элементов в стеке $StekSum */
$Code_Error=32;
return 0;
}
if ($ksum!=_PLUS_)
{
if (!Stek_Integer(1, $StekRes, $TopRes, $Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
$Ai=-$Ai;
if (!Stek_Integer(2, $StekRes, $TopRes, $Ai))
{
/* Переполнение стека $StekRes */
$Code_Error=26;
return 0;
}
}
}
//ADD
elseif($Tab_Lexems[$Number_Lexem]->Code==_INC_)
{
/* Конструкция <выражение>. Неверный оператор инкремента.*/
$Code_Error=50;
return 0;
}
else
{
/* случай отсутствия операции сложения */
/* Обработка конструкции <терм> */
ProcedureT();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <терм> */
if ($Code_Error!=-1)
return 0;
}
while (TRUE):
if ($Tab_Lexems[$Number_Lexem]->Code==_SUMM_)
{
/* y9: занесение в стек $StekSum кода операции типа сложения */
if (!Stek_Integer(2, $StekSum, $TopSum, $Tab_Lexems[$Number_Lexem]->Value))
{
/* Переполнение стека $StekSum */
$Code_Error=31;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции <терм> */
ProcedureT();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <терм> */
if ($Code_Error!=-1)
return 0;
/* y10: в переменную $Bi снять элемент со стека $StekRes ($Bi<--$StekRes),*/
/* в переменную $Ai снять элемент со стека $StekRes ($Ai<--$StekRes), */
/* в переменную ksum снять элемент со стека $StekSum ($ksum<--$StekSum), */
/* выполнить операцию типа сложение $Ai ots($ksum) $Bi и результат */
/* занести в стек $StekRes */
if (!Stek_Integer(1, $StekRes, $TopRes, $Bi))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if (!Stek_Integer(1, $StekRes, $TopRes, $Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if (!Stek_Integer(1, $StekSum, $TopSum, $ksum))
{
/* Нехватка элементов в стеке $StekSum */
$Code_Error=32;
return 0;
}
$c=$Ai+$Bi;
if ($ksum!=_PLUS_)
$c=$Ai-$Bi;
/* занесение результата в стек $StekRes */
if (!Stek_Integer(2, $StekRes, $TopRes, $c))
{
/* Переполнение стека $StekRes */
$Code_Error=26;
return 0;
}
}
elseif($Tab_Lexems[$Number_Lexem]->Code==_INC_)
{
/* Конструкция <выражение>. Неверный оператор инкремента.*/
$Code_Error=50;
return 0;
}
return 0;
endwhile;
} /* End ProcedureE */
/*********************************************************************/
/* Процедура ProcedureB - обработка конструкции <условие> */
/* <условие>::=<выражение><знак отношения><выражение> */
/*********************************************************************/
Function ProcedureB()
{
global $TopSum;
global $TopRes;
global $StekSum;
global $StekRes;
global $StekRel;
global $TopRel;
global $Tab_Lexems;
global $Number_Lexem;
global $Code_Error;
global $Ai;
global $Bi;
$c =0;
$krel =0;
/* Обработка конструкции <выражение> */
ProcedureE();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <выражение> */
if ($Code_Error!=-1)
return 0;
if ($Tab_Lexems[$Number_Lexem]->Code==_RELATION_)
{
/* y11: добавление в стек $StekRel значения операции типа отношение */
/* ($Tab_Lexems[$Number_Lexem]->Value-->$StekRel) */
if (!Stek_Integer(2, $StekRel, $TopRel, $Tab_Lexems[$Number_Lexem]->Value))
{
/* Переполнение стека $StekRel */
$Code_Error=24;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции <выражение> */
ProcedureE();
/* Проверка на ошибки, появившиеся в процессе обработки конструкции <выражение> */
if ($Code_Error!=-1)
return 0;
/* y12: в переменную Bi снять элемент со стека $StekRes ($Bi<--$StekRes),*/
/* в переменную $Ai снять элемент со стека StekRes ($Ai<--$StekRes), */
/* в переменную $krel снять элемент со стека $StekRel (krel<--$StekRel), */
/* выполнить операцию сравнения $Ai otn($krel) Bi и результат занести */
/* в стек $StekRes ([0, 1]-->$StekRes) */
if (!Stek_Integer(1, $StekRes, $TopRes, $Bi))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if (!Stek_Integer(1, $StekRes, $TopRes, $Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if (!Stek_Integer(1, $StekRel, $TopRel, $krel))
{
/* Нехватка элеметов в стеке $StekRel */
$Code_Error=25;
return 0;
}
/* выполнение сравнения */
switch ($krel):
case _EQUAL_: if ($Ai==$Bi) $c=1;break;
case _NOTEQUAL_: if ($Ai!=$Bi) $c=1;break;
case _GT_: if ($Ai>$Bi) $c=1;break;
case _LT_: if ($Ai<$Bi) $c=1;break;
case _GE_: if ($Ai>=$Bi) $c=1;break;
case _LE_: if ($Ai<=$Bi) $c=1;break;
default: $c=0;
endswitch;
/* занесение результата в стек $StekRes */
if (!Stek_Integer(2, $StekRes, $TopRes, $c))
{
/* Переполнение стека $StekRes */
$Code_Error=26;
return 0;
}
}
else
{
/* Конструкция <условие>. Неверная операция отношения. */
$Code_Error=23;
return 0;
}
return 0;
} /* End ProcedureB */
/*********************************************************************/
/* Процедура ProcedureS - обработка конструкции */
/* <оператор>::=<идентификатор>:=<выражение> | OUTPUT(<выражение>) | */
/* WHILE <условие> DO <последовательность операторов> ENDDO| */
/* IF <условие> THEN <последовательность операторов> ENDIF | */
/* <последовательность операторов> ENDIF */
/* Добавлено: ****************************/
/* <оператор>::= <дентификатор>++ | */
/* FOR <идентификатор>:=<выражение> TO <выражение> <последовательность операторов> ENDFOR | */
/* FOR <идентификатор>:=<выражение> TO <выражение> <последовательность операторов> STEP <> ENDFOR | */
/* SWITCH(<выражение>){<выбор>} | SWITCH(<выражение>){<выбор><умолчание>} */
/*********************************************************************/
Function ProcedureS()
{
global $TopRes;
global $StekRes;
global $Tab_Lexems;
global $Number_Lexem;
global $Code_Error;
global $StekIdent;
global $TopIdent;
global $ArrIdent;
global $Ai;
global $Bi;
//ADD
global $StekRep;
global $StekSw;
global $TopRep;
global $TopSw;
switch ($Tab_Lexems[$Number_Lexem]->Code):
case _INC_:
/* Конструкция <оператор>. Неверная конструкция инкремента.*/
$Code_Error=40;
return 0;
/* Обработка оператора присваивания */
/* <идентификатор>:=<выражение> */
/* <идентификатор>++ */
case _IDENTIFIER_ :
/* y13:добавить значение лексемы с номером $Number_Lexem */
/* в стек $StekIdent ($Tab_Lexems[$Number_Lexem]->Value-->$StekIdent)*/
if (!Stek_Integer(2, $StekIdent, $TopIdent, $Tab_Lexems[$Number_Lexem]->Value))
{
/* Переполнение стека $StekIdent */
$Code_Error=14;
Exit;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
//ADD
if ($Tab_Lexems[$Number_Lexem]->Code==_INC_)
{
/* y2p: снять значение лексемы $Number_Lexem-1 в переменную $Ai */
/* ($Ai<--$Tab_Lexems[$Number_Lexem-1]->Value), увеличить значение */
/* идентификатора с номером $Ai на 1 ($ArrayIdent[$Ai]++). */
/* Удалить вершину стека $StekIdent. */
$Ai=$Tab_Lexems[$Number_Lexem-1]->Value;
$ArrIdent[$Ai]+=1;
if (!Stek_Integer(1, $StekIdent, $TopIdent, $Ai))
{
/* Нехватка элементов в стеке $StekIdent */
$Code_Error=17;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
}
elseif($Tab_Lexems[$Number_Lexem]->Code==_ASSIGNMENT_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции <выражение> */
ProcedureE();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <выражение> */
if ($Code_Error!=-1)
return 0;
/* y14: в переменную $Ai снять элемент со стека $StekRes*/
/* ($Ai<--$StekRes), в переменную $Bi снять со стека */
/* $StekIdent значение лексемы ident ($Bi<--$StekIdent), */
/* идентификатору с номером $Bi, присвоить значение $Ai */
/* $ArrIdent[$Bi]=$Ai */
if (!Stek_Integer(1, $StekRes, $TopRes,$Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if(!Stek_Integer(1, $StekIdent, $TopIdent, $Bi))
{
/* Нехватка элементов в стеке $StekIdent */
$Code_Error=17;
return 0;
}
$ArrIdent[$Bi]=$Ai;
}
else
{
/* Конструкция <оператор>. Неверное присваивание*/
$Code_Error=15;
return 0;
}
break;
case _OUTPUT_ :
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
if ($Tab_Lexems[$Number_Lexem]->Code==_LPAREN_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции <выражение> */
ProcedureE();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <выражение> */
if ($Code_Error!=-1)
return 0;
}
else
{
/* Конструкция <оператор>.Неверный оператор OUTPUT.*/
$Code_Error=18;
return 0;
}
if ($Tab_Lexems[$Number_Lexem]->Code==_RPAREN_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* y15: в переменную $Ai снять элемент со стека StekRes */
/* ($Ai<--$StekRes), напечатать переменную $Ai */
if (!Stek_Integer(1, $StekRes,$TopRes, $Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
echo('
<br>
<hr>
<br>
ВЫВОД: ' . $Ai . '
<br>
');
}
else
{
/* Конструкция <оператор>. Неверный оператор OUTPUT.*/
$Code_Error=18;
return 0;
}
break;
case _WHILE_ :
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
while (TRUE)
{
/* Обработка конструкции <условие> */
ProcedureB();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <условие> */
if ($Code_Error!=-1)
return 0;
/* y16: в переменную $Ai снять элемент со стека StekRes */
/* ($Ai<--$StekRes), если $Ai=1, то это истина, иначе - ложь */
if (!Stek_Integer(1, $StekRes, $TopRes, $Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if ($Tab_Lexems[$Number_Lexem]->Code==_DO_)
{
/* проверка истинности условия: $Ai==1 (TRUE), */
/* $Ai==0 (FALSE) */
if ($Ai==1) /* обработка TRUE */
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции */
/* <последовательность операторов> */
ProcedureL();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции */
/* <последовательность операторов> */
if ($Code_Error!=-1)
return 0;
if ($Tab_Lexems[$Number_Lexem]->Code==_ENDDO_)
{
/* y17: перейти на лексему номер */
/* $Tab_Lexems[$Number_Lexem]->Value */
$Number_Lexem=$Tab_Lexems[$Number_Lexem]->Value;
Continue;
}
else
{
/* Конструкция <оператор>. Неверный оператор WHILE. */
$Code_Error=19;
return 0;
}
}
else /* обработка FALSE */
{
/* перейти на лексему номер $Tab_Lexems[$Number_Lexem]->Value */
$Number_Lexem=$Tab_Lexems[$Number_Lexem]->Value;
return 0;
}
}
else
{
/* Конструкция <оператор>. Неверный оператор WHILE. */
$Code_Error=19;
return 0;
}
}
break;
//ADD
case _REPEAT_:
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
While(TRUE)
{
/* Обработка конструкции <последовательность операторов> */
ProcedureL();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <последовательность операторов>*/
if ($Code_Error!=-1)
return 0;
if($Tab_Lexems[$Number_Lexem]->Code!=_UNTIL_)
{
/* Конструкция <оператор>. Неверный оператор REPEAT-UNTIL. */
$Code_Error=41;
return 0;
}
/*y19: занести в стек $StekRep значение лексемы $Number_Lexem */
/*($StekRep<--$Tab_Lexems[$Number_Lexem]->Value); */
if (!Stek_Integer(2, $StekRep, $TopRep, $Tab_Lexems[$Number_Lexem]->Value))
{
/* Переполнение стека $StekRep */
$Code_Error=42;
Exit;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции <условие> */
ProcedureB();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <условие>*/
if ($Code_Error!=-1)
return 0;
/*y16: в переменную $Ai снять элемент со стека $StekRes*/
/* ($Ai?$StekRes), если $Ai=1, то это истина, иначе - ложь;*/
if (!Stek_Integer(1, $StekRes, $TopRes,$Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
// Ветка TRUE
if($Ai==1)
{
/*y21: снять вершину стека $StekRep в переменную $Bi */
/*($Bi?$StekRes), перейти на лексему с номером $Bi ($Number_Lexem ?$Bi)*/
if (!Stek_Integer(1, $StekRep, $TopRep,$Bi))
{
/* Нехватка элементов в стеке $StekRep */
$Code_Error=43;
return 0;
}
$Number_Lexem=$Bi;
continue;
}
else
{
/* Ветка FALSE*/
/*y20: удалить вершину стека $StekRep, выйти из цикла;*/
if (!Stek_Integer(1, $StekRep, $TopRep,$Ai))
{
/* Нехватка элементов в стеке $StekRep */
$Code_Error=43;
return 0;
}
return 0;
}
}
break;
//ADD
case _SWITCH_:
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
if($Tab_Lexems[$Number_Lexem]->Code!=_LPAREN_)
{
/* Конструкция <оператор>. Неверный оператор SWITCH. */
$Code_Error=44;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
/* Обработка конструкции <выражение> */
ProcedureE();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <выражение> */
if ($Code_Error != -1)
return 0;
if($Tab_Lexems[$Number_Lexem]->Code!=_RPAREN_)
{
/* Конструкция <оператор>. Неверный оператор SWITCH. */
$Code_Error=44;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
/* y24: снять вершину стека $StekRes в переменную $Ai ($Ai<--$StekRes), */
/* занести в стек $StekSw значение 0 ($StekSw<--0), */
/* занести значение $Ai в стек $StekSw ($StekSw<--$Ai);*/
if (!Stek_Integer(1, $StekRes, $TopRes,$Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
$Bi=0;
if (!Stek_Integer(2, $StekSw, $TopSw, $Bi))
{
/* Переполнение стека $StekSw */
$Code_Error = 45;
return 0;
}
if (!Stek_Integer(2, $StekSw, $TopSw, $Ai))
{
/* Переполнение стека $StekSw */
$Code_Error = 45;
return 0;
}
if($Tab_Lexems[$Number_Lexem]->Code!=_BSWCH_)
{
/* Конструкция <оператор>. Неверный оператор SWITCH. */
$Code_Error=44;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
/* Обработка конструкции <выбор> */
ProcedureV();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <выбор> */
if ($Code_Error != -1)
return 0;
/* Обработка конструкции <умолчание> */
if($Tab_Lexems[$Number_Lexem]->Code==_DEFAULT_)
{
/* Обработка конструкции <умолчание> */
ProcedureX();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <умолчание> */
if ($Code_Error != -1)
return 0;
}
if($Tab_Lexems[$Number_Lexem]->Code!=_ESWCH_)
{
/* Конструкция <оператор>. Неверный оператор SWITCH. */
$Code_Error=44;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
/*y25: снять со стека $StekSw вершину (удалить) 2 раза*/
if (!Stek_Integer(1, $StekSw, $TopSw, $Ai))
{
/* Нехватка элементов в стеке $StekSw */
$Code_Error = 46;
return 0;
}
if (!Stek_Integer(1, $StekSw, $TopSw, $Ai))
{
/* Нехватка элементов в стеке $StekSw */
$Code_Error = 46;
return 0;
}
break;
case _IF_ :
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции <условие> */
ProcedureB();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <условие> */
if ($Code_Error!=-1)
return 0;
/* y18: в переменную $Ai снять элемент со стека $StekRes */
/* ($Ai<--$StekRes), если $Ai=1, то это истина, */
/* иначе - ложь */
if (!Stek_Integer(1, $StekRes, $TopRes, $Ai))
{
/* Нехватка элементов в стеке $StekRes */
$Code_Error=16;
return 0;
}
if ($Tab_Lexems[$Number_Lexem]->Code!=_THEN_)
{
/* Конструкция <оператор>. */
/* Отсутствует THEN в операторе IF. */
$Code_Error=20;
return 0;
}
/* проверка истинности условия: $Ai==1 (TRUE), */
/* $Ai==0 (FALSE) */
if ($Ai==1) /* Обработка TRUE */
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции */
/* <последовательность операторов> после ELSE */
ProcedureL();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции */
/* <последовательность операторов> */
if ($Code_Error!=-1)
return 0;
if ($Tab_Lexems[$Number_Lexem]->Code==_ELSE_)
{
/* y19: перейти на лексему номер $Tab_Lexems[$Number_Lexem]->Value-1 */
/* */
$Number_Lexem=$Tab_Lexems[$Number_Lexem]->Value-1;
if ($Tab_Lexems[$Number_Lexem]->Code==_ENDIF_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++)*/
$Number_Lexem++;
return 0;
}
else
{
/* Конструкция <оператор>. */
/* Отсутствует ENDIF в операторе IF.*/
$Code_Error=21;
return 0;
}
}
elseif ($Tab_Lexems[$Number_Lexem]->Code==_ENDIF_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
return 0;
}
else
{
/* Конструкция <оператор>. */
/* Отсутствует ENDIF в операторе IF.*/
$Code_Error=21;
return 0;
}
}
else /* Обработка FALSE */
{
/* y19: перейти на лексему номер $Tab_Lexems[$Number_Lexem]->Value-1 */
$Number_Lexem=$Tab_Lexems[$Number_Lexem]->Value-1;
if ($Tab_Lexems[$Number_Lexem]->Code==_ELSE_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции */
/* <последовательность операторов> после ELSE */
ProcedureL();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции */
/* <последовательность операторов> */
if ($Code_Error!=-1)
return 0;
if ($Tab_Lexems[$Number_Lexem]->Code==_ENDIF_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
return 0;
}
else
{
/* Конструкция <оператор>. */
/* Отсутствует ENDIF в операторе IF.*/
$Code_Error=21;
return 0;
}
}
elseif ($Tab_Lexems[$Number_Lexem]->Code==_ENDIF_)
{
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
return 0;
}
else
{
/* Конструкция <оператор>. */
/* Отсутствует ELSE или ENDIF в операторе IF.*/
$Code_Error=22;
return 0;
}
}
break;
endswitch;
return 0;
} /* End ProcdureS */
/*********************************************************************/
/* Процедура ProcedureL - обработка конструкции */
/* <последовательность операторов>::=<оператор> | */
/* <оператор>;<последовательность операторов> */
/*********************************************************************/
function ProcedureL()
{
global $Code_Error;
global $Tab_Lexems;
global $Number_Lexem;
while (TRUE):
/* Обработка конструкции <оператор> */
ProcedureS();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <оператор> */
if ($Code_Error!=-1)
return 0;
/* Проверка символа ";" - если нет разделителя операторов, то выходим!*/
if ($Tab_Lexems[$Number_Lexem]->Code!=_SEMICOLON_)
return 0;
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
endwhile;
return 0;
} /* End ProcedureL */
/* Начало Синтаксического анализа совмещённого с интерпретацией */
/* функция y0: инициализация стеков и переменных */
/* Инициализация переменных */
global $Tab_Lexems;
global $Number_Lexem;
global $Code_Error;
global $ArrIdent;
global $TopIdent;
global $TopRel;
global $TopRes;
global $StekRes;
global $TopSum;
global $StekSum;
global $StekMul;
global $StekRel;
global $StekIdent;
global $Ai;
global $Bi;
$Ai=0;
$Bi=0;
//ADD
global $StekRep;
global $StekSw;
global $TopFRep;
global $TopSw;
Stek_Integer(0, $StekFor, $TopFor, $Ai);
Stek_Integer(0, $StekSw, $TopSw, $Ai);
/* Инициализация стеков */
Stek_Integer(0, $ArrIdent, $TopRes, $Ai);
Stek_Integer(0, $StekRes, $TopRes, $Ai);
Stek_Integer(0, $StekIdent, $TopIdent, $Ai);
Stek_Integer(0, $StekMul, $TopMul, $Ai);
Stek_Integer(0, $StekSum, $TopSum, $Ai);
Stek_Integer(0, $StekRel, $TopRel, $Ai);
/* Начало просмотра массива лексем */
$Number_Lexem=1;
if ($Tab_Lexems[$Number_Lexem]->Code!=_BEGIN_)
{
/* Конструкция <программа>. Нет BEGIN. */
$Code_Error=12;
return 0;
}
/* функция y4: чтение следующей лексемы ($Number_Lexem++) */
$Number_Lexem++;
/* Обработка конструкции <последовательность операторов> */
ProcedureL();
/* Проверка на ошибки, появившиеся в процессе */
/* обработки конструкции <последовательность операторов> */
if ($Code_Error!=-1)
return 0;
if ($Tab_Lexems[$Number_Lexem]->Code!=_END_)
{
/* Конструкция <программа>. Нет END. */
$Code_Error=13;
return 0;
}
/* y20: нормальное завершение работы синтаксического анализатора */
global $ct_buf;
echo('<br><hr><br><font color="blue">НОРМАЛЬНОЕ ЗАВЕРШЕНИЕ РАБОТЫ ИНТЕРПРЕТАТОРА</font><br><br><form action="INTERFACE.php" method="POST">
<input type="submit" value=" ОК " >
<input name="source" type="hidden" value="'.$ct_buf.'">
</form>'); } ?>
2.2 Разработка тестов и тестирование модифицированного языка МИЛАН
1) BEGIN
next:=1;
rng:=1;
c1:=READ;
c2:=c1;
{ это комментарий }
WHILE next=1 DO
c1:=c1/10;
IF c1=0 THEN
next:=0
ELSE
rng++
ENDIF
ENDDO;
OUTPUT(rng); { это комментарий }
k:=1;
REPEAT
SWITCH(k)
{
CASE 1 : rez:=c2-(c2/10)*10
CASE 2 : rez:=c2/10
CASE 3 : rez:=c2/100
DEFAULT: rez:=999
};
OUTPUT(rez);
k++;
UNTIL k<=rng
END
2)BEGIN
y:=3;
x:=5;
t:=1;
SWITCH(x){
CASE 5: OUTPUT(y);
x++;
CASE 0: OUTPUT(x);
DEFAULT: OUTPUT(t)};
OUTPUT (x)
END
3) BEGIN
x:=0;
n:=5;
i:=0;
REPEAT
z:=READ;
x:=x+z;
n:=n-1;
i:=i+10;
UNTIL i<100;
OUTPUT(x)
END
4) BEGIN
x:=0;
n:=5;
i:=0;
REPEAT
z:=READ;
x:=x+z;
n:=n-1;
i:=i+10;
UNTIL i<100;
OUTPUT(x)
END
Примеры с ошибкой
1) BEGIN
y:=3;
x:=5;
t:=1;
{
CASE 5: OUTPUT(y);
x++;
CASE 0: OUTPUT(x);
DEFAULT: OUTPUT(t)};
OUTPUT (x)
END
2) BEGIN
y:=3;
x:=1;
t:=1;
d:=0;
SWITCH(d){
CASE 5: OUTPUT(y);
x++;
CASE 0: IF x>2
OUTPUT(1);
ELSE
OUTPUT(0);
ENDIF;
CASE 2: OUTPUT(d);
DEFAULT: OUTPUT(t)};
OUTPUT (x)
END
3) BEGIN { это комментарий }
x:=0;
n:=5;
i:=0;
z:=READ;
x:=x+z;
n:=n-1;
i:=i+10;
UNTIL i<50
t:=0;
d:=5;
WHILE d>0 DO
k:=READ;
t:=t+k;
d:=d-1;
ENDDO;
OUTPUT(t);
OUTPUT(x)
END { это комментарий }
4) BEGIN
y:=3;
x:=5;
t:=1;
SWITCH(x){
CASE 5: t:=0;
d:=5;
d>0
k:=READ;
t:=t+k;
d:=d-1;
ENDDO;
OUTPUT(t);
CASE 0: OUTPUT(x);
DEFAULT: OUTPUT(t)};
OUTPUT (x)
END
5) BEGIN
x:=1;
n:=5;
WHILE n>0
z:=5*x+x;
b:=b+z;
n:=n-1;
ENDDO;
OUTPUT(b);
OUTPUT(x)
END
ЗАКЛЮЧЕНИЕ
Результатами курсовой работы являются:
1) грамматика модифицированного языка МИЛАН в виде синтаксических диаграмм Вирта;
2) теоретическое описание лексического анализатора модифицированного языка МИЛАН;
3) теоретическое описание процесса расстановки ссылок модифицированного языка МИЛАН;
4) теоретическое описание интерпретатора модифицированного языка МИЛАН;
5) программная реализация интерпретатора модифицированного языка МИЛАН;
6) результаты тестирования интерпретатора модифицированного языка МИЛАН.
В результате выполнения курсовой работы были приобретены следующие знания, умения и навыки:
знания:
об основных принципах, связанных с теоретической и программной разработкой предметно-ориентированных языков
умения:
- формализованного представления грамматики предметно-ориентированного языка в виде диаграмм Вирта;
- теоретического описания моделей основыных компонентов трансляторов в виде R-схем и семнтических функций;
- оценивать качество программного обеспечения;
- логически верно, аргументировано и ясно строить письменную и устную речь.
СПИСОК ЛИТЕРТУРЫ
1. Орлов, С.А. Технология разработки программного обеспечения 4-е изд.Стандарт третьего поколения. / С.А. Орлов, Б.Я. Цилькер. - Санкт-Петербург: Питер, 2012. - 608 с.
2. Пентус, А.Е. Математическая теория формальных языков / А.Е. Пентус. - Москва: Бином, 2006. - 247 с.
3. Рыбанов, А.А. Методические указания к выполнению контрольной работы по дисциплине "Основы трансляции" [Электронный ресурс] Электрон. текстовые дан. (1 файл: 2,25 МБ). / А.А. Рыбанов. - Волжский: ВПИ (филиал) ВолгГТУ, 2011. - Системн. требования: Windows 95 и выше; ПК с процессором 486 +; CD-ROM. - номер гос. регистрации 0321100468.
4. Рыбанов, А.А. Методические указания к выполнению курсовой работы по дисциплине "Теория автоматов и формальных языков" Сборник «Методические указания». Выпуск 5. / А.А. Рыбанов. - Волгоград: ВолгГТУ, 2012. - номер гос. регистрации 0321202238.
5. Рыбанов, А.А. Методические указания к выполнению курсовой работы по дисциплине "Основы трансляции" [Электронный ресурс] Электрон. текстовые дан. (1 файл: 552 КБ). / А.А. Рыбанов. - Волжский: ВПИ (филиал) ВолгГТУ, 2011. - Системн. требования: Windows 95 и выше; ПК с процессором 486 +; CD-ROM. - номер гос. регистрации 0321100467.
6. Рыбанов, А.А. Основы трансляции для студентов заочной формы обучения. / А.А. Рыбанов. - Волгоград: ВолгГТУ, 2005. - 80 с.
7. Рыбанов, А.А. Основы трансляции: лабораторный практикум для студентов заочной формы обучения по специальности 220200 "Автоматизированные системы обработки информации и управления" / А.А. Рыбанов. - Волгоград: ВолгГТУ, 2007. - 48 с.
8. Фролов, Е.М. Разработка и документирование программных средств / Е.М. Фролов, Ю.Л. Чигиринский. - Волгоград: ВолгГТУ, 2011. - 116 с.
Размещено на Allbest.ru
...Подобные документы
Проектирование лексического и синтаксического анализаторов учебного языка. Правила преобразования логических выражений в ПОЛИЗ. Формирование триад, оптимизация их списка. Логическая структура программы. Тестирование модулей транслятора-интерпретатора.
курсовая работа [1,3 M], добавлен 28.05.2013Изучение алгоритма рекурсивного спуска и системы построения грамматики с помощью лексического анализатора Lex. Написание программы интерпретатора языка разметки HTML. Проверка входной последовательности на корректность входа как общая функция программы.
контрольная работа [226,7 K], добавлен 25.12.2012Входная грамматика в структурированной форме. Функции переходов символьного преобразователя. Работа лексического анализатора. Структуры данных, символы действия. Описание семантики перевода. Построение и программная реализация атрибутного преобразователя.
курсовая работа [128,9 K], добавлен 03.07.2013Аналитический обзор существующих программ-редакторов схем (Microsoft Office Visio 2007, FCEditor, редактор блок-схем). Математическое описание программы и её интерпретатора. Описание системы и руководство пользователя, XML и текст редактора схем.
дипломная работа [2,1 M], добавлен 07.07.2012Функции и основные компоненты систем программирования. Средства создания программ. Трансляторы языков программирования. Принципы и фазы работы компилятора, трансформация языка программирования в машинный код. Механизм преобразования интерпретатора.
презентация [3,3 M], добавлен 07.02.2012Описание синтаксиса и семантики входного языка. Описание типов лексем, определение их синтаксиса. Построение диаграммы лексического анализатора, а также его таблицы, тестирование. Построение КС-грамматики входного языка. Описание промежуточного языка.
курсовая работа [83,0 K], добавлен 23.01.2014Создание интерактивного интерпретатора для мелких вычислений стандартного "Калькулятора" Windows. Его реализация относительно несложного языка программирования, работающий в интерактивном режиме, то есть выполняющий вводимые команды с клавиатуры.
курсовая работа [287,3 K], добавлен 17.09.2008Методы грамматического разбора при разработке учебного транслятора. Проектирование лексического анализатора и магазинного автомата. Программная реализация синтаксического анализатора текстового языка высокого уровня. Разработка модуля интерпретации.
курсовая работа [697,2 K], добавлен 06.01.2013Классификация методов оптимизации. Обзор и выбор языка C#. Алгоритмический анализ задачи, описание алгоритма решения. Графические схемы разработанных алгоритмов. Разработка приложения и результаты тестовых испытаний. Интерфейс пользователя, тестирование.
курсовая работа [1,6 M], добавлен 08.03.2016Аналоги текстовых редакторов с русскоязычным интерфейсом. Разработка и тестирование программного продукта, позволяющего работать с текстом и файлами в редакторе на языке программирования, основанным на русском языке. Алгоритм функционала программы.
дипломная работа [2,8 M], добавлен 21.07.2013Структура, классификация и требования к реализации компилятора. Проектирование и реализация анализирующей части компилятора языка С++. Способы реализации лексического анализа. Алгоритм работы синтаксического анализатора. Принципы программной реализации.
курсовая работа [774,2 K], добавлен 26.01.2013Основные особенности эволюционных алгоритмов. Описание алгоритмов селекции, мутации, скрещивания, применяемых для реализации генетических алгоритмов. Вычисление функции приспособленности. Программная реализация. Тестирование и руководство пользователя.
курсовая работа [1,3 M], добавлен 11.03.2014Исследование симметричных алгоритмов блочного шифрования. Минусы и плюсы алгоритма IDEA. Разработка программы аутентификации пользователя и сообщений на основе алгоритма IDEA. Выбор языка программирования. Тестирование и реализация программного средства.
курсовая работа [314,2 K], добавлен 27.01.2015Разработка программы-интерпретатора, способной получать на входе текстовый файл (в формате ASCII или ANSI) с текстом программы и на выходе выводить на экран результаты вычислений, определяемых программистом. Выбор лексем, интерфейс и листинг программы.
курсовая работа [132,0 K], добавлен 12.03.2013Методика разработки и частичная реализация транслятора для языка "С" с использованием языка "С++", производящего разбиение на минимальные неделимые конструкции языка исходной цепочки символов основываясь на лексике языка. Анализ работы программы.
курсовая работа [841,3 K], добавлен 19.03.2012Аналитический обзор средств и языков описания интеллектуальных порталов. Устройство и особенности языка технологии OSTIS, результаты ее анализа. Разработка предметно-ориентированного языка проектирования интеллектуальных порталов. Описание пример модели.
дипломная работа [2,5 M], добавлен 08.11.2015Нормализация предметной области "Сайт знакомств" и ее программная реализация с использованием СУБД MySQL, языка HTML, технологии PHP и ADO, скриптовых языков VBScript или JavaScript. Руководство программиста, тестирование, исходный текст приложения.
реферат [29,0 K], добавлен 09.09.2010Разработка анализирующей части компилятора для выполнения проверки исходной программы на соответствие грамматике языка, правилам семантики и построения внутреннего представления. Описание анализаторов: лексического, синтаксического и семантического.
контрольная работа [704,9 K], добавлен 01.02.2013Целые числа в позиционных системах счисления. Недостатки двоичной системы. Разработка алгоритмов, структур данных. Программная реализация алгоритмов перевода в различные системы счисления на языке программирования С. Тестирование программного обеспечения.
курсовая работа [593,3 K], добавлен 03.01.2015Анализ методов реализации интеллектуальных игр в системе человек-робот. Разработка архитектуры программного комплекса, выбор языка программирования. Алгоритм преобразования данных. Тестирование программного комплекса, редактирование и исправление ошибок.
дипломная работа [2,6 M], добавлен 27.10.2017
