Курсовая работа1 / CodeGenerator / UCcCodeGeneratorCommands

{
C-like language compiler v0.1.0.485

12 november 2007

Copyright (C) 2006, 2007 Igor Krooshch
rheo.ikro@gmail.com

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
}

unit UCcCodeGeneratorCommands;

interface

uses
SysUtils, Classes;

type
TCcCommandType = (
ctPush, ctPop, ctTest, ctMov, ctJz, ctJmp, ctInc, ctDec, ctImul, ctIdiv,
ctAdd, ctSub, ctNeg, ctAnd, ctOr, ctXor, ctNot, ctShr, ctShl, ctNop,
ctCmp, ctSetE, ctSetNE, ctSetG, ctSetGE, ctSetL, ctSetLE, ctComment, ctCdq,
ctRet, ctCall, ctLea, ctInvoke, ctSetA, ctSetB, ctSetAE, ctSetBE,

ctFld, ctFild, ctFldz, ctFst, ctFstp, ctFist, ctFistp, ctFadd,
ctFiadd, ctFsub, ctFisub, ctFmul, ctFimul, ctFdiv, ctFidiv,
ctFcom, ctFicom, ctFicomp,
ctFtst, ctSahf, ctFchs, ctFabs, ctFsqrt, ctFcomi);

TCcSegmentType = (stCode, stData, stStack, stExt);

TCcLabelType = (ltFunc, ltIf, ltWhile, ltFor, ltDoWhile);

TCcCommand = class
private
FLab: string;
FCommand: TCcCommandType;
FComment: string;
public
constructor Create(ACommand: TCcCommandType; const AComment: string = '');

procedure WriteOutput(A: TStringList); virtual;

function GenerateComment: string;

property Command: TCcCommandType read FCommand;
property Lab: string read FLab write FLab;
property Comment: string read FComment write FComment;
end;


TCcCommentCommand = class(TCcCommand)
public
constructor Create(const AText: string); reintroduce;
procedure WriteOutput(A: TStringList); override;
end;


TCcOneOperandCommand = class(TCcCommand)
private
FOperand: string;
public
constructor Create(
ACommand: TCcCommandType; const AOperand: string;
const AComment: string = ''); reintroduce;
procedure WriteOutput(A: TStringList); override;

property Operand: string read FOperand;
end;


TCcTwoOperandsCommand = class(TCcCommand)
private
FLeftOperand: string;
FRightOperand: string;
public
constructor Create(
ACommand: TCcCommandType;
const ALeft, ARight: string; const AComment: string = ''); reintroduce;
procedure WriteOutput(A: TStringList); override;

property Left: string read FLeftOperand;
property Right: string read FRightOperand;
end;


TCcHeader = class(TCcCommand)
private
FText: string;
public
constructor Create(
const AText: string; const AComment: string = ''); reintroduce;

procedure WriteOutput(A: TStringList); override;

property Text: string read FText;
end;


TCcVarDeclaration = class(TCcHeader)
private
FGlobal: boolean;
public
constructor Create(
AText: string; AGlobal: boolean;
const AComment: string = ''); reintroduce;

property Global: boolean read FGlobal;
end;

const
SEGMENT_TYPE: array[TCcSegmentType] of string = ('', 'ds', 'ss', 'es');


implementation

uses
Types, TypInfo;

{ TCcCommand }

constructor TCcCommand.Create(ACommand: TCcCommandType; const AComment: string);
begin
FCommand := ACommand;
FComment := AComment;
end;


function TCcCommand.GenerateComment: string;
begin
Result := '';
if FComment <> '' then
Result := #9 + '; ' + FComment;
end;


procedure TCcCommand.WriteOutput(A: TStringList);
var
s: string;
begin
s := GetEnumName(TypeInfo(TCcCommandType), Ord(Command));
Delete(s, 1, 2);
A.Add(' ' + s + GenerateComment);
end;


{ TCcOneOperandCommand }

constructor TCcOneOperandCommand.Create(
ACommand: TCcCommandType; const AOperand: string; const AComment: string);
begin
inherited Create(ACommand, AComment);
FOperand := AOperand;
end;


procedure TCcOneOperandCommand.WriteOutput(A: TStringList);
var
s: string;
begin
s := GetEnumName(TypeInfo(TCcCommandType), Ord(Command));
Delete(s, 1, 2);
A.Add(' ' + Format('%s %s', [s, Operand]) + GenerateComment);
end;


{ TCcTwoOperandsCommand }

constructor TCcTwoOperandsCommand.Create(
ACommand: TCcCommandType; const ALeft, ARight: string;
const AComment: string);
begin
inherited Create(ACommand, AComment);
FLeftOperand := ALeft;
FRightOperand := ARight;
end;


procedure TCcTwoOperandsCommand.WriteOutput(A: TStringList);
var
s: string;
begin
s := GetEnumName(TypeInfo(TCcCommandType), Ord(Command));
Delete(s, 1, 2);
A.Add(' ' + Format('%s %s, %s', [s, Left, Right]) + GenerateComment);
end;


{ TCcCommentCommand }

constructor TCcCommentCommand.Create(const AText: string);
begin
inherited Create(ctComment, AText);
end;


procedure TCcCommentCommand.WriteOutput(A: TStringList);
begin
A.Add('; ' + Comment);
end;


{ TCcVarDeclaration }

constructor TCcVarDeclaration.Create(
AText: string; AGlobal: boolean; const AComment: string);
begin
inherited Create(AText, AComment);
FGlobal := AGlobal;
end;


{ TCcHeader }

constructor TCcHeader.Create(const AText: string; const AComment: string);
begin
FText := AText;
end;


procedure TCcHeader.WriteOutput(A: TStringList);
begin
A.Add(FText + GenerateComment);
end;


end.