delfortypes.pas

delphi代码格式化,最新汉化版

{|----------------------------------------------------------------------
 | Unit:        DelforTypes
 |
 | Author:      Egbert van Nes
 |
 | Description: Simple types used in DelFor(Exp)
 |
 | Copyright (c) 2000  Egbert van Nes
 |   All rights reserved
 |   Disclaimer and licence notes: see license.txt
 |
 |----------------------------------------------------------------------
}
unit DelForTypes;
interface
uses SysUtils, OObjects;

const
  CurrentDllVersion = 1;
type
  TWordType = (wtLineFeed, wtSpaces, wtHalfComment, wtHalfStarComment,
    wtHalfOutComment, wtFullComment, wtFullOutComment, wtString, wtErrorString,
    wtOperator,  wtWord, wtNumber, wtHexNumber, wtNothing, wtAsm, wtCompDirective);
  EFormatException = class(Exception);

  TProgressEvent = procedure(Sender: TObject;
    Progress: Integer) of object;
const
  Maxline = 1024; // the maximum line length of the Delphi editor
  CRLF = #13#10#0;
  NotPrintable = [#1..#8, #10..#14, #16..#19, #22..#31]; {not printable chars}
  Tab = #9;
  ftNothing = 0;
  ftSpaceBefore = $01;
  ftSpaceAfter = $02;
  ftSpaceBoth = $03;
  ftUpperCase = $04;
  ftLowerCase = $08;
  ftFirstUp = $10;
type
  TSpaceBefore = (spNone, spBefore, spAfter, spBoth);
  TReservedType = (rtNothing, rtReserved, rtOper, rtDirective,
    rtIf, rtDo, rtWhile, rtOn, rtVar, rtType, rtProcedure, rtAsm, rtTry,
    rtExcept,
    rtEnd, rtBegin, rtCase, rtOf, rtLineFeed, rtColon, rtSemiColon,
    rtThen, rtClass, rtClassDecl, rtProgram, rtRepeat, rtUntil, rtRecord,
    rtPrivate, rtElse, rtIfElse, rtInterface, rtImplementation,
    rtLeftBr, rtRightBr, rtLeftHook, rtRightHook, rtMathOper, rtEqualOper,
    rtMinus, rtPlus,
    rtLogOper, rtEquals, rtForward, rtDefault, rtInitialization, rtComma,
    rtUses, rtProcDeclare, rtFuncDirective, rtAbsolute, rtComment, rtRecCase, rtDot,
    rtCompIf, rtDotDot,
    rtCompElse, rtCompEndif);
const
  NoReservedTypes = [rtNothing, rtComma, rtColon, rtLineFeed, rtDefault,
    rtFuncDirective, rtAbsolute, rtComment, rtLeftBr, rtRightBr, rtForward,
    rtCompIf, rtCompElse, rtCompEndif, rtPrivate];
  StandardDirectives = [rtDefault, rtAbsolute, rtPrivate, rtFuncDirective,
    rtAbsolute, rtForward];
type
  TCase = (rfLowerCase, rfUpperCase, rfFirstUp, rfUnchanged);
  TReservedRec = record
    ReservedType: TReservedType;
    Words: PChar;
  end;

type
  TFeedBegin = (Unchanged, Hanging, NewLine);
  TFillMode = (fmUnchanged, fmAddNewWord, fmUse, fmExceptDirect, fmAddUse,
    fmAddUseExcept);

  TCommentArray = array[0..20] of Char; {easier to save}

  PSettings = ^TSettings;
  TSettings = packed record
    ShortCut: Word;
    SpaceOperators: TSpaceBefore;
    SpaceColon: TSpaceBefore;
    SpaceSemiColon: TSpaceBefore;
    SpaceComma: TSpaceBefore;
    SpaceLeftBr: TSpaceBefore;
    SpaceRightBr: TSpaceBefore;
    SpaceLeftHook: TSpaceBefore;
    SpaceRightHook: TSpaceBefore;
    SpaceEqualOper: TSpaceBefore;
    UpperCompDirectives: Boolean;
    UpperNumbers: Boolean;
    ReservedCase: TCase;
    StandDirectivesCase: TCase;
    ChangeIndent: Boolean;
    NoIndentElseIf: Boolean;
    indentBegin: Boolean;
    IndentTry: Boolean;
    IndentTryElse: Boolean;
    IndentCaseElse: Boolean;
    IndentComments: Boolean;
    IndentCompDirectives: Boolean;
    BlankProc: Boolean;
    BlankSubProc: Boolean;
    RemoveDoubleBlank: Boolean;
    SpacePerIndent: Integer;
    FeedRoundBegin: TFeedBegin;
    FeedBeforeEnd: Boolean;
    FeedAfterThen: Boolean;
    ExceptSingle:Boolean;
    FeedAfterVar: Boolean;
    FeedEachUnit: Boolean;
    NoFeedBeforeThen: Boolean;
    FeedElseIf: Boolean;
    FillNewWords: TFillMode;
    FeedAfterSemiColon: Boolean;
    StartCommentOut: TCommentArray;
    EndCommentOut: TCommentArray;
    CommentFunction: Boolean;
    CommentUnit: Boolean;
    WrapLines: Boolean;
    WrapPosition: Byte;
    AlignCommentPos: Byte;
    AlignComments: Boolean;
    AlignVarPos: Byte;
    AlignVar: Boolean;
  end;

const
  NReservedWords = 104;
  {IndentProcedure = True;}
type
  TReservedArray = array[0..NReservedWords - 1] of TReservedRec;
const
  {must be ordered perfectly on words!!}

  ReservedArray: TReservedArray = (
    (ReservedType: rtAbsolute; Words: 'absolute'),
    (ReservedType: rtFuncDirective; Words: 'abstract'),
    (ReservedType: rtOper; Words: 'and'),
    (ReservedType: rtReserved; Words: 'array'),
    (ReservedType: rtOper; Words: 'as'),
    (ReservedType: rtAsm; Words: 'asm'),
    (ReservedType: rtFuncDirective; Words: 'assembler'),
    (ReservedType: rtPrivate; Words: 'automated'),
    (ReservedType: rtBegin; Words: 'begin'),
    (ReservedType: rtCase; Words: 'case'),
    (ReservedType: rtFuncDirective; Words: 'cdecl'),
    (ReservedType: rtClass; Words: 'class'),
    (ReservedType: rtVar; Words: 'const'),
    (ReservedType: rtProcedure; Words: 'constructor'),
    (ReservedType: rtUses; Words: 'contains'),
    (ReservedType: rtDefault; Words: 'default'),
    (ReservedType: rtProcedure; Words: 'destructor'),
    (ReservedType: rtFuncDirective; Words: 'dispid'),
    (ReservedType: rtInterface; Words: 'dispinterface'),
    (ReservedType: rtOper; Words: 'div'),
    (ReservedType: rtDo; Words: 'do'),
    (ReservedType: rtOper; Words: 'downto'),
    (ReservedType: rtFuncDirective; Words: 'dynamic'),
    (ReservedType: rtElse; Words: 'else'),
    (ReservedType: rtEnd; Words: 'end'),
    (ReservedType: rtExcept; Words: 'except'),
    (ReservedType: rtFuncDirective; Words: 'export'),
    (ReservedType: rtUses; Words: 'exports'),
    (ReservedType: rtForward; Words: 'external'),
    (ReservedType: rtFuncDirective; Words: 'far'),
    (ReservedType: rtReserved; Words: 'file'),
    (ReservedType: rtInitialization; Words: 'finalization'),
    (ReservedType: rtExcept; Words: 'finally'),
    (ReservedType: rtWhile; Words: 'for'),
    (ReservedType: rtForward; Words: 'forward'),
    (ReservedType: rtProcedure; Words: 'function'),
    (ReservedType: rtReserved; Words: 'goto'),
    (ReservedType: rtIf; Words: 'if'),
    (ReservedType: rtImplementation; Words: 'implementation'),
    (ReservedType: rtFuncDirective; Words: 'implements'),
    (ReservedType: rtOper; Words: 'in'),
    (ReservedType: rtFuncDirective; Words: 'index'),
    (ReservedType: rtReserved; Words: 'inherited'),
    (ReservedType: rtInitialization; Words: 'initialization'),
    (ReservedType: rtDirective; Words: 'inline'),
    (ReservedType: rtInterface; Words: 'interface'),
    (ReservedType: rtOper; Words: 'is'),
    (ReservedType: rtVar; Words: 'label'),
    (ReservedType: rtProgram; Words: 'library'),
    (ReservedType: rtFuncDirective; Words: 'message'),
    (ReservedType: rtOper; Words: 'mod'),
    (ReservedType: rtFuncDirective; Words: 'name'),
    (ReservedType: rtFuncDirective; Words: 'near'),
    (ReservedType: rtReserved; Words: 'nil'),
    (ReservedType: rtFuncDirective; Words: 'nodefault'),
    (ReservedType: rtOper; Words: 'not'),
    (ReservedType: rtClass; Words: 'object'),
    (ReservedType: rtOf; Words: 'of'),
    (ReservedType: rtOn; Words: 'on'),
    (ReservedType: rtOper; Words: 'or'),
    (ReservedType: rtReserved; Words: 'out'),
    (ReservedType: rtFuncDirective; Words: 'overload'),
    (ReservedType: rtFuncDirective; Words: 'override'),
    (ReservedType: rtReserved; Words: 'packed'),
    (ReservedType: rtFuncDirective; Words: 'pascal'),
    (ReservedType: rtPrivate; Words: 'private'),
    (ReservedType: rtProcedure; Words: 'procedure'),
    (ReservedType: rtProgram; Words: 'program'),
    (ReservedType: rtProcedure; Words: 'property'),
    (ReservedType: rtPrivate; Words: 'protected'),
    (ReservedType: rtPrivate; Words: 'public'),
    (ReservedType: rtPrivate; Words: 'published'),
    (ReservedType: rtReserved; Words: 'raise'),
    (ReservedType: rtFuncDirective; Words: 'read'),
    (ReservedType: rtFuncDirective; Words: 'readonly'),
    (ReservedType: rtRecord; Words: 'record'),
    (ReservedType: rtFuncDirective; Words: 'register'),
    (ReservedType: rtFuncDirective; Words: 'reintroduce'),
    (ReservedType: rtRepeat; Words: 'repeat'),
    (ReservedType: rtUses; Words: 'requires'),
    (ReservedType: rtFuncDirective; Words: 'resident'),
    (ReservedType: rtVar; Words: 'resourcestring'),
    (ReservedType: rtFuncDirective; Words: 'safecall'),
    (ReservedType: rtReserved; Words: 'set'),
    (ReservedType: rtOper; Words: 'shl'),
    (ReservedType: rtOper; Words: 'shr'),
    (ReservedType: rtFuncDirective; Words: 'stdcall'),
    (ReservedType: rtFuncDirective; Words: 'stored'),
    (ReservedType: rtReserved; Words: 'string'),
    (ReservedType: rtThen; Words: 'then'),
    (ReservedType: rtVar; Words: 'threadvar'),
    (ReservedType: rtOper; Words: 'to'),
    (ReservedType: rtTry; Words: 'try'),
    (ReservedType: rtType; Words: 'type'),
    (ReservedType: rtProgram; Words: 'unit'),
    (ReservedType: rtUntil; Words: 'until'),
    (ReservedType: rtUses; Words: 'uses'),
    (ReservedType: rtVar; Words: 'var'),
    (ReservedType: rtFuncDirective; Words: 'virtual'),
    (ReservedType: rtWhile; Words: 'while'),
    (ReservedType: rtWhile; Words: 'with'),
    (ReservedType: rtFuncDirective; Words: 'write'),
    (ReservedType: rtFuncDirective; Words: 'writeonly'),
    (ReservedType: rtOper; Words: 'xor')
    );
type
  TKeywordColl = class(TStrCollection)
  public
    function Compare(Key1, Key2: Pointer): Integer; override;
  end;

function StrCase(Source: PChar;
  ACase: TCase): PChar;

implementation

function TKeywordColl.Compare(Key1, Key2: Pointer): Integer;
begin
  Result := StrIComp(Key1, Key2);
end;

function StrCase(Source: PChar; ACase: TCase): PChar;
begin
  case ACase of
    rfUpperCase: Result := StrUpper(Source);
    rfLowerCase: Result := StrLower(Source);
    rfFirstUp:
      begin
        Result := StrLower(Source);
        while Source^ in [' ', Tab] do
          inc(Source);
        Source^ := UpCase(Char(Source^));
      end;
  else
    Result := Source;
  end;
end;

end.