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

{
  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 UCcIntOpsTemplate;

interface

uses
  SysUtils, Classes,
  UCcCodeTemplate, UCcCodeGenerator, UCcParser, UCcTokenizer,
  UCcSyntaxEntriesTypes, UCcBuffer;

type
  TCcAbstractBinaryOpsTemplate = class(TCcBinaryOpTemplate)
  public
    class function TemplateInfo: TCcCodeTemplateInfo; override;
  end;


  TCcAbstractBinarySimpleIntOpsTemplate = class(TCcAbstractBinaryOpsTemplate)
  protected
    procedure InternalGenerate(
      AGenerator: TCcCodeGenerator; APosition: TCcPosition;
      ALeftType, ARightType: TObject;
      AOperation: TCcTokenSubType); virtual; abstract;
  public
    procedure Generate(
      AGenerator: TCcCodeGenerator; APosition: TCcPosition;
      ALeftType, ARightType: TObject; AOperation: TCcTokenSubType); override;
  end;


  TCcBinaryAssignIntOpsTemplate = class(TCcAbstractBinaryOpsTemplate)
  public
    class function TemplateInfo: TCcCodeTemplateInfo; override;

    procedure Generate(AGenerator: TCcCodeGenerator;
      APosition: TCcPosition; ALeftType, ARightType: TObject;
      AOperation: TCcTokenSubType); override;
  end;


  TCcBinaryCompareIntOpsTemplate = class(TCcAbstractBinarySimpleIntOpsTemplate)
  protected
    procedure InternalGenerate(
      AGenerator: TCcCodeGenerator; APosition: TCcPosition;
      ALeftType, ARightType: TObject; AOperation: TCcTokenSubType); override;
  public
    class function TemplateInfo: TCcCodeTemplateInfo; override;
  end;


  TCcBinaryIntOpsTemplate = class(TCcAbstractBinarySimpleIntOpsTemplate)
  protected
    procedure InternalGenerate(
      AGenerator: TCcCodeGenerator; APosition: TCcPosition; ALeftType: TObject;
      ARightType: TObject; AOperation: TCcTokenSubType); override;
  public
    class function TemplateInfo: TCcCodeTemplateInfo; override;
  end;


implementation

uses
  UCcCodeGeneratorCommands, UCcSyntaxEntries;


const
  COMPARE_CMDS:
    array[TCcTokenCompareOperators] of TCcCommandType = (
      ctSetL, ctSetG, ctSetE, ctSetLE, ctSetGE, ctSetNE
    );
  BINOP_CMDS:
    array[TCcTokenBinaryOperators] of TCcCommandType  = (
      ctAnd, ctOr, ctXor, ctAnd, ctOr, ctNop, ctNop, ctShl, ctShr,
      ctAdd, ctSub, ctIdiv, ctImul, ctNop
    );


{ TCcAbstractBinaryOpsTemplate }

class function TCcAbstractBinaryOpsTemplate.TemplateInfo: TCcCodeTemplateInfo;
begin
  FillChar(Result.AllowedArgs, sizeof(Result.AllowedArgs), false);
  Result.AllowedArgs[etIntegral, etIntegral] := true;
end;


{ TCcBinaryAssignIntOpsTemplate }

procedure TCcBinaryAssignIntOpsTemplate.Generate(
  AGenerator: TCcCodeGenerator; APosition: TCcPosition; ALeftType,
  ARightType: TObject; AOperation: TCcTokenSubType);
const
  ASSIGN_INTOPS:
    array[TCcTokenAssignmentOperators] of TCcCommandType = (
      ctMov, ctImul, ctIdiv, ctNop, ctAdd, ctSub, ctShl, ctShr, ctAnd, ctXor,
      ctOr
    );

var
  re, le: TCcExpression;
begin
  re := (ARightType as TCcExpression);
  le := (ALeftType as TCcExpression);

  re.Generate(AGenerator);
  le.GenerateLValue(AGenerator);

  AGenerator.Gen(ctPop, 'eax').Comment := 'Getting left operand address';
  AGenerator.Gen(ctPop, 'ebx').Comment := 'Getting right operand';
  if (AOperation = tstRemAssign) then begin
    AGenerator.Gen(ctPush, 'eax');
    AGenerator.Gen(ctMov, 'eax', '[eax]');
    AGenerator.Gen(ctCdq);
    AGenerator.Gen(ctIdiv, 'ebx');
    AGenerator.Gen(ctPop, 'eax');
    AGenerator.Gen(ctMov, '[eax]', 'edx');
  end
  else if (AOperation = tstDivAssign) then begin
    AGenerator.Gen(ctPush, 'eax');
    AGenerator.Gen(ctMov, 'eax', '[eax]');
    AGenerator.Gen(ctIdiv, 'ebx');
    AGenerator.Gen(ctPop, 'ebx');
    AGenerator.Gen(ctMov, '[ebx]', 'eax');
  end
  else
    AGenerator.Gen(ASSIGN_INTOPS[AOperation], '[eax]', 'ebx');
  AGenerator.Gen(ctMov, 'eax', '[eax]').Comment := 'Saving reault of calculation in EAX';
  AGenerator.Gen(ctPush, 'eax').Comment := 'Storing EAX';
end;


class function TCcBinaryAssignIntOpsTemplate.TemplateInfo: TCcCodeTemplateInfo;
begin
  Result := inherited TemplateInfo;
  Result.Operations := [tstAssignment..tstOrAssign];
end;


{ TCcAbstractBinarySimpleIntOpsTemplate }

procedure TCcAbstractBinarySimpleIntOpsTemplate.Generate(
  AGenerator: TCcCodeGenerator; APosition: TCcPosition;
  ALeftType, ARightType: TObject; AOperation: TCcTokenSubType);
var
  le, re: TCcExpression;
begin
  le := ALeftType as TCcExpression;
  re := ARightType as TCcExpression;

  re.Generate(AGenerator);
  le.Generate(AGenerator);

  AGenerator.Gen(ctPop, 'eax').Comment := 'Left operand value';
  AGenerator.Gen(ctPop, 'ebx').Comment := 'Right operand value';

  InternalGenerate(AGenerator, APosition, ALeftType, ARightType, AOperation);

  AGenerator.Gen(ctPush, 'eax').Comment := 'Storing result';
end;


{ TCcBinaryCompareIntOpsTemplate }

procedure TCcBinaryCompareIntOpsTemplate.InternalGenerate(
  AGenerator: TCcCodeGenerator; APosition: TCcPosition;
  ALeftType, ARightType: TObject; AOperation: TCcTokenSubType);
begin
  inherited;
  AGenerator.Gen(ctPush, 'ebx');
  AGenerator.Gen(ctXor, 'ebx', 'ebx');
  AGenerator.Gen(ctCmp, 'eax', 'dword ptr [esp]');
  AGenerator.Gen(COMPARE_CMDS[AOperation], 'bl');
  AGenerator.Gen(ctMov, 'eax', 'ebx');
  AGenerator.Gen(ctAdd, 'esp', '4');
end;


class function TCcBinaryCompareIntOpsTemplate.TemplateInfo: TCcCodeTemplateInfo;
begin
  Result := inherited TemplateInfo;
  Result.Operations := [
    Low(TCcTokenCompareOperators)..High(TCcTokenCompareOperators)];
end;


{ TCcBinaryIntOpsTemplate }

procedure TCcBinaryIntOpsTemplate.InternalGenerate(
  AGenerator: TCcCodeGenerator; APosition: TCcPosition;
  ALeftType, ARightType: TObject; AOperation: TCcTokenSubType);
begin
  // Left  -  eax
  // Right  -  ebx
  case AOperation of
    tstRemainder:
      begin
        AGenerator.Gen(ctCdq);
        AGenerator.Gen(ctIdiv, 'ebx');
        AGenerator.Gen(ctMov, 'eax', 'edx');
      end;
    tstShr, tstShl:
      begin
        AGenerator.Gen(ctMov, 'ecx', 'ebx');
        AGenerator.Gen(BINOP_CMDS[AOperation], 'eax', 'cl');
      end;
    tstDiv:
      begin
        AGenerator.Gen(ctXor, 'edx', 'edx');
        AGenerator.Gen(ctIdiv, 'ebx');
      end;
    else
      AGenerator.Gen(BINOP_CMDS[AOperation], 'eax', 'ebx');
  end;
end;


class function TCcBinaryIntOpsTemplate.TemplateInfo: TCcCodeTemplateInfo;
begin
  Result := inherited TemplateInfo;
  Result.Operations :=
    [Low(TCcTokenBinaryOperators)..High(TCcTokenBinaryOperators)];
end;


initialization
  TemplateManager.RegisterTemplate(TCcBinaryAssignIntOpsTemplate.Create);
  TemplateManager.RegisterTemplate(TCcBinaryCompareIntOpsTemplate.Create);
  TemplateManager.RegisterTemplate(TCcBinaryIntOpsTemplate.Create);

end.