Merged revisions 192-195 via svnmerge from

/trunk

git-svn-id: branches/fixes_2_0@276 -

fcl/passrc/pastree.pp

@@ -74,31 +74,31 @@ type
   TPasElement = class
   private
     FRefCount: LongWord;
-    FName: String;
+    FName: string;
     FParent: TPasElement;
   public
-    SourceFilename: String;
+    SourceFilename: string;
     SourceLinenumber: Integer;
-    constructor Create(const AName: String; AParent: TPasElement); virtual;
+    constructor Create(const AName: string; AParent: TPasElement); virtual;
     procedure AddRef;
     procedure Release;
-    function FullName: String;          // Name including parent's names
-    function PathName: String;          // = Module.Name + FullName
+    function FullName: string;          // Name including parent's names
+    function PathName: string;          // = Module.Name + FullName
     function GetModule: TPasModule;
-    function ElementTypeName: String; virtual;
-    function GetDeclaration(full : Boolean) : String; virtual;
+    function ElementTypeName: string; virtual;
+    function GetDeclaration(full : Boolean) : string; virtual;
     Visibility: TPasMemberVisibility;
     property RefCount: LongWord read FRefCount;
-    property Name: String read FName;
+    property Name: string read FName write Fname;
     property Parent: TPasElement read FParent;
   end;
 
   TPasSection = class(TPasElement)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    procedure AddUnitToUsesList(const AUnitName: String);
+    function ElementTypeName: string; override;
+    procedure AddUnitToUsesList(const AUnitName: string);
     UsesList: TList;            // TPasUnresolvedTypeRef or TPasModule elements
     Declarations, ResStrings, Types, Consts, Classes,
       Functions, Variables: TList;
@@ -107,91 +107,91 @@ type
   TPasModule = class(TPasElement)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
     InterfaceSection, ImplementationSection: TPasSection;
-    PackageName: String;
+    PackageName: string;
   end;
 
   TPasPackage = class(TPasElement)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function ElementTypeName: String; override;
+    function ElementTypeName: string; override;
     Modules: TList;     // List of TPasModule objects
   end;
 
   TPasResString = class(TPasElement)
   public
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : Boolean) : String; Override;
-    Value: String;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : Boolean) : string; Override;
+    Value: string;
   end;
 
   TPasType = class(TPasElement)
   public
-    function ElementTypeName: String; override;
+    function ElementTypeName: string; override;
   end;
 
   TPasPointerType = class(TPasType)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : Boolean): String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : Boolean): string; override;
     DestType: TPasType;
   end;
 
   TPasAliasType = class(TPasType)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : Boolean): String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : Boolean): string; override;
     DestType: TPasType;
   end;
 
   TPasTypeAliasType = class(TPasAliasType)
   public
-    function ElementTypeName: String; override;
+    function ElementTypeName: string; override;
   end;
 
   TPasClassOfType = class(TPasAliasType)
   public
-    function ElementTypeName: String; override;
-    function GetDeclaration(full: boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full: boolean) : string; override;
   end;
 
 
   TPasRangeType = class(TPasType)
   public
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
-    RangeStart, RangeEnd: String;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
+    RangeStart, RangeEnd: string;
   end;
 
   TPasArrayType = class(TPasType)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
-    IndexRange : String;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
+    IndexRange : string;
     IsPacked : Boolean;          // 12/04/04 - Dave - Added
     ElType: TPasType;
   end;
 
   TPasEnumValue = class(TPasElement)
   public
-    function ElementTypeName: String; override;
+    function ElementTypeName: string; override;
     IsValueUsed: Boolean;
     Value: Integer;
-    AssignedValue : String;
+    AssignedValue : string;
   end;
 
   TPasEnumType = class(TPasType)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-     function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
+     function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
     Procedure GetEnumNames(Names : TStrings);
     Values: TList;      // List of TPasEnumValue objects
   end;
@@ -199,17 +199,17 @@ type
   TPasSetType = class(TPasType)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
     EnumType: TPasType;
   end;
 
   TPasRecordType = class(TPasType)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
     IsPacked: Boolean;
     Members: TList;     // array of TPasVariable elements
   end;
@@ -219,9 +219,9 @@ type
 
   TPasClassType = class(TPasType)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function ElementTypeName: String; override;
+    function ElementTypeName: string; override;
     ObjKind: TPasObjKind;
     AncestorType: TPasType;     // TPasClassType or TPasUnresolvedTypeRef
     IsPacked: Boolean;        // 12/04/04 - Dave - Added
@@ -233,23 +233,23 @@ type
   TPasArgument = class(TPasElement)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
     Access: TArgumentAccess;
     ArgType: TPasType;
-    Value: String;
+    Value: string;
   end;
 
   TPasProcedureType = class(TPasType)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    class function TypeName: String; virtual;
-    function ElementTypeName: String; override;
+    class function TypeName: string; virtual;
+    function ElementTypeName: string; override;
     IsOfObject: Boolean;
-    function GetDeclaration(full : boolean) : String; override;
+    function GetDeclaration(full : boolean) : string; override;
     procedure GetArguments(List : TStrings);
-    function CreateArgument(const AName, AUnresolvedTypeName: String):
+    function CreateArgument(const AName, AUnresolvedTypeName: string):
       TPasArgument;
     Args: TList;        // List of TPasArgument objects
   end;
@@ -257,80 +257,80 @@ type
   TPasResultElement = class(TPasElement)
   public
     destructor Destroy; override;
-    function ElementTypeName : String; override;
+    function ElementTypeName : string; override;
     ResultType: TPasType;
   end;
 
   TPasFunctionType = class(TPasProcedureType)
   public
     destructor Destroy; override;
-    class function TypeName: String; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(Full : boolean) : String; override;
+    class function TypeName: string; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(Full : boolean) : string; override;
     ResultEl: TPasResultElement;
   end;
 
   TPasUnresolvedTypeRef = class(TPasType)
   public
     // Typerefs cannot be parented! -> AParent _must_ be NIL
-    constructor Create(const AName: String; AParent: TPasElement); override;
-    function ElementTypeName: String; override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
+    function ElementTypeName: string; override;
   end;
 
   TPasTypeRef = class(TPasUnresolvedTypeRef)
   public
-    // function GetDeclaration(full : Boolean): String; override;
+    // function GetDeclaration(full : Boolean): string; override;
     RefType: TPasType;
   end;
 
   TPasVariable = class(TPasElement)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
     VarType: TPasType;
-    Value: String;
+    Value: string;
     Modifiers : string;
   end;
 
   TPasConst = class(TPasVariable)
   public
-    function ElementTypeName: String; override;
+    function ElementTypeName: string; override;
   end;
 
   TPasProperty = class(TPasVariable)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function GetDeclaration(full : boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration(full : boolean) : string; override;
     Args: TList;        // List of TPasArgument objects
     IndexValue, ReadAccessorName, WriteAccessorName,
-      StoredAccessorName, DefaultValue: String;
+      StoredAccessorName, DefaultValue: string;
     IsDefault, IsNodefault: Boolean;
   end;
 
   TPasProcedureBase = class(TPasElement)
   public
-    function TypeName: String; virtual; abstract;
+    function TypeName: string; virtual; abstract;
   end;
 
   TPasOverloadedProc = class(TPasProcedureBase)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function TypeName: String; override;
+    function ElementTypeName: string; override;
+    function TypeName: string; override;
     Overloads: TList;           // List of TPasProcedure nodes
   end;
 
   TPasProcedure = class(TPasProcedureBase)
   public
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function TypeName: String; override;
+    function ElementTypeName: string; override;
+    function TypeName: string; override;
     ProcType: TPasProcedureType;
-    function GetDeclaration(full: Boolean): String; override;
+    function GetDeclaration(full: Boolean): string; override;
     procedure GetModifiers(List: TStrings);
     IsVirtual, IsDynamic, IsAbstract, IsOverride,
       IsOverload, IsMessage: Boolean;
@@ -338,20 +338,26 @@ type
 
   TPasFunction = class(TPasProcedure)
   public
-    function ElementTypeName: String; override;
-    function GetDeclaration (full : boolean) : String; override;
+    function ElementTypeName: string; override;
+    function GetDeclaration (full : boolean) : string; override;
+  end;
+
+  TPasOperator = class(TPasProcedure)
+  public
+    function ElementTypeName: string; override;
+    function GetDeclaration (full : boolean) : string; override;
   end;
 
   TPasConstructor = class(TPasProcedure)
   public
-    function ElementTypeName: String; override;
-    function TypeName: String; override;
+    function ElementTypeName: string; override;
+    function TypeName: string; override;
   end;
 
   TPasDestructor = class(TPasProcedure)
   public
-    function ElementTypeName: String; override;
-    function TypeName: String; override;
+    function ElementTypeName: string; override;
+    function TypeName: string; override;
   end;
 
 
@@ -359,10 +365,10 @@ type
 
   TPasProcedureImpl = class(TPasElement)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function ElementTypeName: String; override;
-    function TypeName: String; virtual;
+    function ElementTypeName: string; override;
+    function TypeName: string; virtual;
     ProcType: TPasProcedureType;
     Locals: TList;
     Body: TPasImplBlock;
@@ -370,14 +376,14 @@ type
 
   TPasConstructorImpl = class(TPasProcedureImpl)
   public
-    function ElementTypeName: String; override;
-    function TypeName: String; override;
+    function ElementTypeName: string; override;
+    function TypeName: string; override;
   end;
 
   TPasDestructorImpl = class(TPasProcedureImpl)
   public
-    function ElementTypeName: String; override;
-    function TypeName: String; override;
+    function ElementTypeName: string; override;
+    function TypeName: string; override;
   end;
 
   TPasImplElement = class(TPasElement)
@@ -385,12 +391,12 @@ type
 
   TPasImplCommand = class(TPasImplElement)
   public
-    Command: String;
+    Command: string;
   end;
 
   TPasImplCommands = class(TPasImplElement)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
     Commands: TStrings;
   end;
@@ -398,7 +404,7 @@ type
   TPasImplIfElse = class(TPasImplElement)
   public
     destructor Destroy; override;
-    Condition: String;
+    Condition: string;
     IfBranch, ElseBranch: TPasImplElement;
   end;
 
@@ -406,33 +412,33 @@ type
   public
     destructor Destroy; override;
     Variable: TPasVariable;
-    StartValue, EndValue: String;
+    StartValue, EndValue: string;
     Body: TPasImplElement;
   end;
 
   TPasImplBlock = class(TPasImplElement)
   public
-    constructor Create(const AName: String; AParent: TPasElement); override;
+    constructor Create(const AName: string; AParent: TPasElement); override;
     destructor Destroy; override;
-    function AddCommand(const ACommand: String): TPasImplCommand;
+    function AddCommand(const ACommand: string): TPasImplCommand;
     function AddCommands: TPasImplCommands;
-    function AddIfElse(const ACondition: String): TPasImplIfElse;
+    function AddIfElse(const ACondition: string): TPasImplIfElse;
     function AddForLoop(AVar: TPasVariable;
-      const AStartValue, AEndValue: String): TPasImplForLoop;
+      const AStartValue, AEndValue: string): TPasImplForLoop;
     Elements: TList;    // TPasImplElement objects
   end;
 
 
 const
-  AccessNames: array[TArgumentAccess] of String[6] = ('', 'const ', 'var ', 'out ');
+  AccessNames: array[TArgumentAccess] of string[6] = ('', 'const ', 'var ', 'out ');
   AllVisibilities: TPasMemberVisibilities =
      [visDefault, visPrivate, visProtected, visPublic,
       visPublished, visAutomated];
 
-  VisibilityNames: array[TPasMemberVisibility] of String = (
+  VisibilityNames: array[TPasMemberVisibility] of string = (
     'default', 'private', 'protected', 'public', 'published', 'automated');
 
-  ObjKindNames: array[TPasObjKind] of String = (
+  ObjKindNames: array[TPasObjKind] of string = (
     'object', 'class', 'interface');
 
 
@@ -443,40 +449,41 @@ uses SysUtils;
 
 { Parse tree element type name functions }
 
-function TPasElement.ElementTypeName: String; begin Result := SPasTreeElement end;
-function TPasSection.ElementTypeName: String; begin Result := SPasTreeSection end;
-function TPasModule.ElementTypeName: String; begin Result := SPasTreeModule end;
-function TPasPackage.ElementTypeName: String; begin Result := SPasTreePackage end;
-function TPasResString.ElementTypeName: String; begin Result := SPasTreeResString end;
-function TPasType.ElementTypeName: String; begin Result := SPasTreeType end;
-function TPasPointerType.ElementTypeName: String; begin Result := SPasTreePointerType end;
-function TPasAliasType.ElementTypeName: String; begin Result := SPasTreeAliasType end;
-function TPasTypeAliasType.ElementTypeName: String; begin Result := SPasTreeTypeAliasType end;
-function TPasClassOfType.ElementTypeName: String; begin Result := SPasTreeClassOfType end;
-function TPasRangeType.ElementTypeName: String; begin Result := SPasTreeRangeType end;
-function TPasArrayType.ElementTypeName: String; begin Result := SPasTreeArrayType end;
-function TPasEnumValue.ElementTypeName: String; begin Result := SPasTreeEnumValue end;
-function TPasEnumType.ElementTypeName: String; begin Result := SPasTreeEnumType end;
-function TPasSetType.ElementTypeName: String; begin Result := SPasTreeSetType end;
-function TPasRecordType.ElementTypeName: String; begin Result := SPasTreeRecordType end;
-function TPasArgument.ElementTypeName: String; begin Result := SPasTreeArgument end;
-function TPasProcedureType.ElementTypeName: String; begin Result := SPasTreeProcedureType end;
-function TPasResultElement.ElementTypeName: String; begin Result := SPasTreeResultElement end;
-function TPasFunctionType.ElementTypeName: String; begin Result := SPasTreeFunctionType end;
-function TPasUnresolvedTypeRef.ElementTypeName: String; begin Result := SPasTreeUnresolvedTypeRef end;
-function TPasVariable.ElementTypeName: String; begin Result := SPasTreeVariable end;
-function TPasConst.ElementTypeName: String; begin Result := SPasTreeConst end;
-function TPasProperty.ElementTypeName: String; begin Result := SPasTreeProperty end;
-function TPasOverloadedProc.ElementTypeName: String; begin Result := SPasTreeOverloadedProcedure end;
-function TPasProcedure.ElementTypeName: String; begin Result := SPasTreeProcedure end;
-function TPasFunction.ElementTypeName: String; begin Result := SPasTreeFunction end;
-function TPasConstructor.ElementTypeName: String; begin Result := SPasTreeConstructor end;
-function TPasDestructor.ElementTypeName: String; begin Result := SPasTreeDestructor end;
-function TPasProcedureImpl.ElementTypeName: String; begin Result := SPasTreeProcedureImpl end;
-function TPasConstructorImpl.ElementTypeName: String; begin Result := SPasTreeConstructorImpl end;
-function TPasDestructorImpl.ElementTypeName: String; begin Result := SPasTreeDestructorImpl end;
-
-function TPasClassType.ElementTypeName: String;
+function TPasElement.ElementTypeName: string; begin Result := SPasTreeElement end;
+function TPasSection.ElementTypeName: string; begin Result := SPasTreeSection end;
+function TPasModule.ElementTypeName: string; begin Result := SPasTreeModule end;
+function TPasPackage.ElementTypeName: string; begin Result := SPasTreePackage end;
+function TPasResString.ElementTypeName: string; begin Result := SPasTreeResString end;
+function TPasType.ElementTypeName: string; begin Result := SPasTreeType end;
+function TPasPointerType.ElementTypeName: string; begin Result := SPasTreePointerType end;
+function TPasAliasType.ElementTypeName: string; begin Result := SPasTreeAliasType end;
+function TPasTypeAliasType.ElementTypeName: string; begin Result := SPasTreeTypeAliasType end;
+function TPasClassOfType.ElementTypeName: string; begin Result := SPasTreeClassOfType end;
+function TPasRangeType.ElementTypeName: string; begin Result := SPasTreeRangeType end;
+function TPasArrayType.ElementTypeName: string; begin Result := SPasTreeArrayType end;
+function TPasEnumValue.ElementTypeName: string; begin Result := SPasTreeEnumValue end;
+function TPasEnumType.ElementTypeName: string; begin Result := SPasTreeEnumType end;
+function TPasSetType.ElementTypeName: string; begin Result := SPasTreeSetType end;
+function TPasRecordType.ElementTypeName: string; begin Result := SPasTreeRecordType end;
+function TPasArgument.ElementTypeName: string; begin Result := SPasTreeArgument end;
+function TPasProcedureType.ElementTypeName: string; begin Result := SPasTreeProcedureType end;
+function TPasResultElement.ElementTypeName: string; begin Result := SPasTreeResultElement end;
+function TPasFunctionType.ElementTypeName: string; begin Result := SPasTreeFunctionType end;
+function TPasUnresolvedTypeRef.ElementTypeName: string; begin Result := SPasTreeUnresolvedTypeRef end;
+function TPasVariable.ElementTypeName: string; begin Result := SPasTreeVariable end;
+function TPasConst.ElementTypeName: string; begin Result := SPasTreeConst end;
+function TPasProperty.ElementTypeName: string; begin Result := SPasTreeProperty end;
+function TPasOverloadedProc.ElementTypeName: string; begin Result := SPasTreeOverloadedProcedure end;
+function TPasProcedure.ElementTypeName: string; begin Result := SPasTreeProcedure end;
+function TPasFunction.ElementTypeName: string; begin Result := SPasTreeFunction end;
+function TPasOperator.ElementTypeName: string; begin Result := SPasTreeFunction end;
+function TPasConstructor.ElementTypeName: string; begin Result := SPasTreeConstructor end;
+function TPasDestructor.ElementTypeName: string; begin Result := SPasTreeDestructor end;
+function TPasProcedureImpl.ElementTypeName: string; begin Result := SPasTreeProcedureImpl end;
+function TPasConstructorImpl.ElementTypeName: string; begin Result := SPasTreeConstructorImpl end;
+function TPasDestructorImpl.ElementTypeName: string; begin Result := SPasTreeDestructorImpl end;
+
+function TPasClassType.ElementTypeName: string;
 begin
   case ObjKind of
     okObject: Result := SPasTreeObjectType;
@@ -489,7 +496,7 @@ end;
 { All other stuff: }
 
 
-constructor TPasElement.Create(const AName: String; AParent: TPasElement);
+constructor TPasElement.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create;
   FName := AName;
@@ -509,7 +516,7 @@ begin
     Dec(FRefCount);
 end;
 
-function TPasElement.FullName: String;
+function TPasElement.FullName: string;
 var
   p: TPasElement;
 begin
@@ -526,7 +533,7 @@ begin
   end;
 end;
 
-function TPasElement.PathName: String;
+function TPasElement.PathName: string;
 var
   p: TPasElement;
 begin
@@ -555,7 +562,7 @@ begin
   end;
 end;
 
-function TPasElement.GetDeclaration (full : boolean): String;
+function TPasElement.GetDeclaration (full : boolean): string;
 
 begin
   if Full then
@@ -564,7 +571,7 @@ begin
     Result := '';
 end;
 
-constructor TPasSection.Create(const AName: String; AParent: TPasElement);
+constructor TPasSection.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   UsesList := TList.Create;
@@ -599,7 +606,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TPasSection.AddUnitToUsesList(const AUnitName: String);
+procedure TPasSection.AddUnitToUsesList(const AUnitName: string);
 begin
   UsesList.Add(TPasUnresolvedTypeRef.Create(AUnitName, Self));
 end;
@@ -615,7 +622,7 @@ begin
 end;
 
 
-constructor TPasPackage.Create(const AName: String; AParent: TPasElement);
+constructor TPasPackage.Create(const AName: string; AParent: TPasElement);
 begin
   if (Length(AName) > 0) and (AName[1] <> '#') then
     inherited Create('#' + AName, AParent)
@@ -659,7 +666,7 @@ begin
 end;
 
 
-constructor TPasEnumType.Create(const AName: String; AParent: TPasElement);
+constructor TPasEnumType.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Values := TList.Create;
@@ -697,7 +704,7 @@ begin
 end;
 
 
-constructor TPasRecordType.Create(const AName: String; AParent: TPasElement);
+constructor TPasRecordType.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Members := TList.Create;
@@ -714,7 +721,7 @@ begin
 end;
 
 
-constructor TPasClassType.Create(const AName: String; AParent: TPasElement);
+constructor TPasClassType.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   IsPacked := False;                     // 12/04/04 - Dave - Added
@@ -742,7 +749,7 @@ begin
 end;
 
 
-constructor TPasProcedureType.Create(const AName: String; AParent: TPasElement);
+constructor TPasProcedureType.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Args := TList.Create;
@@ -758,13 +765,13 @@ begin
   inherited Destroy;
 end;
 
-function TPasProcedureType.TypeName: String;
+function TPasProcedureType.TypeName: string;
 begin
   Result := 'procedure';
 end;
 
 function TPasProcedureType.CreateArgument(const AName,
-  AUnresolvedTypeName: String): TPasArgument;
+  AUnresolvedTypeName: string): TPasArgument;
 begin
   Result := TPasArgument.Create(AName, Self);
   Args.Add(Result);
@@ -787,13 +794,13 @@ begin
   inherited Destroy;
 end;
 
-function TPasFunctionType.TypeName: String;
+function TPasFunctionType.TypeName: string;
 begin
   Result := 'function';
 end;
 
 
-constructor TPasUnresolvedTypeRef.Create(const AName: String; AParent: TPasElement);
+constructor TPasUnresolvedTypeRef.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, nil);
 end;
@@ -809,7 +816,7 @@ begin
 end;
 
 
-constructor TPasProperty.Create(const AName: String; AParent: TPasElement);
+constructor TPasProperty.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Args := TList.Create;
@@ -826,7 +833,7 @@ begin
 end;
 
 
-constructor TPasOverloadedProc.Create(const AName: String; AParent: TPasElement);
+constructor TPasOverloadedProc.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Overloads := TList.Create;
@@ -842,7 +849,7 @@ begin
   inherited Destroy;
 end;
 
-function TPasOverloadedProc.TypeName: String;
+function TPasOverloadedProc.TypeName: string;
 begin
   if Assigned(TPasProcedure(Overloads[0]).ProcType) then
     Result := TPasProcedure(Overloads[0]).ProcType.TypeName
@@ -858,25 +865,25 @@ begin
   inherited Destroy;
 end;
 
-function TPasProcedure.TypeName: String;
+function TPasProcedure.TypeName: string;
 begin
   Result := ProcType.TypeName;
 end;
 
 
-function TPasConstructor.TypeName: String;
+function TPasConstructor.TypeName: string;
 begin
   Result := 'constructor';
 end;
 
 
-function TPasDestructor.TypeName: String;
+function TPasDestructor.TypeName: string;
 begin
   Result := 'destructor';
 end;
 
 
-constructor TPasProcedureImpl.Create(const AName: String; AParent: TPasElement);
+constructor TPasProcedureImpl.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Locals := TList.Create;
@@ -899,24 +906,24 @@ begin
   inherited Destroy;
 end;
 
-function TPasProcedureImpl.TypeName: String;
+function TPasProcedureImpl.TypeName: string;
 begin
   Result := ProcType.TypeName;
 end;
 
 
-function TPasConstructorImpl.TypeName: String;
+function TPasConstructorImpl.TypeName: string;
 begin
   Result := 'constructor';
 end;
 
-function TPasDestructorImpl.TypeName: String;
+function TPasDestructorImpl.TypeName: string;
 begin
   Result := 'destructor';
 end;
 
 
-constructor TPasImplCommands.Create(const AName: String; AParent: TPasElement);
+constructor TPasImplCommands.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Commands := TStringList.Create;
@@ -949,7 +956,7 @@ begin
 end;
 
 
-constructor TPasImplBlock.Create(const AName: String; AParent: TPasElement);
+constructor TPasImplBlock.Create(const AName: string; AParent: TPasElement);
 begin
   inherited Create(AName, AParent);
   Elements := TList.Create;
@@ -965,7 +972,7 @@ begin
   inherited Destroy;
 end;
 
-function TPasImplBlock.AddCommand(const ACommand: String): TPasImplCommand;
+function TPasImplBlock.AddCommand(const ACommand: string): TPasImplCommand;
 begin
   Result := TPasImplCommand.Create('', Self);
   Elements.Add(Result);
@@ -978,7 +985,7 @@ begin
   Elements.Add(Result);
 end;
 
-function TPasImplBlock.AddIfElse(const ACondition: String): TPasImplIfElse;
+function TPasImplBlock.AddIfElse(const ACondition: string): TPasImplIfElse;
 begin
   Result := TPasImplIfElse.Create('', Self);
   Elements.Add(Result);
@@ -986,7 +993,7 @@ begin
 end;
 
 function TPasImplBlock.AddForLoop(AVar: TPasVariable; const AStartValue,
-  AEndValue: String): TPasImplForLoop;
+  AEndValue: string): TPasImplForLoop;
 begin
   Result := TPasImplForLoop.Create('', Self);
   Elements.Add(Result);
@@ -1001,7 +1008,7 @@ end;
 
   ---------------------------------------------------------------------}
 
-function TPasModule.GetDeclaration(full : boolean): String;
+function TPasModule.GetDeclaration(full : boolean): string;
 begin
   Result := 'Unit ' + Name;
 end;
@@ -1062,7 +1069,7 @@ begin
     Result:=Name+' = '+Result;
 end;
 
-Function IndentStrings(S : TStrings; indent : Integer) : String;
+Function IndentStrings(S : TStrings; indent : Integer) : string;
 
 Var
   I,CurrLen,CurrPos : Integer;
@@ -1144,7 +1151,7 @@ function TPasRecordType.GetDeclaration (full : boolean) : string;
 
 Var
   S,T : TStringList;
-  temp : String;
+  temp : string;
   I,J : integer;
 
 begin
@@ -1183,7 +1190,7 @@ end;
 procedure TPasProcedureType.GetArguments(List : TStrings);
 
 Var
-  T : String;
+  T : string;
   I : Integer;
 
 begin
@@ -1227,7 +1234,7 @@ function TPasFunctionType.GetDeclaration (full : boolean) : string;
 
 Var
   S : TStringList;
-  T : String;
+  T : string;
 
 begin
   S:=TStringList.Create;
@@ -1281,7 +1288,7 @@ end;
 function TPasProperty.GetDeclaration (full : boolean) : string;
 
 Var
-  S : String;
+  S : string;
   I : Integer;
 
 begin
@@ -1316,7 +1323,7 @@ end;
 
 Procedure TPasProcedure.GetModifiers(List : TStrings);
 
-  Procedure DoAdd(B : Boolean; S : String);
+  Procedure DoAdd(B : Boolean; S : string);
 
   begin
     if B then
@@ -1354,7 +1361,36 @@ function TPasFunction.GetDeclaration (full : boolean) : string;
 
 Var
   S : TStringList;
-  T : String;
+  T : string;
+
+begin
+  S:=TStringList.Create;
+  try
+    If Full then
+      S.Add(TypeName+' '+Name);
+    ProcType.GetArguments(S);
+    If Assigned((Proctype as TPasFunctionType).ResultEl) then
+      With TPasFunctionType(ProcType).ResultEl.ResultType do
+        begin
+        T:=' : ';
+        If (Name<>'') then
+          T:=T+Name
+        else
+          T:=T+GetDeclaration(False);
+        S.Add(T);
+        end;
+    GetModifiers(S);
+    Result:=IndentStrings(S,Length(S[0]));
+  finally
+    S.Free;
+  end;
+end;
+
+function TPasOperator.GetDeclaration (full : boolean) : string;
+
+Var
+  S : TStringList;
+  T : string;
 
 begin
   S:=TStringList.Create;

fcl/passrc/paswrite.pp

@@ -26,18 +26,18 @@ type
   private
     FStream: TStream;
     IsStartOfLine: Boolean;
-    Indent, CurDeclSection: String;
+    Indent, CurDeclSection: string;
     DeclSectionStack: TList;
     procedure IncIndent;
     procedure DecIndent;
     procedure IncDeclSectionLevel;
     procedure DecDeclSectionLevel;
-    procedure PrepareDeclSection(const ADeclSection: String);
+    procedure PrepareDeclSection(const ADeclSection: string);
   public
     constructor Create(AStream: TStream);
     destructor Destroy; override;
-    procedure wrt(const s: String);
-    procedure wrtln(const s: String);
+    procedure wrt(const s: string);
+    procedure wrtln(const s: string);
     procedure wrtln;
 
     procedure WriteElement(AElement: TPasElement);
@@ -60,7 +60,7 @@ type
   end;
 
 
-procedure WritePasFile(AElement: TPasElement; const AFilename: String);
+procedure WritePasFile(AElement: TPasElement; const AFilename: string);
 procedure WritePasFile(AElement: TPasElement; AStream: TStream);
 
 
@@ -72,7 +72,7 @@ uses SysUtils;
 type
   PDeclSectionStackElement = ^TDeclSectionStackElement;
   TDeclSectionStackElement = record
-    LastDeclSection, LastIndent: String;
+    LastDeclSection, LastIndent: string;
   end;
 
 constructor TPasWriter.Create(AStream: TStream);
@@ -96,7 +96,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TPasWriter.wrt(const s: String);
+procedure TPasWriter.wrt(const s: string);
 begin
   if IsStartOfLine then
   begin
@@ -108,9 +108,9 @@ begin
 end;
 
 const
-  LF: String = #10;
+  LF: string = #10;
 
-procedure TPasWriter.wrtln(const s: String);
+procedure TPasWriter.wrtln(const s: string);
 begin
   wrt(s);
   Stream.Write(LF[1], 1);
@@ -468,7 +468,7 @@ end;
 procedure TPasWriter.WriteImplCommands(ACommands: TPasImplCommands);
 var
   i: Integer;
-  s: String;
+  s: string;
 begin
   for i := 0 to ACommands.Commands.Count - 1 do
   begin
@@ -572,7 +572,7 @@ begin
   Dispose(El);
 end;
 
-procedure TPasWriter.PrepareDeclSection(const ADeclSection: String);
+procedure TPasWriter.PrepareDeclSection(const ADeclSection: string);
 begin
   if ADeclSection <> CurDeclSection then
   begin
@@ -588,7 +588,7 @@ begin
 end;
 
 
-procedure WritePasFile(AElement: TPasElement; const AFilename: String);
+procedure WritePasFile(AElement: TPasElement; const AFilename: string);
 var
   Stream: TFileStream;
 begin

fcl/passrc/pparser.pp

@@ -47,36 +47,36 @@ type
   protected
     FPackage: TPasPackage;
   public
-    function CreateElement(AClass: TPTreeElement; const AName: String;
-      AParent: TPasElement; const ASourceFilename: String;
+    function CreateElement(AClass: TPTreeElement; const AName: string;
+      AParent: TPasElement; const ASourceFilename: string;
       ASourceLinenumber: Integer): TPasElement;
-    function CreateElement(AClass: TPTreeElement; const AName: String;
+    function CreateElement(AClass: TPTreeElement; const AName: string;
       AParent: TPasElement; AVisibility: TPasMemberVisibility;
-      const ASourceFilename: String; ASourceLinenumber: Integer): TPasElement;
+      const ASourceFilename: string; ASourceLinenumber: Integer): TPasElement;
       virtual; abstract;
-    function CreateFunctionType(const AName: String; AParent: TPasElement;
-      UseParentAsResultParent: Boolean; const ASourceFilename: String;
+    function CreateFunctionType(const AName,resultname: string; AParent: TPasElement;
+      UseParentAsResultParent: Boolean; const ASourceFilename: string;
       ASourceLinenumber: Integer): TPasFunctionType;
-    function FindElement(const AName: String): TPasElement; virtual; abstract;
-    function FindModule(const AName: String): TPasModule; virtual;
+    function FindElement(const AName: string): TPasElement; virtual; abstract;
+    function FindModule(const AName: string): TPasModule; virtual;
     property Package: TPasPackage read FPackage;
   end;
 
   EParserError = class(Exception)
   private
-    FFilename: String;
+    FFilename: string;
     FRow, FColumn: Integer;
   public
-    constructor Create(const AReason, AFilename: String;
+    constructor Create(const AReason, AFilename: string;
       ARow, AColumn: Integer);
-    property Filename: String read FFilename;
+    property Filename: string read FFilename;
     property Row: Integer read FRow;
     property Column: Integer read FColumn;
   end;
 
 
 function ParseSource(AEngine: TPasTreeContainer;
-  const FPCCommandLine, OSTarget, CPUTarget: String): TPasModule;
+  const FPCCommandLine, OSTarget, CPUTarget: string): TPasModule;
 
 
 implementation
@@ -87,42 +87,44 @@ type
 
   TDeclType = (declNone, declConst, declResourcestring, declType, declVar);
 
+  Tproctype = (pt_procedure,pt_function,pt_operator);
+
   TPasParser = class
   private
     FFileResolver: TFileResolver;
     FScanner: TPascalScanner;
     FEngine: TPasTreeContainer;
     FCurToken: TToken;
-    FCurTokenString: String;
+    FCurTokenString: string;
     // UngetToken support:
     FTokenBuffer: array[0..1] of TToken;
-    FTokenStringBuffer: array[0..1] of String;
+    FTokenStringBuffer: array[0..1] of string;
     FTokenBufferIndex, FTokenBufferSize: Integer;
 
-    procedure ParseExc(const Msg: String);
+    procedure ParseExc(const Msg: string);
   protected
-    function CreateElement(AClass: TPTreeElement; const AName: String;
+    function CreateElement(AClass: TPTreeElement; const AName: string;
       AParent: TPasElement): TPasElement;
-    function CreateElement(AClass: TPTreeElement; const AName: String;
+    function CreateElement(AClass: TPTreeElement; const AName: string;
       AParent: TPasElement; AVisibility: TPasMemberVisibility): TPasElement;
   public
     constructor Create(AScanner: TPascalScanner; AFileResolver: TFileResolver;
       AEngine: TPasTreeContainer);
-    function CurTokenName: String;
-    function CurTokenText: String;
+    function CurTokenName: string;
+    function CurTokenText: string;
     procedure NextToken;
     procedure UngetToken;
     procedure ExpectToken(tk: TToken);
-    function ExpectIdentifier: String;
+    function ExpectIdentifier: string;
 
-    function ParseType(Parent: TPasElement; Prefix : String): TPasType;
+    function ParseType(Parent: TPasElement; Prefix : string): TPasType;
     function ParseType(Parent: TPasElement): TPasType;
     function ParseComplexType: TPasType;
     procedure ParseArrayType(Element: TPasArrayType);
-    function ParseExpression: String;
+    function ParseExpression: string;
     procedure AddProcOrFunction(ASection: TPasSection; AProc: TPasProcedure);
     function CheckIfOverloaded(AOwner: TPasClassType;
-      const AName: String): TPasElement;
+      const AName: string): TPasElement;
 
     procedure ParseMain(var Module: TPasModule);
     procedure ParseUnit(var Module: TPasModule);
@@ -136,11 +138,11 @@ type
     procedure ParseVarDecl(Parent: TPasElement; List: TList);
     procedure ParseArgList(Parent: TPasElement; Args: TList; EndToken: TToken);
     procedure ParseProcedureOrFunctionHeader(Parent: TPasElement;
-      Element: TPasProcedureType; IsFunction, OfObjectPossible: Boolean);
+      Element: TPasProcedureType; proctype:Tproctype; OfObjectPossible: Boolean);
     function ParseProcedureOrFunctionDecl(Parent: TPasElement;
-      IsFunction: Boolean): TPasProcedure;
+      proctype:Tproctype): TPasProcedure;
     procedure ParseRecordDecl(Parent: TPasRecordType);
-    function ParseClassDecl(Parent: TPasElement; const AClassName: String;
+    function ParseClassDecl(Parent: TPasElement; const AClassName: string;
       AObjKind: TPasObjKind): TPasType;
     procedure ParseProperty(Element:TPasElement);
 
@@ -149,21 +151,21 @@ type
     property Engine: TPasTreeContainer read FEngine;
 
     property CurToken: TToken read FCurToken;
-    property CurTokenString: String read FCurTokenString;
+    property CurTokenString: string read FCurTokenString;
   end;
 
 
 function TPasTreeContainer.CreateElement(AClass: TPTreeElement;
-  const AName: String; AParent: TPasElement; const ASourceFilename: String;
+  const AName: string; AParent: TPasElement; const ASourceFilename: string;
   ASourceLinenumber: Integer): TPasElement;
 begin
   Result := CreateElement(AClass, AName, AParent, visDefault, ASourceFilename,
     ASourceLinenumber);
 end;
 
-function TPasTreeContainer.CreateFunctionType(const AName: String;
+function TPasTreeContainer.CreateFunctionType(const AName,resultname: string;
   AParent: TPasElement; UseParentAsResultParent: Boolean;
-  const ASourceFilename: String; ASourceLinenumber: Integer): TPasFunctionType;
+  const ASourceFilename: string; ASourceLinenumber: Integer): TPasFunctionType;
 var
   ResultParent: TPasElement;
 begin
@@ -176,16 +178,16 @@ begin
     ResultParent := Result;
 
   TPasFunctionType(Result).ResultEl :=
-    TPasResultElement(CreateElement(TPasResultElement, 'Result', ResultParent,
+    TPasResultElement(CreateElement(TPasResultElement, resultname, ResultParent,
     ASourceFilename, ASourceLinenumber));
 end;
 
-function TPasTreeContainer.FindModule(const AName: String): TPasModule;
+function TPasTreeContainer.FindModule(const AName: string): TPasModule;
 begin
   Result := nil;
 end;
 
-constructor EParserError.Create(const AReason, AFilename: String;
+constructor EParserError.Create(const AReason, AFilename: string;
   ARow, AColumn: Integer);
 begin
   inherited Create(AReason);
@@ -194,7 +196,7 @@ begin
   FColumn := AColumn;
 end;
 
-procedure TPasParser.ParseExc(const Msg: String);
+procedure TPasParser.ParseExc(const Msg: string);
 begin
   raise EParserError.Create(Format(SParserErrorAtToken, [Msg, CurTokenName]),
     Scanner.CurFilename, Scanner.CurRow, Scanner.CurColumn);
@@ -209,7 +211,7 @@ begin
   FEngine := AEngine;
 end;
 
-function TPasParser.CurTokenName: String;
+function TPasParser.CurTokenName: string;
 begin
   if CurToken = tkIdentifier then
     Result := 'Identifier ' + Scanner.CurTokenString
@@ -217,7 +219,7 @@ begin
     Result := TokenInfos[CurToken];
 end;
 
-function TPasParser.CurTokenText: String;
+function TPasParser.CurTokenText: string;
 begin
   case CurToken of
     tkIdentifier, tkString, tkNumber, tkChar:
@@ -281,7 +283,7 @@ begin
     ParseExc(Format(SParserExpectTokenError, [TokenInfos[tk]]));
 end;
 
-function TPasParser.ExpectIdentifier: String;
+function TPasParser.ExpectIdentifier: string;
 begin
   ExpectToken(tkIdentifier);
   Result := CurTokenString;
@@ -293,7 +295,7 @@ begin
   Result:=ParseType(Parent,'');
 end;
 
-function TPasParser.ParseType(Parent: TPasElement; Prefix : String): TPasType;
+function TPasParser.ParseType(Parent: TPasElement; Prefix : string): TPasType;
 
   procedure ParseRange;
   begin
@@ -309,7 +311,7 @@ function TPasParser.ParseType(Parent: TPasElement; Prefix : String): TPasType;
   end;
 
 var
-  Name, s: String;
+  Name, s: string;
   EnumValue: TPasEnumValue;
   Ref: TPasElement;
 begin
@@ -339,7 +341,7 @@ begin
         else if s = 'LONGWORD' then Name := 'LongWord'
         else if s = 'SHORTINT' then Name := 'ShortInt'
         else if s = 'SMALLINT' then Name := 'SmallInt'
-        else if s = 'STRING' then Name := 'String'
+        else if s = 'string' then Name := 'string'
         else if s = 'WORD' then Name := 'Word'
         else
           Ref := Engine.FindElement(Name);
@@ -353,7 +355,7 @@ begin
           Result := TPasUnresolvedTypeRef(CreateElement(TPasUnresolvedTypeRef, Name, nil));
 
         // !!!: Doesn't make sense for resolved types
-        if Name = 'String' then
+        if Name = 'string' then
         begin
           NextToken;
           if CurToken = tkSquaredBraceOpen then
@@ -379,7 +381,7 @@ begin
     tkBraceOpen:
       begin
         Result := TPasEnumType(CreateElement(TPasEnumType, '', Parent));
-        while True do
+        while true do
         begin
           NextToken;
           EnumValue := TPasEnumValue(CreateElement(TPasEnumValue,
@@ -418,8 +420,8 @@ begin
         Result := TPasProcedureType(
           CreateElement(TPasProcedureType, '', Parent));
         try
-          ParseProcedureOrFunctionHeader(Result,
-            TPasProcedureType(Result), False, True);
+          ParseProcedureOrFunctionHeader(Result,TPasProcedureType(Result),
+                                         pt_procedure, true);
         except
           Result.Free;
           raise;
@@ -427,11 +429,11 @@ begin
       end;
     tkFunction:
       begin
-        Result := Engine.CreateFunctionType('', Parent, False,
+        Result := Engine.CreateFunctionType('','result', Parent, false,
           Scanner.CurFilename, Scanner.CurRow);
         try
-          ParseProcedureOrFunctionHeader(Result,
-            TPasFunctionType(Result), True, True);
+          ParseProcedureOrFunctionHeader(Result,TPasFunctionType(Result),
+                                         pt_function, true);
         except
           Result.Free;
           raise;
@@ -453,16 +455,16 @@ begin
     tkProcedure:
       begin
         Result := TPasProcedureType(CreateElement(TPasProcedureType, '', nil));
-        ParseProcedureOrFunctionHeader(Result,
-          TPasProcedureType(Result), False, True);
+        ParseProcedureOrFunctionHeader(Result, TPasProcedureType(Result),
+                                       pt_procedure, true);
         UngetToken;        // Unget semicolon
       end;
     tkFunction:
       begin
-        Result := Engine.CreateFunctionType('', nil, False, Scanner.CurFilename,
+        Result := Engine.CreateFunctionType('','result', nil, false, Scanner.CurFilename,
           Scanner.CurRow);
-        ParseProcedureOrFunctionHeader(Result,
-          TPasFunctionType(Result), True, True);
+        ParseProcedureOrFunctionHeader(Result, TPasFunctionType(Result),
+                                       pt_function, true);
         UngetToken;        // Unget semicolon
       end;
     else
@@ -477,7 +479,7 @@ end;
 procedure TPasParser.ParseArrayType(Element: TPasArrayType);
 
 Var
-  S : String;
+  S : string;
 
 begin
   NextToken;
@@ -510,16 +512,16 @@ begin
   end;
 end;
 
-function TPasParser.ParseExpression: String;
+function TPasParser.ParseExpression: string;
 var
   BracketLevel: Integer;
   MayAppendSpace, AppendSpace, NextAppendSpace: Boolean;
 begin
   SetLength(Result, 0);
   BracketLevel := 0;
-  MayAppendSpace := False;
-  AppendSpace := False;
-  while True do
+  MayAppendSpace := false;
+  AppendSpace := false;
+  while true do
   begin
     NextToken;
     { !!!: Does not detect when normal brackets and square brackets are mixed
@@ -537,7 +539,7 @@ begin
 
     if MayAppendSpace then
     begin
-      NextAppendSpace := False;
+      NextAppendSpace := false;
       case CurToken of
         tkBraceOpen, tkBraceClose, tkDivision, tkEqual, tkCaret, tkAnd, tkAs,
           tkDiv, tkIn, tkIs, tkMinus, tkMod, tkMul, tkNot, tkOf, tkOn,
@@ -545,15 +547,15 @@ begin
 {        tkPlus.._ASSIGNMENT, _UNEQUAL, tkPlusASN.._XORASN, _AS, _AT, _IN, _IS,
           tkOf, _ON, _OR, _AND, _DIV, _MOD, _NOT, _SHL, _SHR, _XOR:}
           begin
-            AppendSpace := True;
-            NextAppendSpace := True;
+            AppendSpace := true;
+            NextAppendSpace := true;
           end;
       end;
       if AppendSpace then
         Result := Result + ' ';
       AppendSpace := NextAppendSpace;
     end else
-      MayAppendSpace := True;
+      MayAppendSpace := true;
     if CurToken=tkString then
       begin
       If (Length(CurTokenText)>0) and (CurTokenText[1]=#0) then
@@ -601,7 +603,7 @@ end;
 
 // Returns the parent for an element which is to be created
 function TPasParser.CheckIfOverloaded(AOwner: TPasClassType;
-  const AName: String): TPasElement;
+  const AName: string): TPasElement;
 var
   i: Integer;
   Member: TPasElement;
@@ -663,7 +665,7 @@ begin
   Section := TPasSection(CreateElement(TPasSection, '', Module));
   Module.InterfaceSection := Section;
   CurBlock := declNone;
-  while True do
+  while true do
   begin
     NextToken;
     if CurToken = tkImplementation then
@@ -681,12 +683,12 @@ begin
         CurBlock := declVar;
       tkProcedure:
         begin
-          AddProcOrFunction(Section, ParseProcedureOrFunctionDecl(Section, False));
+          AddProcOrFunction(Section, ParseProcedureOrFunctionDecl(Section, pt_procedure));
           CurBlock := declNone;
         end;
       tkFunction:
         begin
-          AddProcOrFunction(Section, ParseProcedureOrFunctionDecl(Section, True));
+          AddProcOrFunction(Section, ParseProcedureOrFunctionDecl(Section, pt_function));
           CurBlock := declNone;
         end;
       tkProperty:
@@ -696,15 +698,7 @@ begin
         end;
       tkOperator:
         begin
-          // !!!: Not supported yet
-          i := 0;
-          repeat
-            NextToken;
-            if CurToken = tkBraceOpen then
-              Inc(i)
-            else if CurToken = tkBraceClose then
-              Dec(i);
-          until (CurToken = tkSemicolon) and (i = 0);
+          AddProcOrFunction(Section, ParseProcedureOrFunctionDecl(Section, pt_operator));
           CurBlock := declNone;
         end;
       tkIdentifier:
@@ -788,10 +782,10 @@ end;
 // Starts after the "uses" token
 procedure TPasParser.ParseUsesList(ASection: TPasSection);
 var
-  UnitName: String;
+  UnitName: string;
   Element: TPasElement;
 begin
-  while True do
+  while true do
   begin
     UnitName := ExpectIdentifier;
 
@@ -849,7 +843,7 @@ end;
 // Starts after the type name
 function TPasParser.ParseTypeDecl(Parent: TPasElement): TPasType;
 var
-  TypeName: String;
+  TypeName: string;
 
   procedure ParseRange;
   begin
@@ -867,19 +861,19 @@ var
 
 var
   EnumValue: TPasEnumValue;
-  Prefix : String;
+  Prefix : string;
   HadPackedModifier : Boolean;           // 12/04/04 - Dave - Added
 
 begin
   TypeName := CurTokenString;
   ExpectToken(tkEqual);
   NextToken;
-  HadPackedModifier := False;     { Assume not present }
+  HadPackedModifier := false;     { Assume not present }
   if CurToken = tkPacked then     { If PACKED modifier }
      begin                        { Handle PACKED modifier for all situations }
      NextToken;                   { Move to next token for rest of parse }
      if CurToken in [tkArray, tkRecord, tkObject, tkClass] then  { If allowed }
-       HadPackedModifier := True  { rememeber for later }
+       HadPackedModifier := true  { rememeber for later }
      else                         { otherwise, syntax error }
        ParseExc(Format(SParserExpectTokenError,['ARRAY, RECORD, OBJECT or CLASS']))
      end;
@@ -968,7 +962,7 @@ begin
           ParseRange;
         end;
       end;
-{    _STRING, _FILE:
+{    _string, _FILE:
       begin
         Result := TPasAliasType(CreateElement(TPasAliasType, TypeName, Parent));
         UngetToken;
@@ -1003,7 +997,7 @@ begin
       begin
         Result := TPasEnumType(CreateElement(TPasEnumType, TypeName, Parent));
         try
-          while True do
+          while true do
           begin
             NextToken;
             EnumValue := TPasEnumValue(CreateElement(TPasEnumValue,
@@ -1035,8 +1029,8 @@ begin
         Result := TPasProcedureType(CreateElement(TPasProcedureType, TypeName,
           Parent));
         try
-          ParseProcedureOrFunctionHeader(Result,
-            TPasProcedureType(Result), False, True);
+          ParseProcedureOrFunctionHeader(Result,TPasProcedureType(Result),
+                                         pt_procedure, true);
         except
           Result.Free;
           raise;
@@ -1044,11 +1038,11 @@ begin
       end;
     tkFunction:
       begin
-        Result := Engine.CreateFunctionType(TypeName, Parent, False,
+        Result := Engine.CreateFunctionType(TypeName, 'result', Parent, false,
           Scanner.CurFilename, Scanner.CurRow);
         try
-          ParseProcedureOrFunctionHeader(Result,
-            TPasFunctionType(Result), True, True);
+          ParseProcedureOrFunctionHeader(Result, TPasFunctionType(Result),
+                                         pt_function, true);
         except
           Result.Free;
           raise;
@@ -1091,7 +1085,7 @@ var
 begin
   VarNames := TStringList.Create;
   try
-    while True do
+    while true do
     begin
       VarNames.Add(CurTokenString);
       NextToken;
@@ -1128,10 +1122,10 @@ procedure TPasParser.ParseVarDecl(Parent: TPasElement; List: TList);
 var
   i: Integer;
   VarType: TPasType;
-  Value, S: String;
+  Value, S: string;
   M: string;
 begin
-  while True do
+  while true do
   begin
     List.Add(CreateElement(TPasVariable, CurTokenString, Parent));
     NextToken;
@@ -1168,7 +1162,7 @@ begin
 
   ExpectToken(tkSemicolon);
   M := '';
-  while True do
+  while true do
   begin
     NextToken;
     if CurToken = tkIdentifier then
@@ -1229,19 +1223,19 @@ procedure TPasParser.ParseArgList(Parent: TPasElement; Args: TList; EndToken: TT
 var
   ArgNames: TStringList;
   IsUntyped: Boolean;
-  Name, Value: String;
+  Name, Value: string;
   i: Integer;
   Arg: TPasArgument;
   Access: TArgumentAccess;
   ArgType: TPasType;
 begin
-  while True do
+  while true do
   begin
     ArgNames := TStringList.Create;
     Access := argDefault;
-    IsUntyped := False;
+    IsUntyped := false;
     ArgType := nil;
-    while True do
+    while true do
     begin
       NextToken;
       if CurToken = tkConst then
@@ -1269,7 +1263,7 @@ begin
       begin
         // found an untyped const or var argument
         UngetToken;
-        IsUntyped := True;
+        IsUntyped := true;
         break
       end
       else if CurToken <> tkComma then
@@ -1308,37 +1302,54 @@ end;
 // Next token is expected to be a "(", ";" or for a function ":". The caller
 // will get the token after the final ";" as next token.
 procedure TPasParser.ParseProcedureOrFunctionHeader(Parent: TPasElement;
-  Element: TPasProcedureType; IsFunction, OfObjectPossible: Boolean);
+  Element: TPasProcedureType; proctype:Tproctype; OfObjectPossible: Boolean);
+
 begin
   NextToken;
-  if IsFunction then
-  begin
-    if CurToken = tkBraceOpen then
-    begin
-      ParseArgList(Parent, Element.Args, tkBraceClose);
-      ExpectToken(tkColon);
-    end else if CurToken <> tkColon then
-      ParseExc(SParserExpectedLBracketColon);
-    if Assigned(Element) then        // !!!
-      TPasFunctionType(Element).ResultEl.ResultType := ParseType(Parent)
-    else
-      ParseType(nil);
-  end else
-  begin
-    if CurToken = tkBraceOpen then
-    begin
-      ParseArgList(Element, Element.Args, tkBraceClose);
-    end else if (CurToken = tkSemicolon) or (OfObjectPossible and (CurToken = tkOf)) then
-      UngetToken
-    else
-      ParseExc(SParserExpectedLBracketSemicolon);
+  case proctype of
+    pt_function:
+      begin
+        if CurToken = tkBraceOpen then
+        begin
+          ParseArgList(Parent, Element.Args, tkBraceClose);
+          ExpectToken(tkColon);
+        end else if CurToken <> tkColon then
+          ParseExc(SParserExpectedLBracketColon);
+        if Assigned(Element) then        // !!!
+          TPasFunctionType(Element).ResultEl.ResultType := ParseType(Parent)
+        else
+          ParseType(nil);
+      end;
+    pt_procedure:
+      begin
+        if CurToken = tkBraceOpen then
+        begin
+          ParseArgList(Element, Element.Args, tkBraceClose);
+        end else if (CurToken = tkSemicolon) or (OfObjectPossible and (CurToken = tkOf)) then
+          UngetToken
+        else
+          ParseExc(SParserExpectedLBracketSemicolon);
+      end;
+    pt_operator:
+      begin
+        ParseArgList(Parent, Element.Args, tkBraceClose);
+        
+        TPasFunctionType(Element).ResultEl.name := ExpectIdentifier;
+            
+        if CurToken <> tkColon then
+          ParseExc(SParserExpectedLBracketColon);
+        if Assigned(Element) then        // !!!
+          TPasFunctionType(Element).ResultEl.ResultType := ParseType(Parent)
+        else
+          ParseType(nil);
+      end;
   end;
 
   NextToken;
   if OfObjectPossible and (CurToken = tkOf) then
   begin
     ExpectToken(tkObject);
-    Element.IsOfObject := True;
+    Element.IsOfObject := true;
   end else
     UngetToken;
 
@@ -1352,7 +1363,7 @@ begin
 
   ExpectToken(tkSemicolon);
 
-  while True do
+  while true do
   begin
     NextToken;
     if (CurToken = tkIdentifier) and (UpperCase(CurTokenString) = 'CDECL') then
@@ -1375,7 +1386,7 @@ begin
     end else if Parent.InheritsFrom(TPasProcedure) and
       (CurToken = tkIdentifier) and (UpperCase(CurTokenString) = 'OVERLOAD') then
     begin
-      TPasProcedure(Parent).IsOverload := True;
+      TPasProcedure(Parent).IsOverload := true;
       ExpectToken(tkSemicolon);
     end else
     begin
@@ -1388,11 +1399,11 @@ end;
 
 procedure TPasParser.ParseProperty(Element:TPasElement);
 
-  function GetAccessorName: String;
+  function GetAccessorName: string;
   begin
     ExpectIdentifier;
     Result := CurTokenString;
-    while True do
+    while true do
     begin
       NextToken;
       if CurToken = tkDot then
@@ -1454,9 +1465,9 @@ begin
   begin
           NextToken;
           if CurToken = tkTrue then
-          TPasProperty(Element).StoredAccessorName := 'True'
+          TPasProperty(Element).StoredAccessorName := 'true'
           else if CurToken = tkFalse then
-          TPasProperty(Element).StoredAccessorName := 'False'
+          TPasProperty(Element).StoredAccessorName := 'false'
           else if CurToken = tkIdentifier then
           TPasProperty(Element).StoredAccessorName := CurTokenString
           else
@@ -1493,8 +1504,8 @@ begin
   NextToken;
   if CurToken = tkSemicolon then
   begin
-          TPasProperty(Element).IsDefault := True;
-          UngetToken;
+  TPasProperty(Element).IsDefault := true;
+  UngetToken;
   end else
   begin
           UngetToken;
@@ -1507,24 +1518,35 @@ end;
 
 // Starts after the "procedure" or "function" token
 function TPasParser.ParseProcedureOrFunctionDecl(Parent: TPasElement;
-  IsFunction: Boolean): TPasProcedure;
+  proctype: Tproctype): TPasProcedure;
 var
-  Name: String;
+  Name: string;
 begin
-  Name := ExpectIdentifier;
-  if IsFunction then
-  begin
-    Result := TPasFunction(CreateElement(TPasFunction, Name, Parent));
-    Result.ProcType := Engine.CreateFunctionType('', Result, True,
-      Scanner.CurFilename, Scanner.CurRow);
-  end else
-  begin
-    Result := TPasProcedure(CreateElement(TPasProcedure, Name, Parent));
-    Result.ProcType := TPasProcedureType(CreateElement(TPasProcedureType, '',
-      Result));
+  case proctype of
+    pt_function:
+      begin
+        Name := ExpectIdentifier;
+        Result := TPasFunction(CreateElement(TPasFunction, Name, Parent));
+        Result.ProcType := Engine.CreateFunctionType('', 'result', Result, true,
+           Scanner.CurFilename, Scanner.CurRow);
+      end;
+    pt_procedure:
+      begin
+        Name := ExpectIdentifier;
+        Result := TPasProcedure(CreateElement(TPasProcedure, Name, Parent));
+        Result.ProcType := TPasProcedureType(CreateElement(TPasProcedureType, '',
+           Result));
+      end;
+    pt_operator:
+      begin
+        name := tokeninfos[curtoken];
+        Result := TPasOperator(CreateElement(TPasOperator, Name, Parent));
+        Result.ProcType := Engine.CreateFunctionType('', '__INVALID__', Result, true,
+           Scanner.CurFilename, Scanner.CurRow);
+      end;
   end;
 
-  ParseProcedureOrFunctionHeader(Result, Result.ProcType, IsFunction, False);
+  ParseProcedureOrFunctionHeader(Result, Result.ProcType, proctype, false);
 end;
 
 // Starts after the "record" token
@@ -1535,7 +1557,7 @@ Var
   CCount : Integer;
 
 begin
-  while True do
+  while true do
   begin
     if CurToken = tkEnd then
       break;
@@ -1562,15 +1584,16 @@ end;
 
 // Starts after the "class" token
 function TPasParser.ParseClassDecl(Parent: TPasElement;
-  const AClassName: String; AObjKind: TPasObjKind): TPasType;
+  const AClassName: string; AObjKind: TPasObjKind): TPasType;
 var
   CurVisibility: TPasMemberVisibility;
+  pt: Tproctype;
 
-  procedure ProcessMethod(const MethodTypeName: String; HasReturnValue: Boolean);
+  procedure ProcessMethod(const MethodTypeName: string; HasReturnValue: Boolean);
   var
     Owner: TPasElement;
     Proc: TPasProcedure;
-    s: String;
+    s: string;
   begin
     ExpectIdentifier;
     Owner := CheckIfOverloaded(TPasClassType(Result), CurTokenString);
@@ -1578,7 +1601,7 @@ var
     begin
       Proc := TPasFunction(CreateElement(TPasFunction, CurTokenString, Owner,
         CurVisibility));
-      Proc.ProcType := Engine.CreateFunctionType( '', Proc, True,
+      Proc.ProcType := Engine.CreateFunctionType( '', 'result', Proc, true,
         Scanner.CurFilename, Scanner.CurRow);
     end else
     begin
@@ -1600,27 +1623,32 @@ var
     else
       TPasClassType(Result).Members.Add(Proc);
 
-    ParseProcedureOrFunctionHeader(Proc, Proc.ProcType, HasReturnValue, False);
+    if hasreturnvalue then
+      pt:=pt_function
+    else
+      pt:=pt_procedure;
+
+    ParseProcedureOrFunctionHeader(Proc, Proc.ProcType, pt, false);
 
-    while True do
+    while true do
     begin
       NextToken;
       if CurToken = tkIdentifier then
       begin
         s := UpperCase(CurTokenString);
         if s = 'VIRTUAL' then
-          Proc.IsVirtual := True
+          Proc.IsVirtual := true
         else if s = 'DYNAMIC' then
-          Proc.IsDynamic := True
+          Proc.IsDynamic := true
         else if s = 'ABSTRACT' then
-          Proc.IsAbstract := True
+          Proc.IsAbstract := true
         else if s = 'OVERRIDE' then
-          Proc.IsOverride := True
+          Proc.IsOverride := true
         else if s = 'OVERLOAD' then
-          Proc.IsOverload := True
+          Proc.IsOverload := true
         else if s = 'MESSAGE' then
         begin
-          Proc.IsMessage := True;
+          Proc.IsMessage := true;
           repeat
             NextToken;
           until CurToken = tkSemicolon;
@@ -1644,7 +1672,7 @@ var
   end;
 
 var
-  s, SourceFilename: String;
+  s, SourceFilename: string;
   i, SourceLinenumber: Integer;
   VarList: TList;
   Element: TPasElement;
@@ -1677,7 +1705,7 @@ begin
     if CurToken = tkBraceOpen then
     begin
       TPasClassType(Result).AncestorType := ParseType(nil);
-      while True do
+      while true do
       begin
         NextToken;
         if CurToken = tkBraceClose then
@@ -1726,13 +1754,13 @@ begin
               end;
             end;
           tkProcedure:
-            ProcessMethod('procedure', False);
+            ProcessMethod('procedure', false);
           tkFunction:
-            ProcessMethod('function', True);
+            ProcessMethod('function', true);
           tkConstructor:
-            ProcessMethod('constructor', False);
+            ProcessMethod('constructor', false);
           tkDestructor:
-            ProcessMethod('destructor', False);
+            ProcessMethod('destructor', false);
           tkProperty:
             begin
               ExpectIdentifier;
@@ -1752,14 +1780,14 @@ begin
   end;
 end;
 
-function TPasParser.CreateElement(AClass: TPTreeElement; const AName: String;
+function TPasParser.CreateElement(AClass: TPTreeElement; const AName: string;
   AParent: TPasElement): TPasElement;
 begin
   Result := Engine.CreateElement(AClass, AName, AParent,
     Scanner.CurFilename, Scanner.CurRow);
 end;
 
-function TPasParser.CreateElement(AClass: TPTreeElement; const AName: String;
+function TPasParser.CreateElement(AClass: TPTreeElement; const AName: string;
   AParent: TPasElement; AVisibility: TPasMemberVisibility): TPasElement;
 begin
   Result := Engine.CreateElement(AClass, AName, AParent, AVisibility,
@@ -1768,18 +1796,18 @@ end;
 
 
 function ParseSource(AEngine: TPasTreeContainer;
-  const FPCCommandLine, OSTarget, CPUTarget: String): TPasModule;
+  const FPCCommandLine, OSTarget, CPUTarget: string): TPasModule;
 var
   FileResolver: TFileResolver;
   Parser: TPasParser;
   Start, CurPos: PChar;
-  Filename: String;
+  Filename: string;
   Scanner: TPascalScanner;
 
   procedure ProcessCmdLinePart;
   var
     l: Integer;
-    s: String;
+    s: string;
   begin
     l := CurPos - Start;
     SetLength(s, l);
@@ -1804,7 +1832,7 @@ var
   end;
 
 var
-  s: String;
+  s: string;
 begin
   Result := nil;
   FileResolver := nil;

fcl/passrc/pscanner.pp

@@ -23,7 +23,7 @@ uses SysUtils, Classes;
 
 resourcestring
   SErrInvalidCharacter = 'Invalid character ''%s''';
-  SErrOpenString = 'String exceeds end of line';
+  SErrOpenString = 'string exceeds end of line';
   SErrIncludeFileNotFound = 'Could not find include file ''%s''';
   SErrIfXXXNestingLimitReached = 'Nesting of $IFxxx too deep';
   SErrInvalidPPElse = '$ELSE without matching $IFxxx';
@@ -133,7 +133,7 @@ type
   TLineReader = class
   public
     function IsEOF: Boolean; virtual; abstract;
-    function ReadLine: String; virtual; abstract;
+    function ReadLine: string; virtual; abstract;
   end;
 
   TFileLineReader = class(TLineReader)
@@ -141,10 +141,10 @@ type
     FTextFile: Text;
     FileOpened: Boolean;
   public
-    constructor Create(const AFilename: String);
+    constructor Create(const AFilename: string);
     destructor Destroy; override;
     function IsEOF: Boolean; override;
-    function ReadLine: String; override;
+    function ReadLine: string; override;
   end;
 
   TFileResolver = class
@@ -153,9 +153,9 @@ type
   public
     constructor Create;
     destructor Destroy; override;
-    procedure AddIncludePath(const APath: String);
-    function FindSourceFile(const AName: String): TLineReader;
-    function FindIncludeFile(const AName: String): TLineReader;
+    procedure AddIncludePath(const APath: string);
+    function FindSourceFile(const AName: string): TLineReader;
+    function FindIncludeFile(const AName: string): TLineReader;
   end;
 
   EScannerError       = class(Exception);
@@ -168,11 +168,11 @@ type
   private
     FFileResolver: TFileResolver;
     FCurSourceFile: TLineReader;
-    FCurFilename: String;
+    FCurFilename: string;
     FCurRow: Integer;
     FCurToken: TToken;
-    FCurTokenString: String;
-    FCurLine: String;
+    FCurTokenString: string;
+    FCurLine: string;
     FDefines: TStrings;
     TokenStr: PChar;
     FIncludeStack: TList;
@@ -186,36 +186,36 @@ type
 
     function GetCurColumn: Integer;
   protected
-    procedure Error(const Msg: String);
-    procedure Error(const Msg: String; Args: array of Const);
+    procedure Error(const Msg: string);
+    procedure Error(const Msg: string; Args: array of Const);
     function DoFetchToken: TToken;
   public
     constructor Create(AFileResolver: TFileResolver);
     destructor Destroy; override;
-    procedure OpenFile(const AFilename: String);
+    procedure OpenFile(const AFilename: string);
     function FetchToken: TToken;
 
     property FileResolver: TFileResolver read FFileResolver;
     property CurSourceFile: TLineReader read FCurSourceFile;
-    property CurFilename: String read FCurFilename;
+    property CurFilename: string read FCurFilename;
 
-    property CurLine: String read FCurLine;
+    property CurLine: string read FCurLine;
     property CurRow: Integer read FCurRow;
     property CurColumn: Integer read GetCurColumn;
 
     property CurToken: TToken read FCurToken;
-    property CurTokenString: String read FCurTokenString;
+    property CurTokenString: string read FCurTokenString;
 
     property Defines: TStrings read FDefines;
   end;
 
 const
-  TokenInfos: array[TToken] of String = (
+  TokenInfos: array[TToken] of string = (
     'EOF',
     'Whitespace',
     'Comment',
     'Identifier',
-    'String',
+    'string',
     'Number',
     'Character',
     '(',
@@ -314,21 +314,21 @@ implementation
 type
   TIncludeStackItem = class
     SourceFile: TLineReader;
-    Filename: String;
+    Filename: string;
     Token: TToken;
-    TokenString: String;
-    Line: String;
+    TokenString: string;
+    Line: string;
     Row: Integer;
     TokenStr: PChar;
   end;
 
 
-constructor TFileLineReader.Create(const AFilename: String);
+constructor TFileLineReader.Create(const AFilename: string);
 begin
   inherited Create;
   Assign(FTextFile, AFilename);
   Reset(FTextFile);
-  FileOpened := True;
+  FileOpened := true;
 end;
 
 destructor TFileLineReader.Destroy;
@@ -343,7 +343,7 @@ begin
   Result := EOF(FTextFile);
 end;
 
-function TFileLineReader.ReadLine: String;
+function TFileLineReader.ReadLine: string;
 begin
   ReadLn(FTextFile, Result);
 end;
@@ -361,12 +361,12 @@ begin
   inherited Destroy;
 end;
 
-procedure TFileResolver.AddIncludePath(const APath: String);
+procedure TFileResolver.AddIncludePath(const APath: string);
 begin
   FIncludePaths.Add(IncludeTrailingPathDelimiter(ExpandFileName(APath)));
 end;
 
-function TFileResolver.FindSourceFile(const AName: String): TLineReader;
+function TFileResolver.FindSourceFile(const AName: string): TLineReader;
 begin
   if not FileExists(AName) then
     Raise EFileNotFoundError.create(Aname)
@@ -378,10 +378,10 @@ begin
     end;
 end;
 
-function TFileResolver.FindIncludeFile(const AName: String): TLineReader;
+function TFileResolver.FindIncludeFile(const AName: string): TLineReader;
 var
   i: Integer;
-  FN : String;
+  FN : string;
 
 begin
   Result := nil;
@@ -428,7 +428,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TPascalScanner.OpenFile(const AFilename: String);
+procedure TPascalScanner.OpenFile(const AFilename: string);
 begin
   FCurSourceFile := FileResolver.FindSourceFile(AFilename);
   FCurFilename := AFilename;
@@ -438,7 +438,7 @@ function TPascalScanner.FetchToken: TToken;
 var
   IncludeStackItem: TIncludeStackItem;
 begin
-  while True do
+  while true do
   begin
     Result := DoFetchToken;
     if FCurToken = tkEOF then
@@ -465,12 +465,12 @@ begin
   end;
 end;
 
-procedure TPascalScanner.Error(const Msg: String);
+procedure TPascalScanner.Error(const Msg: string);
 begin
   raise EScannerError.Create(Msg);
 end;
 
-procedure TPascalScanner.Error(const Msg: String; Args: array of Const);
+procedure TPascalScanner.Error(const Msg: string; Args: array of Const);
 begin
   raise EScannerError.CreateFmt(Msg, Args);
 end;
@@ -483,12 +483,12 @@ function TPascalScanner.DoFetchToken: TToken;
     begin
       FCurLine := '';
       TokenStr := nil;
-      Result := False;
+      Result := false;
     end else
     begin
       FCurLine := CurSourceFile.ReadLine;
       TokenStr := PChar(CurLine);
-      Result := True;
+      Result := true;
       Inc(FCurRow);
     end;
   end;
@@ -497,7 +497,7 @@ var
   TokenStart, CurPos: PChar;
   i: TToken;
   OldLength, SectionLength, NestingLevel, Index: Integer;
-  Directive, Param: String;
+  Directive, Param: string;
   IncludeStackItem: TIncludeStackItem;
 begin
   if TokenStr = nil then
@@ -581,7 +581,7 @@ begin
         OldLength := 0;
         FCurTokenString := '';
 
-        while True do
+        while true do
         begin
           if TokenStr[0] = '''' then
             if TokenStr[1] = '''' then
@@ -692,7 +692,7 @@ begin
     '0'..'9':
       begin
         TokenStart := TokenStr;
-        while True do
+        while true do
         begin
           Inc(TokenStr);
           case TokenStr[0] of
@@ -894,7 +894,7 @@ begin
               if PPIsSkipping then
               begin
                 PPSkipMode := ppSkipAll;
-                PPIsSkipping := True;
+                PPIsSkipping := true;
               end else
               begin
                 Param := UpperCase(Param);
@@ -902,7 +902,7 @@ begin
                 if Index < 0 then
                 begin
                   PPSkipMode := ppSkipIfBranch;
-                  PPIsSkipping := True;
+                  PPIsSkipping := true;
                 end else
                   PPSkipMode := ppSkipElseBranch;
               end;
@@ -916,7 +916,7 @@ begin
               if PPIsSkipping then
               begin
                 PPSkipMode := ppSkipAll;
-                PPIsSkipping := True;
+                PPIsSkipping := true;
               end else
               begin
                 Param := UpperCase(Param);
@@ -924,7 +924,7 @@ begin
                 if Index >= 0 then
                 begin
                   PPSkipMode := ppSkipIfBranch;
-                  PPIsSkipping := True;
+                  PPIsSkipping := true;
                 end else
                   PPSkipMode := ppSkipElseBranch;
               end;
@@ -938,13 +938,13 @@ begin
               if PPIsSkipping then
               begin
                 PPSkipMode := ppSkipAll;
-                PPIsSkipping := True;
+                PPIsSkipping := true;
               end else
               begin
                 { !!!: Currently, options are not supported, so they are just
                   assumed as not being set. }
                 PPSkipMode := ppSkipIfBranch;
-                PPIsSkipping := True;
+                PPIsSkipping := true;
               end;
             end else if Directive = 'IF' then
             begin
@@ -956,22 +956,22 @@ begin
               if PPIsSkipping then
               begin
                 PPSkipMode := ppSkipAll;
-                PPIsSkipping := True;
+                PPIsSkipping := true;
               end else
               begin
                 { !!!: Currently, expressions are not supported, so they are
                   just assumed as evaluating to false. }
                 PPSkipMode := ppSkipIfBranch;
-                PPIsSkipping := True;
+                PPIsSkipping := true;
               end;
             end else if Directive = 'ELSE' then
             begin
               if PPSkipStackIndex = 0 then
                 Error(SErrInvalidPPElse);
               if PPSkipMode = ppSkipIfBranch then
-                PPIsSkipping := False
+                PPIsSkipping := false
               else if PPSkipMode = ppSkipElseBranch then
-                PPIsSkipping := True;
+                PPIsSkipping := true;
             end else if Directive = 'ENDIF' then
             begin
               if PPSkipStackIndex = 0 then