Курсовые проекты / Soft / Common / Triads

unit Triads;

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

uses Classes, TblElem, LexElem, TrdType;

type
{ Предварительное описание класса триад }
TTriad = class;
{ Типы операндов: константа, переменная,
  ссылка на другую триаду }
TOpType = (OP_CONST, OP_VAR, OP_LINK);

{ Структура данных для описания операнда в триадах }
TOperand = record
  { Тип операнда }
  case OpType: TOpType of
    OP_CONST: (ConstVal: integer);
    { для константы - её значение }
    OP_VAR:   (VarLink: TVarInfo);
    { для переменной - ссылка на элемент
      таблицы идентификаторов }
    OP_LINK:  (TriadNum: integer);
    { для триады - номер триады }
end;
{ Массив операндов из двух элементов }
TOpArray = array[1..2] of TOperand;

{ Структура данных для описания триады }
TTriad = class(TObject)
 private
  { Тип триады }
  TriadType: TTriadType;
  { Массив операндов }
  Operands: TOpArray;
 public
{ Дополнительная информация для оптимизирующих алгоритмов }
  Info: longint;
  { Флаг наличия ссылки на эту триаду }
  IsLinked: Boolean;
  { Конструктор для создания триады }
  constructor Create(Typ: TTriadType; const Ops: TOpArray);
  { Функции для чтения и записи операндов }
  function GetOperand(iIdx: integer): TOperand;
  procedure SetOperand(iIdx: integer; Op: TOperand);
  { Функции для чтения и записи ссылок на другие триады }
  function GetLink(iIdx: integer): integer;
  procedure SetLink(iIdx: integer; TrdN: integer);
  { Функции для чтения и записи типа операндов }
  function GetOpType(iIdx: integer): TOpType;
  procedure SetOpType(iIdx: integer; OpT: TOpType);
  { Функции для чтения и записи значений констант }
  function GetConstVal(iIdx: integer): integer;
  procedure SetConstVal(iIdx: integer; iVal: integer);
  { Свойства триады, основанные на описанных выше
    функциях }
  property TrdType: TTriadType read TriadType;
  property Opers[iIdx: integer]: TOperand read GetOperand
                                write SetOperand; default;
  property Links[iIdx: integer]: integer read GetLink
                                write SetLink;
  property OpTypes[iIdx: integer]: TOpType read GetOpType
                                write SetOpType;
  property Values[iIdx: integer]: integer read GetConstVal
                                write SetConstVal;
  { Функция, проверяющая совпадение (эквивалентность)
    двух триад }
  function IsEqual(Trd1: TTriad): Boolean;
  { Функция, формирующая строковое представление триады }
  function MakeString(i: integer): string;
 end;

{ Класс для описания списка триад и работы с ним }
TTriadList = class(TList)
 public
  { Процедура очистки списка и деструктор
    для удаления списка }
  procedure Clear; override;
  destructor Destroy; override;
  { Процедура вывода списка триад в список строк
    для отображения списка триад }
  procedure WriteToList(list: TStrings);
  { Процедура удаления триады из списка }
  procedure DelTriad(iIdx: integer);
  { Функция получения триады из списка по её номеру }
  function GetTriad(iIdx: integer): TTriad;
  { Свойство списка триад для доступа к нему
    по номеру триады }
  property Triads[iIdx: integer]: TTriad read GetTriad;
     default;
end;

{ Процедура удаления из списка триад
  всех триад заданного типа }
procedure DelTriadTypes(listTriad: TTriadList;
                        TrdType: TTriadType);

implementation

uses SysUtils, FncTree, LexType;

constructor TTriad.Create(Typ: TTriadType;
                          const Ops: TOpArray);
{ Конструктор создания триады }
var i: integer;
begin
  { Вызываем конструктор базового класса }
  inherited Create;
  { Запоминаем тип триады }
  TriadType := Typ;
  { Запоминаем два операнда триады }
  for i:=1 to 2 do Operands[i] := Ops[i];
  { Очищаем поле дополнительной информации
    и поле внешней ссылки }
  Info := 0;
  IsLinked := False;
end;

function TTriad.GetOperand(iIdx: integer): TOperand;
{ Функция получения данных об операнде триады
  по его номеру }
begin
  Result := Operands[iIdx];
end;

procedure TTriad.SetOperand(iIdx: integer; Op: TOperand);
{ Функция записи данных операнда триады по его номеру }
begin
  Operands[iIdx] := Op;
end;

function TTriad.GetLink(iIdx: integer): integer;
{ Функция получения ссылки на другую триаду из операнда
  по его номеру }
begin
  Result := Operands[iIdx].TriadNum;
end;

procedure TTriad.SetLink(iIdx: integer; TrdN: integer);
{ Функция записи номера ссылки на другую триаду
  в операнд по его номеру }
begin
  Operands[iIdx].TriadNum := TrdN;
end;

function TTriad.GetOpType(iIdx: integer): TOpType;
{ Функция получения типа операнда по его номеру }
begin
  Result := Operands[iIdx].OpType;
end;

function TTriad.GetConstVal(iIdx: integer): integer;
{ Функция записи типа операнда по его номеру }
begin
  Result := Operands[iIdx].ConstVal;
end;

procedure TTriad.SetConstVal(iIdx: integer; iVal: integer);
{ Функция получения значения константы в операнде
  по его номеру }
begin
  Operands[iIdx].ConstVal := iVal;
end;

procedure TTriad.SetOpType(iIdx: integer; OpT: TOpType);
{ Функция записи значения константы в операнд
  по его номеру }
begin
  Operands[iIdx].OpType := OpT;
end;

function IsEqualOp(const Op1,Op2: TOperand): Boolean;
{ Функция проверки совпадения (эквивалентности)
  двух операндов }
begin
  { Операнды равны, если совпадают их типы }
  Result := (Op1.OpType = Op2.OpType);
  { и значения в зависимости от типа }
  if Result then
  case Op1.OpType of
    OP_CONST: Result := (Op1.ConstVal = Op2.ConstVal);
    OP_VAR:   Result := (Op1.VarLink = Op2.VarLink);
    OP_LINK:  Result := (Op1.TriadNum = Op2.TriadNum);
  end;
end;

function TTriad.IsEqual(Trd1: TTriad): Boolean;
{ Функция, проверяющая совпадение (эквивалентность)
  двух триад }
begin
  { Триады эквивалентны, если совпадают их типы }
  Result := (TriadType = Trd1.TriadType)
        { и оба операнда }
        and IsEqualOp(Operands[1],Trd1[1])
        and IsEqualOp(Operands[2],Trd1[2]);
end;

function GetOperStr(Op: TOperand): string;
{ Функция формирования строки для отображения
  оператора триады }
begin
  case Op.OpType of
    OP_CONST: Result := IntToStr(Op.ConstVal);
    OP_VAR:   Result := Op.VarLink.VarName;
    OP_LINK:  Result := '^'+ IntToStr(Op.TriadNum+1);
  end{case};
end;

function TTriad.MakeString(i: integer): string;
begin
  Result := Format('%d:'#9'%s (%s, %s)',
            [i+1,TriadStr[TriadType],
             GetOperStr(Opers[1]),GetOperStr(Opers[2])]);
end;

destructor TTriadList.Destroy;
{ Деструктор для удаления списка триад }
begin
  { Очищаем список триад }
  Clear;
  { Вызываем деструктор базового класса }
  inherited Destroy;
end;

procedure TTriadList.Clear;
{ Процедура очистки списка триад }
var i: integer;
begin
  { Освобождаем память для всех триад из списка }
  for i:=Count-1 downto 0 do TTriad(Items[i]).Free;
  { Вызываем функцию базового класса }
  inherited Clear;
end;

procedure TTriadList.DelTriad(iIdx: integer);
{ Функция удаления триады из списка триад }
begin
  { Если это не последняя триада }
  if iIdx < Count-1 then
   { и если на нее есть ссылка - переставляем
     флаг ссылки на предыдущую }
   TTriad(Items[iIdx+1]).IsLinked :=
      TTriad(Items[iIdx+1]).IsLinked
      or TTriad(Items[iIdx]).IsLinked;
  { Освобождаем память триады }
  TTriad(Items[iIdx]).Free;
  { Удаляем ссылку на триаду из списка }
  Delete(iIdx);
end;

function TTriadList.GetTriad(iIdx: integer): TTriad;
{ Функция выборки триады из списка по её номеру }
begin
  Result := TTriad(Items[iIdx]);
end;

procedure TTriadList.WriteToList(list: TStrings);
{ Процедура вывода списка триад в список строк
  для отображения списка триад }
var
  i,iCnt: integer;
begin
  { Очищаем список строк }
  list.Clear;
  iCnt := Count-1;
  { Для всех триад из списка триад }
  for i:=0 to iCnt do
   { Формируем строковое представление триады
     и добавляем его в список строк }
   list.Add(TTriad(Items[i]).MakeString(i));
end;

procedure DelTriadTypes(listTriad: TTriadList;
                        TrdType: TTriadType);
{ Процедура удаления из списка триад всех триад
  заданного типа }
var
  i,j,iCnt,iDel: integer;
  listNum: TList;
  Trd: TTriad; { список для запоминания изменений
                 индексов триад }
begin
  { Вначале изменение индекса нулевое }
  iDel := 0;
  iCnt := listTriad.Count-1;
  { Создаем список для запоминания изменений
    индексов триад }
  listNum := TList.Create;
  try
    { Для всех триад списка выполняем запоминание
      изменений индекса }
    for i:=0 to iCnt do
    begin
      { Запоминем изменение индекса данной триады }
      listNum.Add(TObject(iDel));
      { Если эта триада удаляемого типа,
        то увеличиваем изменение индекса }
      if listTriad[i].TriadType = TrdType then Inc(iDel);
    end;
    { Для всех триад списка изменяем индексы ссылок }
    for i:=iCnt downto 0 do
    begin
      Trd := listTriad[i];
      { Если эта триада удаляемого типа, то удаляем ее }
      if Trd.TriadType = TrdType then listTriad.DelTriad(i)
      else
      { Иначе для обоих операндов триады смотрим,
        не является ли он ссылкой }
      for j:=1 to 2 do
       if Trd[j].OpType = OP_LINK then
        { Если операнд является ссылкой на триаду,
          уменьшаем её индекс }
        Trd.Links[j] :=
          Trd.Links[j] - integer(listNum[Trd.Links[j]]);
    end;
    { Уничтожаем список для запоминания
      изменений индексов триад }
    finally listNum.Free;
  end;
end;

end.