Курсовые проекты / Soft / Labs / TrdMake

unit TrdMake; {!!! Зависит от входного языка !!!}

interface
{ Модуль, обеспечивающий создание списка триад
на основе структуры синтаксического разбора }

uses LexElem, Triads, SyntSymb;

function MakeTriadList(symbTop: TSymbol;
listTriad: TTriadList): TLexem;
{ Функция создания списка триад начиная от корневого
символа дерева синтаксического разбора.
Функция возвращает nil при успешном выполнении, иначе она
возвращает ссылку на лексему, где произошла ошибка }

implementation

uses LexType, TrdType;

function GetLexem(symbOp: TSymbol): TLexem;
{ Функция, проверяющая является ли операнд лексемой }
begin
case symbOp.Rule of
{ Если правил нет, это лексема! }
0: Result := symbOp.Lexem;
{ Если дочерний символ построен по правилу №12,
то это лексема }
12: Result := symbOp[0].Lexem;
{ Если это арифметические скобки, надо проверить,
не является ли лексемой операнд в скобках }
13: Result := GetLexem(symbOp[1])
{ Иначе это не лексема }
else Result := nil;
end;
end;

function MakeTriadListNOP(symbTop: TSymbol;
listTriad: TTriadList): TLexem;
{ Функция создания списка триад начиная от корневого
символа дерева синтаксического разбора
(без добавления триады NOP в конец списка) }
var
Opers: TOpArray; { массив операндов триад }
iIns1,iIns2,iIns3: integer;
{ переменные для запоминания индексов триад в списке }
function MakeOperand(iOp{номер операнда},
iSymOp{порядковый номер символа в синт. конструкции},
iMin{минимальная позиция триады в списке},
iSymErr: integer;
{номер лексемы, на которой позиционировать ошибку}
var iIns: integer{индекс триады в списке}): TLexem;
{ Функция формирования ссылки на операнд }
var lexTmp: TLexem;
begin
{ Проверяем, является ли операнд лексемой }
lexTmp := GetLexem(symbTop[iSymOp]);
if lexTmp <> nil then
{ Если да, то берем имя операнда в зависимости от типа }
with lexTmp do
begin
if LexType = LEX_VAR then
begin
{ Если это переменная, то запоминаем ссылку
на таблицу идентификаторов }
Opers[iOp].OpType := OP_VAR;
Opers[iOp].VarLink := VarInfo;
end
else
if LexType = LEX_CONST then
begin
{ Если это константа, то запоминаем её значение }
Opers[iOp].OpType := OP_CONST;
Opers[iOp].ConstVal := ConstVal;
end
else
begin
{ Иначе это ошибка, возвращаем лексему
как указатель на место ошибки }
Result := lexTmp;
Exit;
end;
iIns := iMin;
Result := nil;
end
else
{ иначе это синтаксическая конструкция }
begin
{ Вызываем рекурсивно функцию создания списка триад }
Result := MakeTriadListNOP(symbTop[iSymOp],listTriad);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Запоминаем индекс триады }
iIns := listTriad.Count;
{ Если индекс меньше минимального (список не менялся) -
это ошибка }
if iIns <= iMin then
begin
Result := symbTop[iSymErr].Lexem;
Exit;
end;
{ Запоминаем ссылку на предыдущую триаду }
Opers[iOp].OpType := OP_LINK;
Opers[iOp].TriadNum := iIns-1;
end;
end;
function MakeOperation(
Trd: TTriadType{тип создаваемой триады}): TLexem;
{ Функция создания списка триад для линейных операций }
begin
{ Создаем ссылку на первый операнд }
Result := MakeOperand(1{op},0{sym},listTriad.Count,
1{sym err},iIns1);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Создаем ссылку на второй операнд }
Result := MakeOperand(2{op},2{sym},iIns1,
1{sym err},iIns2);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Создаем саму триаду с двумя ссылками на операнды }
listTriad.Add(TTriad.Create(Trd,Opers));
end;
begin
{ Тело главной функции. Начинаем с выбора типа правила }
case symbTop.Rule of
2,5:{'ifEthenEelseE'}
{ Полный условный оператор }
begin
{ Запоминаем ссылку на первый операнд
(условие "if") }
Result := MakeOperand(1{op},1{sym},listTriad.Count,
0{sym err},iIns1);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Второй операнд - ссылка на триаду,
номер которой пока не известен }
Opers[2].OpType := OP_LINK;
Opers[2].TriadNum := 0;
{ Создаем триаду типа "IF" }
listTriad.Add(TTriad.Create(TRD_IF,Opers));
{ Запоминаем ссылку на второй операнд
(раздел "then") }
Result := MakeOperand(2{op},3{sym},iIns1,
2{sym err},iIns2);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Заполняем операнды для триады типа "JMP", которая
должна быть в конце раздела "then" }
Opers[1].OpType := OP_CONST;
Opers[1].ConstVal := 1;
{ Второй операнд - ссылка на триаду, номер которой
пока не известен }
Opers[2].OpType := OP_LINK;
Opers[2].TriadNum := 0;
{ Создаем триаду типа "JMP" }
listTriad.Add(TTriad.Create(TRD_JMP,Opers));
{ Для созданной ранее триады типа "IF" ставим
ссылку в конец последовательности триад,
созданной для раздела "then" }
listTriad[iIns1].Links[2] := iIns2+1;
{ Запоминаем ссылку на третий операнд
(раздел "else") }
Result := MakeOperand(2{op},5{sym},iIns2,
4{sym err},iIns3);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Для созданной ранее триады типа "JMP" ставим
ссылку в конец последовательности триад,
созданной для раздела "else" }
listTriad[iIns2].Links[2] := iIns3;
end;
3:{'ifEthenE'}
{ Неполный условный оператор }
begin
{ Запоминаем ссылку на первый операнд
(условие "if") }
Result := MakeOperand(1{op},1{sym},listTriad.Count,
0{sym err},iIns1);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Второй операнд - ссылка на триаду,
номер которой пока не известен }
Opers[2].OpType := OP_LINK;
Opers[2].TriadNum := 0;
{ Создаем триаду типа "IF" }
listTriad.Add(TTriad.Create(TRD_IF,Opers));
{ Запоминаем ссылку на второй операнд
(раздел "then") }
Result := MakeOperand(2{op},3{sym},iIns1,
2{sym err},iIns2);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Для созданной ранее триады типа "IF" ставим
ссылку в конец последовательности триад,
созданной для раздела "then" }
listTriad[iIns1].Links[2] := iIns2;
end;
4,6:{'a:=E'}
{ Оператор присвоения }
begin
{ Если первый операнд не является переменной,
то это ошибка }
if symbTop[0].Lexem.LexType <> LEX_VAR then
begin
Result := symbTop[0].Lexem;
Exit;
end;
{ Создаем ссылку на первый операнд - переменную }
Opers[1].OpType := OP_VAR;
Opers[1].VarLink := symbTop[0].Lexem.VarInfo;
{ Создаем ссылку на второй операнд }
Result := MakeOperand(2{op},2{sym},listTriad.Count,
1{sym err},iIns1);
{ Если произошла ошибка, прерываем выполнение }
if Result <> nil then Exit;
{ Создаем триаду типа "присвоение" }
listTriad.Add(TTriad.Create(TRD_ASSIGN,Opers));
end;
{ Генерация списка триад для линейных операций }
7:{'EorE'} Result := MakeOperation(TRD_OR);
8:{'ExorE'} Result := MakeOperation(TRD_XOR);
10:{'EandE'} Result := MakeOperation(TRD_AND);
{ Для скобочного выражения нужно рекурсивно вызвать
функцию для второго символа }
13:{'(E)'}
Result := MakeTriadListNOP(symbTop[1],listTriad);
{ Для лексем ничего не нужно делать }
12: Result := nil;
{ Во всех остальных случаях нужно рекурсивно вызвать
функцию для первого символа }
else Result := MakeTriadListNOP(symbTop[0],listTriad);
end{case Rule};
end;

function MakeTriadList(symbTop: TSymbol;
listTriad: TTriadList): TLexem;
{ Функция создания списка триад начиная от корневого
символа дерева синтаксического разбора }
var
i: integer;
Opers: TOpArray;
Trd: TTriad;
begin
{ Создаем список триад }
Result := MakeTriadListNOP(symbTop,listTriad);
{ Если произошла ошибка, прерываем выполнение,
иначе продолжаем... }
if Result = nil then
with listTriad do
begin
{ Создаем пустую триаду "NOP" в конце списка }
Opers[1].OpType := OP_CONST;
Opers[1].ConstVal := 0;
Opers[2].OpType := OP_CONST;
Opers[2].ConstVal := 0;
Add(TTriad.Create(TRD_NOP,Opers));
{ Для всех триад в списке расставляем флаг ссылки }
for i:=Count-1 downto 0 do
begin
Trd := Triads[i];
if Trd.TrdType in [TRD_IF,TRD_JMP] then
begin
{ Если триада типа "переход" ("IF" или "JMP")
и ссылается на другую триаду,
то ту триаду надо пометить }
if Trd.OpTypes[2] = OP_LINK then
listTriad[Trd.Links[2]].IsLinked := True;
end;
end;
end;
end;

end.