Página Principal Explorar Ajuda
Iniciar Sessão
pascal
/
freepascal.compiler
mirror de https://gitlab.com/freepascal.org/fpc/source.git
2
0
Fork 0
Ficheiros Problemas 0 Wiki
Ver Fonte

packages: replace UTF8String to AnsiString at least for now.

git-svn-id: trunk@19134 -
paul há 14 anos atrás
pai
85450d5469
commit
1f129cfee0
3 ficheiros alterados com 351 adições e 351 exclusões
Visão Dividida Mostrar Estatísticas Diff
  1. 5 5
      packages/fcl-base/src/uriparser.pp
  2. 75 75
      packages/libxml/src/xmlxsd.pas
  3. 271 271
      packages/libxml/src/xmlxsdparser.pas

+ 5 - 5
packages/fcl-base/src/uriparser.pp
Ver Ficheiro 

@@ -43,8 +43,8 @@ function ParseURI(const URI, DefaultProtocol: String; DefaultPort: Word):  TURI;
 
 function ResolveRelativeURI(const BaseUri, RelUri: WideString;
 
   out ResultUri: WideString): Boolean; overload;
 
 
-function ResolveRelativeURI(const BaseUri, RelUri: UTF8String;
 
-  out ResultUri: UTF8String): Boolean; overload;
 
+function ResolveRelativeURI(const BaseUri, RelUri: AnsiString;
 
+  out ResultUri: AnsiString): Boolean; overload;
 
 
 function URIToFilename(const URI: string; out Filename: string): Boolean;
 
 function FilenameToURI(const Filename: string): string;
 
@@ -312,8 +312,8 @@ begin
 
 end;
 
 
 // TODO: this probably must NOT percent-encode the result...
 
-function ResolveRelativeURI(const BaseUri, RelUri: UTF8String;
 
-  out ResultUri: UTF8String): Boolean;
 
+function ResolveRelativeURI(const BaseUri, RelUri: AnsiString;
 
+  out ResultUri: AnsiString): Boolean;
 
 var
 
   Base, Rel: TUri;
 
 begin
 
@@ -362,7 +362,7 @@ end;
 
 function ResolveRelativeURI(const BaseUri, RelUri: WideString;
 
   out ResultUri: WideString): Boolean;
 
 var
 
-  rslt: UTF8String;
 
+  rslt: AnsiString;
 
 begin
 
   Result := ResolveRelativeURI(UTF8Encode(BaseUri), UTF8Encode(RelUri), rslt);
 
   if Result then

+ 75 - 75
packages/libxml/src/xmlxsd.pas
Ver Ficheiro 

@@ -34,8 +34,8 @@ type
 
 
 { Node creation functions }
 
 function xsdNewChildBase64(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: TStream): xmlNodePtr;
 
-function xsdNewChildCData(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Utf8String): xmlNodePtr;
 
-function xsdNewChildString(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Utf8String): xmlNodePtr;
 
+function xsdNewChildCData(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: AnsiString): xmlNodePtr;
 
+function xsdNewChildString(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: AnsiString): xmlNodePtr;
 
 function xsdNewChildBoolean(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Boolean; UseWords: Boolean = False): xmlNodePtr;
 
 function xsdNewChildDate(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Year, Month, Day: Longword; BC: Boolean = False; Timezone: PXsdTimezone = nil): xmlNodePtr;
 
 function xsdNewChildDate(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Date: TDateTime; Timezone: PXsdTimezone = nil): xmlNodePtr;
 
@@ -54,10 +54,10 @@ function xsdNewChildUnsignedByte(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlChar
 
 function xsdNewChildUnsignedShort(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Word): xmlNodePtr;
 
 function xsdNewChildUnsignedInt(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Longword): xmlNodePtr;
 
 function xsdNewChildUnsignedLong(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: QWord): xmlNodePtr;
 
-function xsdNewChildEnum(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of Utf8String; Value: Integer): xmlNodePtr;
 
+function xsdNewChildEnum(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of AnsiString; Value: Integer): xmlNodePtr;
 
 
 { Property creation functions }
 
-function xsdNewPropString(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Utf8String): xmlAttrPtr;
 
+function xsdNewPropString(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: AnsiString): xmlAttrPtr;
 
 function xsdNewPropBoolean(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Boolean; UseWords: Boolean = False): xmlAttrPtr;
 
 function xsdNewPropDate(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Year, Month, Day: Longword; BC: Boolean = False; Timezone: PXsdTimezone = nil): xmlAttrPtr;
 
 function xsdNewPropDate(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Date: TDateTime; Timezone: PXsdTimezone = nil): xmlAttrPtr;
 
@@ -76,7 +76,7 @@ function xsdNewPropUnsignedByte(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr
 
 function xsdNewPropUnsignedShort(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Word): xmlAttrPtr;
 
 function xsdNewPropUnsignedInt(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Longword): xmlAttrPtr;
 
 function xsdNewPropUnsignedLong(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: QWord): xmlAttrPtr;
 
-function xsdNewPropEnum(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of Utf8String; Value: Integer): xmlAttrPtr;
 
+function xsdNewPropEnum(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of AnsiString; Value: Integer): xmlAttrPtr;
 
 
 { Query functions }
 
 const
 
@@ -91,7 +91,7 @@ function xsdTryGetChild(node: xmlNodePtr; name, nameSpace: xmlCharPtr; Index: In
 
 function xsdTryGetChild(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out child: xmlNodePtr; Index: Integer = 0): Boolean;
 
 function xsdTryGetChildChars(node: xmlNodePtr; name, nameSpace: xmlCharPtr; Index: Integer = 0): xmlCharPtr;
 
 function xsdTryGetChildBase64(node: xmlNodePtr; name, nameSpace: xmlCharPtr; const Value: TStream; Index: Integer = 0): Boolean;
 
-function xsdTryGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String; Index: Integer = 0): Boolean;
 
+function xsdTryGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString; Index: Integer = 0): Boolean;
 
 function xsdTryGetChildBoolean(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Boolean; Index: Integer = 0): Boolean;
 
 function xsdTryGetChildDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil; Index: Integer = 0): Boolean;
 
 function xsdTryGetChildDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: TDateTime; Timezone: PXsdTimezone = nil; Index: Integer = 0): Boolean;
 
@@ -110,12 +110,12 @@ function xsdTryGetChildUnsignedByte(node: xmlNodePtr; name, nameSpace: xmlCharPt
 
 function xsdTryGetChildUnsignedShort(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Word; Index: Integer = 0): Boolean;
 
 function xsdTryGetChildUnsignedInt(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Longword; Index: Integer = 0): Boolean;
 
 function xsdTryGetChildUnsignedLong(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: QWord; Index: Integer = 0): Boolean;
 
-function xsdTryGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer; Index: Integer = 0): Boolean;
 
+function xsdTryGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer; Index: Integer = 0): Boolean;
 
 
 function xsdGetChild(node: xmlNodePtr; name, nameSpace: xmlCharPtr; Index: Integer = 0): xmlNodePtr;
 
 function xsdGetChildChars(node: xmlNodePtr; name, nameSpace: xmlCharPtr; Index: Integer = 0): xmlCharPtr;
 
 procedure xsdGetChildBase64(node: xmlNodePtr; name, nameSpace: xmlCharPtr; const Value: TStream; Index: Integer = 0);
 
-procedure xsdGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String; Index: Integer = 0);
 
+procedure xsdGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString; Index: Integer = 0);
 
 procedure xsdGetChildBoolean(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Boolean; Index: Integer = 0);
 
 procedure xsdGetChildDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil; Index: Integer = 0);
 
 procedure xsdGetChildDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: TDateTime; Timezone: PXsdTimezone = nil; Index: Integer = 0);
 
@@ -134,14 +134,14 @@ procedure xsdGetChildUnsignedByte(node: xmlNodePtr; name, nameSpace: xmlCharPtr;
 
 procedure xsdGetChildUnsignedShort(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Word; Index: Integer = 0);
 
 procedure xsdGetChildUnsignedInt(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Longword; Index: Integer = 0);
 
 procedure xsdGetChildUnsignedLong(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: QWord; Index: Integer = 0);
 
-procedure xsdGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer; Index: Integer = 0);
 
+procedure xsdGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer; Index: Integer = 0);
 
 
 { Node parsing functions }
 
 function xsdTryNext(var node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlNodePtr;
 
 function xsdTryNext(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out last: xmlNodePtr): Boolean;
 
 function xsdTryNextChars(var node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlCharPtr;
 
 function xsdTryNextBase64(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; const Value: TStream): Boolean;
 
-function xsdTryNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String): Boolean;
 
+function xsdTryNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString): Boolean;
 
 function xsdTryNextBoolean(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Boolean): Boolean;
 
 function xsdTryNextDate(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil): Boolean;
 
 function xsdTryNextDate(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
@@ -160,12 +160,12 @@ function xsdTryNextUnsignedByte(var node: xmlNodePtr; name, nameSpace: xmlCharPt
 
 function xsdTryNextUnsignedShort(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Word): Boolean;
 
 function xsdTryNextUnsignedInt(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Longword): Boolean;
 
 function xsdTryNextUnsignedLong(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: QWord): Boolean;
 
-function xsdTryNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer): Boolean;
 
+function xsdTryNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer): Boolean;
 
 
 function xsdNext(var node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlNodePtr;
 
 function xsdNextChars(var node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlCharPtr;
 
 procedure xsdNextBase64(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; const Value: TStream);
 
-procedure xsdNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String);
 
+procedure xsdNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString);
 
 procedure xsdNextBoolean(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Boolean);
 
 procedure xsdNextDate(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil);
 
 procedure xsdNextDate(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
@@ -184,7 +184,7 @@ procedure xsdNextUnsignedByte(var node: xmlNodePtr; name, nameSpace: xmlCharPtr;
 
 procedure xsdNextUnsignedShort(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Word);
 
 procedure xsdNextUnsignedInt(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Longword);
 
 procedure xsdNextUnsignedLong(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: QWord);
 
-procedure xsdNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer);
 
+procedure xsdNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer);
 
 
 { Property query functions }
 
 function xsdTestPropNs(attr: xmlAttrPtr; nameSpace: xmlCharPtr): Boolean;
 
@@ -192,7 +192,7 @@ function xsdTestProp(attr: xmlAttrPtr; name, nameSpace: xmlCharPtr): Boolean;
 
 
 function xsdTryGetProp(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlAttrPtr;
 
 function xsdTryGetPropChars(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlCharPtr;
 
-function xsdTryGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String): Boolean;
 
+function xsdTryGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString): Boolean;
 
 function xsdTryGetPropBoolean(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Boolean): Boolean;
 
 function xsdTryGetPropDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil): Boolean;
 
 function xsdTryGetPropDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
@@ -211,11 +211,11 @@ function xsdTryGetPropUnsignedByte(node: xmlNodePtr; name, nameSpace: xmlCharPtr
 
 function xsdTryGetPropUnsignedShort(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Word): Boolean;
 
 function xsdTryGetPropUnsignedInt(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Longword): Boolean;
 
 function xsdTryGetPropUnsignedLong(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: QWord): Boolean;
 
-function xsdTryGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer): Boolean;
 
+function xsdTryGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer): Boolean;
 
 
 function xsdGetProp(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlAttrPtr;
 
 function xsdGetPropChars(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlCharPtr;
 
-procedure xsdGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String);
 
+procedure xsdGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString);
 
 procedure xsdGetPropBoolean(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Boolean);
 
 procedure xsdGetPropDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil);
 
 procedure xsdGetPropDate(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
@@ -234,9 +234,9 @@ procedure xsdGetPropUnsignedByte(node: xmlNodePtr; name, nameSpace: xmlCharPtr;
 
 procedure xsdGetPropUnsignedShort(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Word);
 
 procedure xsdGetPropUnsignedInt(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Longword);
 
 procedure xsdGetPropUnsignedLong(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: QWord);
 
-procedure xsdGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer);
 
+procedure xsdGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer);
 
 
-function xsdRemoveBlanks(content: xmlCharPtr; out cleaned: Utf8String): boolean;
 
+function xsdRemoveBlanks(content: xmlCharPtr; out cleaned: AnsiString): boolean;
 
 
 implementation
 
 
@@ -252,27 +252,27 @@ end;
 
 
 function xsdNewChildBase64(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: TStream): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatBase64(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
 end;
 
 
-function xsdNewChildCData(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Utf8String): xmlNodePtr;
 
+function xsdNewChildCData(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: AnsiString): xmlNodePtr;
 
 begin
 
   Result := xmlNewNode(ns, name);
 
   xmlAddChild(Result, xmlNewCDataBlock(parent^.doc, PChar(Value), Length(Value)));
 
   xmlAddChild(parent, Result);
 
 end;
 
 
-function xsdNewChildString(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Utf8String): xmlNodePtr;
 
+function xsdNewChildString(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: AnsiString): xmlNodePtr;
 
 begin
 
   Result := xmlNewChild(parent, ns, name, PChar(Value));
 
 end;
 
 
 function xsdNewChildBoolean(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Boolean; UseWords: Boolean): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatBoolean(Value, UseWords);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -280,7 +280,7 @@ end;
 
 
 function xsdNewChildTime(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatTime(Hour, Minute, Second, Milliseconds, Timezone);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -288,7 +288,7 @@ end;
 
 
 function xsdNewChildTime(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Time: TDateTime; Timezone: PXsdTimezone): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatTime(Time, Timezone);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -296,7 +296,7 @@ end;
 
 
 function xsdNewChildDate(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Year, Month, Day: Longword; BC: Boolean; Timezone: PXsdTimezone): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDate(Year, Month, Day, BC, Timezone);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -304,7 +304,7 @@ end;
 
 
 function xsdNewChildDate(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Date: TDateTime; Timezone: PXsdTimezone): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDate(Date, Timezone);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -312,7 +312,7 @@ end;
 
 
 function xsdNewChildDateTime(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; BC: Boolean; Timezone: PXsdTimezone): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDateTime(Year, Month, Day, Hour, Minute, Second, Milliseconds, BC, Timezone);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -320,7 +320,7 @@ end;
 
 
 function xsdNewChildDateTime(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; DateTime: TDateTime; Timezone: PXsdTimezone): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDateTime(DateTime, Timezone);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -328,7 +328,7 @@ end;
 
 
 function xsdNewChildDecimal(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Extended; Precision: Integer; Digits: Integer): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDecimal(Value, Precision, Digits);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -336,7 +336,7 @@ end;
 
 
 function xsdNewChildDouble(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Double): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDouble(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -344,7 +344,7 @@ end;
 
 
 function xsdNewChildFloat(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Single): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatFloat(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -352,7 +352,7 @@ end;
 
 
 function xsdNewChildByte(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Shortint): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatByte(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -360,7 +360,7 @@ end;
 
 
 function xsdNewChildShort(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Smallint): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatShort(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -368,7 +368,7 @@ end;
 
 
 function xsdNewChildInt(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Longint): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatInt(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -376,7 +376,7 @@ end;
 
 
 function xsdNewChildLong(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Int64): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatLong(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -384,7 +384,7 @@ end;
 
 
 function xsdNewChildUnsignedByte(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Byte): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedByte(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -392,7 +392,7 @@ end;
 
 
 function xsdNewChildUnsignedShort(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Word): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedShort(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -400,7 +400,7 @@ end;
 
 
 function xsdNewChildUnsignedInt(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Longword): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedInt(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
@@ -408,28 +408,28 @@ end;
 
 
 function xsdNewChildUnsignedLong(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: QWord): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedLong(Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
 end;
 
 
-function xsdNewChildEnum(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of Utf8String; Value: Integer): xmlNodePtr;
 
+function xsdNewChildEnum(parent: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of AnsiString; Value: Integer): xmlNodePtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatEnum(enum, Value);
 
   Result := xmlNewChild(parent, ns, name, PChar(Tmp));
 
 end;
 
 
-function xsdNewPropString(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Utf8String): xmlAttrPtr;
 
+function xsdNewPropString(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: AnsiString): xmlAttrPtr;
 
 begin
 
   Result := xmlNewNsProp(node, ns, name, PChar(Value));
 
 end;
 
 
 function xsdNewPropBoolean(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Boolean; UseWords: Boolean): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatBoolean(Value, UseWords);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -437,7 +437,7 @@ end;
 
 
 function xsdNewPropTime(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatTime(Hour, Minute, Second, Milliseconds, Timezone);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -445,7 +445,7 @@ end;
 
 
 function xsdNewPropTime(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Time: TDateTime; Timezone: PXsdTimezone): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatTime(Time, Timezone);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -453,7 +453,7 @@ end;
 
 
 function xsdNewPropDate(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Year, Month, Day: Longword; BC: Boolean; Timezone: PXsdTimezone): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDate(Year, Month, Day, BC, Timezone);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -461,7 +461,7 @@ end;
 
 
 function xsdNewPropDate(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Date: TDateTime; Timezone: PXsdTimezone): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDate(Date, Timezone);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -469,7 +469,7 @@ end;
 
 
 function xsdNewPropDateTime(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; BC: Boolean; Timezone: PXsdTimezone): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDateTime(Year, Month, Day, Hour, Minute, Second, Milliseconds, BC, Timezone);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -477,7 +477,7 @@ end;
 
 
 function xsdNewPropDateTime(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; DateTime: TDateTime; Timezone: PXsdTimezone): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDateTime(DateTime, Timezone);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -485,7 +485,7 @@ end;
 
 
 function xsdNewPropDecimal(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Extended; Precision: Integer; Digits: Integer): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDecimal(Value, Precision, Digits);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -493,7 +493,7 @@ end;
 
 
 function xsdNewPropDouble(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Double): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatDouble(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -501,7 +501,7 @@ end;
 
 
 function xsdNewPropFloat(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Single): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatFloat(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -509,7 +509,7 @@ end;
 
 
 function xsdNewPropByte(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Shortint): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatByte(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -517,7 +517,7 @@ end;
 
 
 function xsdNewPropShort(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Smallint): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatShort(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -525,7 +525,7 @@ end;
 
 
 function xsdNewPropInt(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Longint): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatInt(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -533,7 +533,7 @@ end;
 
 
 function xsdNewPropLong(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Int64): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatLong(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -541,7 +541,7 @@ end;
 
 
 function xsdNewPropUnsignedByte(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Byte): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedByte(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -549,7 +549,7 @@ end;
 
 
 function xsdNewPropUnsignedShort(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Word): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedShort(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -557,7 +557,7 @@ end;
 
 
 function xsdNewPropUnsignedInt(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: Longword): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedInt(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -565,15 +565,15 @@ end;
 
 
 function xsdNewPropUnsignedLong(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; Value: QWord): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatUnsignedLong(Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
 end;
 
 
-function xsdNewPropEnum(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of Utf8String; Value: Integer): xmlAttrPtr;
 
+function xsdNewPropEnum(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr; enum: array of AnsiString; Value: Integer): xmlAttrPtr;
 
 var
 
-  Tmp: Utf8String;
 
+  Tmp: AnsiString;
 
 begin
 
   Tmp := xsdFormatEnum(enum, Value);
 
   Result := xmlNewNsProp(node, ns, name, PChar(Tmp));
 
@@ -627,7 +627,7 @@ begin
 
   Result := xsdTryParseBase64(xsdTryGetChildChars(node, name, nameSpace, Index), -1, Value);
 
 end;
 
 
-function xsdTryGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String; Index: Integer): Boolean;
 
+function xsdTryGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString; Index: Integer): Boolean;
 
 begin
 
   Result := xsdTryParseString(xsdTryGetChildChars(node, name, nameSpace, Index), -1, Value);
 
 end;
 
@@ -722,7 +722,7 @@ begin
 
   Result := xsdTryParseUnsignedLong(xsdTryGetChildChars(node, name, nameSpace, Index), -1, Value);
 
 end;
 
 
-function xsdTryGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer; Index: Integer): Boolean;
 
+function xsdTryGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer; Index: Integer): Boolean;
 
 begin
 
   Result := xsdTryParseEnum(xsdTryGetChildChars(node, name, nameSpace, Index), -1, enum, Value);
 
 end;
 
@@ -744,7 +744,7 @@ begin
 
   xsdParseBase64(xsdGetChildChars(node, name, nameSpace, Index), -1, Value);
 
 end;
 
 
-procedure xsdGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String; Index: Integer);
 
+procedure xsdGetChildString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString; Index: Integer);
 
 begin
 
   xsdParseString(xsdGetChildChars(node, name, nameSpace, Index), -1, Value);
 
 end;
 
@@ -839,7 +839,7 @@ begin
 
   xsdParseUnsignedLong(xsdGetChildChars(node, name, nameSpace, Index), -1, Value);
 
 end;
 
 
-procedure xsdGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer; Index: Integer);
 
+procedure xsdGetChildEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer; Index: Integer);
 
 begin
 
   xsdParseEnum(xsdGetChildChars(node, name, nameSpace, Index), -1, enum, Value);
 
 end;
 
@@ -873,7 +873,7 @@ begin
 
   Result := xsdTryParseBase64(xsdTryNextChars(node, name, nameSpace), -1, Value);
 
 end;
 
 
-function xsdTryNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String): Boolean;
 
+function xsdTryNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString): Boolean;
 
 begin
 
   Result := xsdTryParseString(xsdTryNextChars(node, name, nameSpace), -1, Value);
 
 end;
 
@@ -968,7 +968,7 @@ begin
 
   Result := xsdTryParseUnsignedLong(xsdTryNextChars(node, name, nameSpace), -1, Value);
 
 end;
 
 
-function xsdTryNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer): Boolean;
 
+function xsdTryNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer): Boolean;
 
 begin
 
   Result := xsdTryParseEnum(xsdTryNextChars(node, name, nameSpace), -1, enum, Value);
 
 end;
 
@@ -990,7 +990,7 @@ begin
 
   xsdParseBase64(xsdNextChars(node, name, nameSpace), -1, Value);
 
 end;
 
 
-procedure xsdNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String);
 
+procedure xsdNextString(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString);
 
 begin
 
   xsdParseString(xsdNextChars(node, name, nameSpace), -1, Value);
 
 end;
 
@@ -1085,7 +1085,7 @@ begin
 
   xsdParseUnsignedLong(xsdNextChars(node, name, nameSpace), -1, Value);
 
 end;
 
 
-procedure xsdNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer);
 
+procedure xsdNextEnum(var node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer);
 
 begin
 
   xsdParseEnum(xsdNextChars(node, name, nameSpace), -1, enum, Value);
 
 end;
 
@@ -1129,7 +1129,7 @@ begin
 
     Result := nil;
 
 end;
 
 
-function xsdTryGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String): Boolean;
 
+function xsdTryGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString): Boolean;
 
 begin
 
   Result := xsdTryParseString(xsdTryGetPropChars(node, name, nameSpace), -1, Value);
 
 end;
 
@@ -1224,7 +1224,7 @@ begin
 
   Result := xsdTryParseUnsignedLong(xsdTryGetPropChars(node, name, nameSpace), -1, Value);
 
 end;
 
 
-function xsdTryGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer): Boolean;
 
+function xsdTryGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer): Boolean;
 
 begin
 
   Result := xsdTryParseEnum(xsdTryGetPropChars(node, name, nameSpace), -1, enum, Value);
 
 end;
 
@@ -1241,7 +1241,7 @@ begin
 
   Result := xmlNodeGetContent(xsdGetProp(node, name, nameSpace)^.children);
 
 end;
 
 
-procedure xsdGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: Utf8String);
 
+procedure xsdGetPropString(node: xmlNodePtr; name, nameSpace: xmlCharPtr; out Value: AnsiString);
 
 begin
 
   xsdParseString(xsdGetPropChars(node, name, nameSpace), -1, Value);
 
 end;
 
@@ -1336,12 +1336,12 @@ begin
 
   xsdParseUnsignedLong(xsdGetPropChars(node, name, nameSpace), -1, Value);
 
 end;
 
 
-procedure xsdGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of Utf8String; out Value: Integer);
 
+procedure xsdGetPropEnum(node: xmlNodePtr; name, nameSpace: xmlCharPtr; enum: array of AnsiString; out Value: Integer);
 
 begin
 
   xsdParseEnum(xsdGetPropChars(node, name, nameSpace), -1, enum, Value);
 
 end;
 
 
-function xsdRemoveBlanks(content: xmlCharPtr; out cleaned: Utf8String): boolean;
 
+function xsdRemoveBlanks(content: xmlCharPtr; out cleaned: AnsiString): boolean;
 
 var
 
   Space: Boolean;
 
   len: Integer;

+ 271 - 271
packages/libxml/src/xmlxsdparser.pas
Ver Ficheiro 

@@ -47,26 +47,26 @@ const
 
 
 
 { Format functions }
 
-function xsdFormatBase64(Value: TStream): Utf8String;
 
-function xsdFormatBoolean(Value: Boolean; UseWords: Boolean = False): Utf8String;
 
-function xsdFormatDate(Year, Month, Day: Longword; BC: Boolean; Timezone: PXsdTimezone = nil): Utf8String;
 
-function xsdFormatDate(Value: TDateTime; Timezone: PXsdTimezone = nil): Utf8String;
 
-function xsdFormatTime(Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil): Utf8String;
 
-function xsdFormatTime(Value: TDateTime; Timezone: PXsdTimezone = nil): Utf8String;
 
-function xsdFormatDateTime(Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; BC: Boolean; Timezone: PXsdTimezone = nil): Utf8String;
 
-function xsdFormatDateTime(Value: TDateTime; Timezone: PXsdTimezone): Utf8String;
 
-function xsdFormatDecimal(Value: Extended; Precision: Integer = 4; Digits: Integer = 1): Utf8String;
 
-function xsdFormatDouble(Value: Double): Utf8String;
 
-function xsdFormatFloat(Value: Single): Utf8String;
 
-function xsdFormatByte(Value: Shortint): Utf8String;
 
-function xsdFormatShort(Value: Smallint): Utf8String;
 
-function xsdFormatInt(Value: Longint): Utf8String;
 
-function xsdFormatLong(Value: Int64): Utf8String;
 
-function xsdFormatUnsignedByte(Value: Byte): Utf8String;
 
-function xsdFormatUnsignedShort(Value: Word): Utf8String;
 
-function xsdFormatUnsignedInt(Value: Longword): Utf8String;
 
-function xsdFormatUnsignedLong(Value: QWord): Utf8String;
 
-function xsdFormatEnum(enum: array of Utf8String; Value: Integer): Utf8String;
 
+function xsdFormatBase64(Value: TStream): AnsiString;
 
+function xsdFormatBoolean(Value: Boolean; UseWords: Boolean = False): AnsiString;
 
+function xsdFormatDate(Year, Month, Day: Longword; BC: Boolean; Timezone: PXsdTimezone = nil): AnsiString;
 
+function xsdFormatDate(Value: TDateTime; Timezone: PXsdTimezone = nil): AnsiString;
 
+function xsdFormatTime(Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil): AnsiString;
 
+function xsdFormatTime(Value: TDateTime; Timezone: PXsdTimezone = nil): AnsiString;
 
+function xsdFormatDateTime(Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; BC: Boolean; Timezone: PXsdTimezone = nil): AnsiString;
 
+function xsdFormatDateTime(Value: TDateTime; Timezone: PXsdTimezone): AnsiString;
 
+function xsdFormatDecimal(Value: Extended; Precision: Integer = 4; Digits: Integer = 1): AnsiString;
 
+function xsdFormatDouble(Value: Double): AnsiString;
 
+function xsdFormatFloat(Value: Single): AnsiString;
 
+function xsdFormatByte(Value: Shortint): AnsiString;
 
+function xsdFormatShort(Value: Smallint): AnsiString;
 
+function xsdFormatInt(Value: Longint): AnsiString;
 
+function xsdFormatLong(Value: Int64): AnsiString;
 
+function xsdFormatUnsignedByte(Value: Byte): AnsiString;
 
+function xsdFormatUnsignedShort(Value: Word): AnsiString;
 
+function xsdFormatUnsignedInt(Value: Longword): AnsiString;
 
+function xsdFormatUnsignedLong(Value: QWord): AnsiString;
 
+function xsdFormatEnum(enum: array of AnsiString; Value: Integer): AnsiString;
 
 
 { DateTime functions }
 
 function xsdNowUTC: TDateTime;
 
@@ -77,8 +77,8 @@ function xsdDateTimeConvert(const DateTime: TDateTime; const Current, Target: TX
 
 
 { Parse functions }
 
 function xsdTryParseBase64(Chars: PChar; Len: Integer; const Value: TStream): Boolean;
 
-function xsdTryParseString(Chars: PChar; Len: Integer; out Value: Utf8String): Boolean;
 
-function xsdTryParseStringLower(Chars: PChar; Len: Integer; out Value: Utf8String): Boolean;
 
+function xsdTryParseString(Chars: PChar; Len: Integer; out Value: AnsiString): Boolean;
 
+function xsdTryParseStringLower(Chars: PChar; Len: Integer; out Value: AnsiString): Boolean;
 
 function xsdTryParseBoolean(Chars: PChar; Len: Integer; out Value: Boolean): Boolean;
 
 function xsdTryParseDate(Chars: PChar; Len: Integer; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil): Boolean;
 
 function xsdTryParseDate(Chars: PChar; Len: Integer; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
@@ -102,10 +102,10 @@ function xsdTryParseUnsignedByte(Chars: PChar; Len: Integer; out Value: Byte): B
 
 function xsdTryParseUnsignedShort(Chars: PChar; Len: Integer; out Value: Word): Boolean;
 
 function xsdTryParseUnsignedInt(Chars: PChar; Len: Integer; out Value: Longword): Boolean;
 
 function xsdTryParseUnsignedLong(Chars: PChar; Len: Integer; out Value: QWord): Boolean;
 
-function xsdTryParseEnum(Chars: PChar; Len: Integer; enum: array of Utf8String; out Value: Integer): Boolean;
 
+function xsdTryParseEnum(Chars: PChar; Len: Integer; enum: array of AnsiString; out Value: Integer): Boolean;
 
 
-function xsdParseStringDef(Chars: PChar; Len: Integer; Default: Utf8String): Utf8String;
 
-function xsdParseStringLowerDef(Chars: PChar; Len: Integer; Default: Utf8String): Utf8String;
 
+function xsdParseStringDef(Chars: PChar; Len: Integer; Default: AnsiString): AnsiString;
 
+function xsdParseStringLowerDef(Chars: PChar; Len: Integer; Default: AnsiString): AnsiString;
 
 function xsdParseBooleanDef(Chars: PChar; Len: Integer; Default: Boolean): Boolean;
 
 function xsdParseDateDef(Chars: PChar; Len: Integer; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
 function xsdParseTimeDef(Chars: PChar; Len: Integer; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
@@ -126,11 +126,11 @@ function xsdParseUnsignedByteDef(Chars: PChar; Len: Integer; Default: Byte): Byt
 
 function xsdParseUnsignedShortDef(Chars: PChar; Len: Integer; Default: Word): Word;
 
 function xsdParseUnsignedIntDef(Chars: PChar; Len: Integer; Default: Longword): Longword;
 
 function xsdParseUnsignedLongDef(Chars: PChar; Len: Integer; Default: QWord): QWord;
 
-function xsdParseEnumDef(Chars: PChar; Len: Integer; enum: array of Utf8String; Default: Integer): Integer;
 
+function xsdParseEnumDef(Chars: PChar; Len: Integer; enum: array of AnsiString; Default: Integer): Integer;
 
 
 procedure xsdParseBase64(Chars: PChar; Len: Integer; const Value: TStream);
 
-procedure xsdParseString(Chars: PChar; Len: Integer; out Value: Utf8String);
 
-procedure xsdParseStringLower(Chars: PChar; Len: Integer; out Value: Utf8String);
 
+procedure xsdParseString(Chars: PChar; Len: Integer; out Value: AnsiString);
 
+procedure xsdParseStringLower(Chars: PChar; Len: Integer; out Value: AnsiString);
 
 procedure xsdParseBoolean(Chars: PChar; Len: Integer; out Value: Boolean);
 
 procedure xsdParseDate(Chars: PChar; Len: Integer; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil);
 
 procedure xsdParseDate(Chars: PChar; Len: Integer; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
@@ -154,10 +154,10 @@ procedure xsdParseUnsignedByte(Chars: PChar; Len: Integer; out Value: Byte);
 
 procedure xsdParseUnsignedShort(Chars: PChar; Len: Integer; out Value: Word);
 
 procedure xsdParseUnsignedInt(Chars: PChar; Len: Integer; out Value: Longword);
 
 procedure xsdParseUnsignedLong(Chars: PChar; Len: Integer; out Value: QWord);
 
-procedure xsdParseEnum(Chars: PChar; Len: Integer; enum: array of Utf8String; out Value: Integer);
 
+procedure xsdParseEnum(Chars: PChar; Len: Integer; enum: array of AnsiString; out Value: Integer);
 
 
-function xsdParseString(Chars: PChar; Len: Integer): Utf8String;
 
-function xsdParseStringLower(Chars: PChar; Len: Integer): Utf8String;
 
+function xsdParseString(Chars: PChar; Len: Integer): AnsiString;
 
+function xsdParseStringLower(Chars: PChar; Len: Integer): AnsiString;
 
 function xsdParseBoolean(Chars: PChar; Len: Integer): Boolean;
 
 function xsdParseDate(Chars: PChar; Len: Integer; Timezone: PXsdTimezone = nil): TDateTime;
 
 function xsdParseTime(Chars: PChar; Len: Integer; Timezone: PXsdTimezone = nil): TDateTime;
 
@@ -178,111 +178,111 @@ function xsdParseUnsignedByte(Chars: PChar; Len: Integer): Byte;
 
 function xsdParseUnsignedShort(Chars: PChar; Len: Integer): Word;
 
 function xsdParseUnsignedInt(Chars: PChar; Len: Integer): Longword;
 
 function xsdParseUnsignedLong(Chars: PChar; Len: Integer): QWord;
 
-function xsdParseEnum(Chars: PChar; Len: Integer; enum: array of Utf8String): Integer;
 
+function xsdParseEnum(Chars: PChar; Len: Integer; enum: array of AnsiString): Integer;
 
 {
 
-function xsdTryParseBase64(const S: UTF8String; const Value: TStream): Boolean;
 
-function xsdTryParseString(const S: UTF8String; out Value: Utf8String): Boolean;
 
-function xsdTryParseStringLower(const S: UTF8String; out Value: Utf8String): Boolean;
 
-function xsdTryParseBoolean(const S: UTF8String; out Value: Boolean): Boolean;
 
-function xsdTryParseDate(const S: UTF8String; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil): Boolean;
 
-function xsdTryParseDate(const S: UTF8String; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
-function xsdTryParseTime(const S: UTF8String; out Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil): Boolean;
 
-function xsdTryParseTime(const S: UTF8String; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
-function xsdTryParseDateTime(const S: UTF8String; out Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil): Boolean;
 
-function xsdTryParseDateTime(const S: UTF8String; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
-function xsdTryParseDecimal(const S: UTF8String; out Value: Extended): Boolean;
 
-function xsdTryParseDouble(const S: UTF8String; out Value: Double): Boolean;
 
-function xsdTryParseFloat(const S: UTF8String; out Value: Single): Boolean;
 
-function xsdTryParseInteger(const S: UTF8String; out Value: Int64): Boolean;
 
-function xsdTryParseNonNegativeInteger(const S: UTF8String; out Value: QWord): Boolean;
 
-function xsdTryParseNonPositiveInteger(const S: UTF8String; out Value: Int64): Boolean;
 
-function xsdTryParseNegativeInteger(const S: UTF8String; out Value: Int64): Boolean;
 
-function xsdTryParsePositiveInteger(const S: UTF8String; out Value: QWord): Boolean;
 
-function xsdTryParseByte(const S: UTF8String; out Value: Shortint): Boolean;
 
-function xsdTryParseShort(const S: UTF8String; out Value: Smallint): Boolean;
 
-function xsdTryParseInt(const S: UTF8String; out Value: Longint): Boolean;
 
-function xsdTryParseLong(const S: UTF8String; out Value: Int64): Boolean;
 
-function xsdTryParseUnsignedByte(const S: UTF8String; out Value: Byte): Boolean;
 
-function xsdTryParseUnsignedShort(const S: UTF8String; out Value: Word): Boolean;
 
-function xsdTryParseUnsignedInt(const S: UTF8String; out Value: Longword): Boolean;
 
-function xsdTryParseUnsignedLong(const S: UTF8String; out Value: QWord): Boolean;
 
-function xsdTryParseEnum(const S: UTF8String; enum: array of Utf8String; out Value: Integer): Boolean;
 
-
 
-function xsdParseStringDef(const S: UTF8String; Default: Utf8String): Utf8String;
 
-function xsdParseStringLowerDef(const S: UTF8String; Default: Utf8String): Utf8String;
 
-function xsdParseBooleanDef(const S: UTF8String; Default: Boolean): Boolean;
 
-function xsdParseDateDef(const S: UTF8String; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
-function xsdParseTimeDef(const S: UTF8String; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
-function xsdParseDateTimeDef(const S: UTF8String; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
-function xsdParseDecimalDef(const S: UTF8String; Default: Extended): Extended;
 
-function xsdParseDoubleDef(const S: UTF8String; Default: Double): Double;
 
-function xsdParseFloatDef(const S: UTF8String; Default: Single): Single;
 
-function xsdParseIntegerDef(const S: UTF8String; Default: Int64): Int64;
 
-function xsdParseNonNegativeIntegerDef(const S: UTF8String; Default: QWord): QWord;
 
-function xsdParseNonPositiveIntegerDef(const S: UTF8String; Default: Int64): Int64;
 
-function xsdParseNegativeIntegerDef(const S: UTF8String; Default: Int64): Int64;
 
-function xsdParsePositiveIntegerDef(const S: UTF8String; Default: QWord): QWord;
 
-function xsdParseByteDef(const S: UTF8String; Default: Shortint): Shortint;
 
-function xsdParseShortDef(const S: UTF8String; Default: Smallint): Smallint;
 
-function xsdParseIntDef(const S: UTF8String; Default: Longint): Longint;
 
-function xsdParseLongDef(const S: UTF8String; Default: Int64): Int64;
 
-function xsdParseUnsignedByteDef(const S: UTF8String; Default: Byte): Byte;
 
-function xsdParseUnsignedShortDef(const S: UTF8String; Default: Word): Word;
 
-function xsdParseUnsignedIntDef(const S: UTF8String; Default: Longword): Longword;
 
-function xsdParseUnsignedLongDef(const S: UTF8String; Default: QWord): QWord;
 
-function xsdParseEnumDef(const S: UTF8String; enum: array of Utf8String; Default: Integer): Integer;
 
+function xsdTryParseBase64(const S: AnsiString; const Value: TStream): Boolean;
 
+function xsdTryParseString(const S: AnsiString; out Value: AnsiString): Boolean;
 
+function xsdTryParseStringLower(const S: AnsiString; out Value: AnsiString): Boolean;
 
+function xsdTryParseBoolean(const S: AnsiString; out Value: Boolean): Boolean;
 
+function xsdTryParseDate(const S: AnsiString; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil): Boolean;
 
+function xsdTryParseDate(const S: AnsiString; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
+function xsdTryParseTime(const S: AnsiString; out Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil): Boolean;
 
+function xsdTryParseTime(const S: AnsiString; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
+function xsdTryParseDateTime(const S: AnsiString; out Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil): Boolean;
 
+function xsdTryParseDateTime(const S: AnsiString; out Value: TDateTime; Timezone: PXsdTimezone = nil): Boolean;
 
+function xsdTryParseDecimal(const S: AnsiString; out Value: Extended): Boolean;
 
+function xsdTryParseDouble(const S: AnsiString; out Value: Double): Boolean;
 
+function xsdTryParseFloat(const S: AnsiString; out Value: Single): Boolean;
 
+function xsdTryParseInteger(const S: AnsiString; out Value: Int64): Boolean;
 
+function xsdTryParseNonNegativeInteger(const S: AnsiString; out Value: QWord): Boolean;
 
+function xsdTryParseNonPositiveInteger(const S: AnsiString; out Value: Int64): Boolean;
 
+function xsdTryParseNegativeInteger(const S: AnsiString; out Value: Int64): Boolean;
 
+function xsdTryParsePositiveInteger(const S: AnsiString; out Value: QWord): Boolean;
 
+function xsdTryParseByte(const S: AnsiString; out Value: Shortint): Boolean;
 
+function xsdTryParseShort(const S: AnsiString; out Value: Smallint): Boolean;
 
+function xsdTryParseInt(const S: AnsiString; out Value: Longint): Boolean;
 
+function xsdTryParseLong(const S: AnsiString; out Value: Int64): Boolean;
 
+function xsdTryParseUnsignedByte(const S: AnsiString; out Value: Byte): Boolean;
 
+function xsdTryParseUnsignedShort(const S: AnsiString; out Value: Word): Boolean;
 
+function xsdTryParseUnsignedInt(const S: AnsiString; out Value: Longword): Boolean;
 
+function xsdTryParseUnsignedLong(const S: AnsiString; out Value: QWord): Boolean;
 
+function xsdTryParseEnum(const S: AnsiString; enum: array of AnsiString; out Value: Integer): Boolean;
 
+
 
+function xsdParseStringDef(const S: AnsiString; Default: AnsiString): AnsiString;
 
+function xsdParseStringLowerDef(const S: AnsiString; Default: AnsiString): AnsiString;
 
+function xsdParseBooleanDef(const S: AnsiString; Default: Boolean): Boolean;
 
+function xsdParseDateDef(const S: AnsiString; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
+function xsdParseTimeDef(const S: AnsiString; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
+function xsdParseDateTimeDef(const S: AnsiString; Default: TDateTime; Timezone: PXsdTimezone = nil): TDateTime;
 
+function xsdParseDecimalDef(const S: AnsiString; Default: Extended): Extended;
 
+function xsdParseDoubleDef(const S: AnsiString; Default: Double): Double;
 
+function xsdParseFloatDef(const S: AnsiString; Default: Single): Single;
 
+function xsdParseIntegerDef(const S: AnsiString; Default: Int64): Int64;
 
+function xsdParseNonNegativeIntegerDef(const S: AnsiString; Default: QWord): QWord;
 
+function xsdParseNonPositiveIntegerDef(const S: AnsiString; Default: Int64): Int64;
 
+function xsdParseNegativeIntegerDef(const S: AnsiString; Default: Int64): Int64;
 
+function xsdParsePositiveIntegerDef(const S: AnsiString; Default: QWord): QWord;
 
+function xsdParseByteDef(const S: AnsiString; Default: Shortint): Shortint;
 
+function xsdParseShortDef(const S: AnsiString; Default: Smallint): Smallint;
 
+function xsdParseIntDef(const S: AnsiString; Default: Longint): Longint;
 
+function xsdParseLongDef(const S: AnsiString; Default: Int64): Int64;
 
+function xsdParseUnsignedByteDef(const S: AnsiString; Default: Byte): Byte;
 
+function xsdParseUnsignedShortDef(const S: AnsiString; Default: Word): Word;
 
+function xsdParseUnsignedIntDef(const S: AnsiString; Default: Longword): Longword;
 
+function xsdParseUnsignedLongDef(const S: AnsiString; Default: QWord): QWord;
 
+function xsdParseEnumDef(const S: AnsiString; enum: array of AnsiString; Default: Integer): Integer;
 
 }
 
-procedure xsdParseBase64(const S: UTF8String; const Value: TStream);
 
-procedure xsdParseString(const S: UTF8String; out Value: Utf8String);
 
-procedure xsdParseStringLower(const S: UTF8String; out Value: Utf8String);
 
-procedure xsdParseBoolean(const S: UTF8String; out Value: Boolean);
 
-procedure xsdParseDate(const S: UTF8String; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil);
 
-procedure xsdParseDate(const S: UTF8String; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
-procedure xsdParseTime(const S: UTF8String; out Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil);
 
-procedure xsdParseTime(const S: UTF8String; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
-procedure xsdParseDateTime(const S: UTF8String; out Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil);
 
-procedure xsdParseDateTime(const S: UTF8String; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
-procedure xsdParseDecimal(const S: UTF8String; out Value: Extended);
 
-procedure xsdParseDouble(const S: UTF8String; out Value: Double);
 
-procedure xsdParseFloat(const S: UTF8String; out Value: Single);
 
-procedure xsdParseInteger(const S: UTF8String; out Value: Int64);
 
-procedure xsdParseNonNegativeInteger(const S: UTF8String; out Value: QWord);
 
-procedure xsdParseNonPositiveInteger(const S: UTF8String; out Value: Int64);
 
-procedure xsdParseNegativeInteger(const S: UTF8String; out Value: Int64);
 
-procedure xsdParsePositiveInteger(const S: UTF8String; out Value: QWord);
 
-procedure xsdParseByte(const S: UTF8String; out Value: Shortint);
 
-procedure xsdParseShort(const S: UTF8String; out Value: Smallint);
 
-procedure xsdParseInt(const S: UTF8String; out Value: Longint);
 
-procedure xsdParseLong(const S: UTF8String; out Value: Int64);
 
-procedure xsdParseUnsignedByte(const S: UTF8String; out Value: Byte);
 
-procedure xsdParseUnsignedShort(const S: UTF8String; out Value: Word);
 
-procedure xsdParseUnsignedInt(const S: UTF8String; out Value: Longword);
 
-procedure xsdParseUnsignedLong(const S: UTF8String; out Value: QWord);
 
-procedure xsdParseEnum(const S: UTF8String; enum: array of Utf8String; out Value: Integer);
 
-
 
-function xsdParseString(const S: UTF8String): Utf8String;
 
-function xsdParseStringLower(const S: UTF8String): Utf8String;
 
-function xsdParseBoolean(const S: UTF8String): Boolean;
 
-function xsdParseDate(const S: UTF8String; Timezone: PXsdTimezone = nil): TDateTime;
 
-function xsdParseTime(const S: UTF8String; Timezone: PXsdTimezone = nil): TDateTime;
 
-function xsdParseDateTime(const S: UTF8String; Timezone: PXsdTimezone = nil): TDateTime;
 
-function xsdParseDecimal(const S: UTF8String): Extended;
 
-function xsdParseDouble(const S: UTF8String): Double;
 
-function xsdParseFloat(const S: UTF8String): Single;
 
-function xsdParseInteger(const S: UTF8String): Int64;
 
-function xsdParseNonNegativeInteger(const S: UTF8String): QWord;
 
-function xsdParseNonPositiveInteger(const S: UTF8String): Int64;
 
-function xsdParseNegativeInteger(const S: UTF8String): Int64;
 
-function xsdParsePositiveInteger(const S: UTF8String): QWord;
 
-function xsdParseByte(const S: UTF8String): Shortint;
 
-function xsdParseShort(const S: UTF8String): Smallint;
 
-function xsdParseInt(const S: UTF8String): Longint;
 
-function xsdParseLong(const S: UTF8String): Int64;
 
-function xsdParseUnsignedByte(const S: UTF8String): Byte;
 
-function xsdParseUnsignedShort(const S: UTF8String): Word;
 
-function xsdParseUnsignedInt(const S: UTF8String): Longword;
 
-function xsdParseUnsignedLong(const S: UTF8String): QWord;
 
-function xsdParseEnum(const S: UTF8String; enum: array of Utf8String): Integer;
 
+procedure xsdParseBase64(const S: AnsiString; const Value: TStream);
 
+procedure xsdParseString(const S: AnsiString; out Value: AnsiString);
 
+procedure xsdParseStringLower(const S: AnsiString; out Value: AnsiString);
 
+procedure xsdParseBoolean(const S: AnsiString; out Value: Boolean);
 
+procedure xsdParseDate(const S: AnsiString; out Year, Month, Day: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil);
 
+procedure xsdParseDate(const S: AnsiString; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
+procedure xsdParseTime(const S: AnsiString; out Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil);
 
+procedure xsdParseTime(const S: AnsiString; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
+procedure xsdParseDateTime(const S: AnsiString; out Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone = nil; BC: PBoolean = nil);
 
+procedure xsdParseDateTime(const S: AnsiString; out Value: TDateTime; Timezone: PXsdTimezone = nil);
 
+procedure xsdParseDecimal(const S: AnsiString; out Value: Extended);
 
+procedure xsdParseDouble(const S: AnsiString; out Value: Double);
 
+procedure xsdParseFloat(const S: AnsiString; out Value: Single);
 
+procedure xsdParseInteger(const S: AnsiString; out Value: Int64);
 
+procedure xsdParseNonNegativeInteger(const S: AnsiString; out Value: QWord);
 
+procedure xsdParseNonPositiveInteger(const S: AnsiString; out Value: Int64);
 
+procedure xsdParseNegativeInteger(const S: AnsiString; out Value: Int64);
 
+procedure xsdParsePositiveInteger(const S: AnsiString; out Value: QWord);
 
+procedure xsdParseByte(const S: AnsiString; out Value: Shortint);
 
+procedure xsdParseShort(const S: AnsiString; out Value: Smallint);
 
+procedure xsdParseInt(const S: AnsiString; out Value: Longint);
 
+procedure xsdParseLong(const S: AnsiString; out Value: Int64);
 
+procedure xsdParseUnsignedByte(const S: AnsiString; out Value: Byte);
 
+procedure xsdParseUnsignedShort(const S: AnsiString; out Value: Word);
 
+procedure xsdParseUnsignedInt(const S: AnsiString; out Value: Longword);
 
+procedure xsdParseUnsignedLong(const S: AnsiString; out Value: QWord);
 
+procedure xsdParseEnum(const S: AnsiString; enum: array of AnsiString; out Value: Integer);
 
+
 
+function xsdParseString(const S: AnsiString): AnsiString;
 
+function xsdParseStringLower(const S: AnsiString): AnsiString;
 
+function xsdParseBoolean(const S: AnsiString): Boolean;
 
+function xsdParseDate(const S: AnsiString; Timezone: PXsdTimezone = nil): TDateTime;
 
+function xsdParseTime(const S: AnsiString; Timezone: PXsdTimezone = nil): TDateTime;
 
+function xsdParseDateTime(const S: AnsiString; Timezone: PXsdTimezone = nil): TDateTime;
 
+function xsdParseDecimal(const S: AnsiString): Extended;
 
+function xsdParseDouble(const S: AnsiString): Double;
 
+function xsdParseFloat(const S: AnsiString): Single;
 
+function xsdParseInteger(const S: AnsiString): Int64;
 
+function xsdParseNonNegativeInteger(const S: AnsiString): QWord;
 
+function xsdParseNonPositiveInteger(const S: AnsiString): Int64;
 
+function xsdParseNegativeInteger(const S: AnsiString): Int64;
 
+function xsdParsePositiveInteger(const S: AnsiString): QWord;
 
+function xsdParseByte(const S: AnsiString): Shortint;
 
+function xsdParseShort(const S: AnsiString): Smallint;
 
+function xsdParseInt(const S: AnsiString): Longint;
 
+function xsdParseLong(const S: AnsiString): Int64;
 
+function xsdParseUnsignedByte(const S: AnsiString): Byte;
 
+function xsdParseUnsignedShort(const S: AnsiString): Word;
 
+function xsdParseUnsignedInt(const S: AnsiString): Longword;
 
+function xsdParseUnsignedLong(const S: AnsiString): QWord;
 
+function xsdParseEnum(const S: AnsiString; enum: array of AnsiString): Integer;
 
 
 
 { INTERNAL HELPERS!!! }
 
@@ -296,11 +296,11 @@ function __parseTimezone(var P: PChar; const L: PChar; out T: TXsdTimezone): Boo
 
 function __parseDate(var P: PChar; const L: PChar; out Year, Month, Day: Longword; BC: PBoolean): Boolean;
 
 function __parseTime(var P: PChar; const L: PChar; const AllowMoreThan24h: Boolean;
 
   out Hour, Minute, Second, Milliseconds: Longword): Boolean;
 
-function __strpas(Chars: PChar; Len: Integer): Utf8String;
 
+function __strpas(Chars: PChar; Len: Integer): AnsiString;
 
 
 implementation
 
 
-function xsdFormatBase64(Value: TStream): Utf8String;
 
+function xsdFormatBase64(Value: TStream): AnsiString;
 
 const
 
   Base64: array[0..63] of char = (
 
     'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
 
@@ -366,7 +366,7 @@ begin
 
   end;
 
 end;
 
 
-function xsdFormatBoolean(Value: Boolean; UseWords: Boolean): Utf8String;
 
+function xsdFormatBoolean(Value: Boolean; UseWords: Boolean): AnsiString;
 
 begin
 
   if UseWords then
 
     if Value then
 
@@ -380,7 +380,7 @@ begin
 
       Result := '0';
 
 end;
 
 
-function xsdFormatDate(Year, Month, Day: Longword; BC: Boolean; Timezone: PXsdTimezone): Utf8String;
 
+function xsdFormatDate(Year, Month, Day: Longword; BC: Boolean; Timezone: PXsdTimezone): AnsiString;
 
 begin
 
   Result := Format('%4.4d-%2.2u-%2.2u', [Year, Month, Day]);
 
   if BC then
 
@@ -401,7 +401,7 @@ begin
 
     end;
 
 end;
 
 
-function xsdFormatDate(Value: TDateTime; Timezone: PXsdTimezone): Utf8String;
 
+function xsdFormatDate(Value: TDateTime; Timezone: PXsdTimezone): AnsiString;
 
 var
 
   Year, Month, Day: Word;
 
 begin
 
@@ -409,7 +409,7 @@ begin
 
   Result := xsdFormatDate(Year, Month, Day, False, Timezone);
 
 end;
 
 
-function xsdFormatTime(Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone): Utf8String;
 
+function xsdFormatTime(Hour, Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone): AnsiString;
 
 begin
 
   Result := Format('%2.2u:%2.2u:%2.2u', [Hour, Minute, Second]);
 
   if Milliseconds > 0 then
 
@@ -430,7 +430,7 @@ begin
 
     end;
 
 end;
 
 
-function xsdFormatTime(Value: TDateTime; Timezone: PXsdTimezone): Utf8String;
 
+function xsdFormatTime(Value: TDateTime; Timezone: PXsdTimezone): AnsiString;
 
 var
 
   Hour, Minute, Second, Milliseconds: Word;
 
 begin
 
@@ -438,12 +438,12 @@ begin
 
   Result := xsdFormatTime(Hour, Minute, Second, Milliseconds, Timezone);
 
 end;
 
 
-function xsdFormatDateTime(Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; BC: Boolean; Timezone: PXsdTimezone): Utf8String;
 
+function xsdFormatDateTime(Year, Month, Day, Hour, Minute, Second, Milliseconds: Longword; BC: Boolean; Timezone: PXsdTimezone): AnsiString;
 
 begin
 
   Result := xsdFormatDate(Year, Month, Day, BC, nil) + 'T' + xsdFormatTime(Hour, Minute, Second, Milliseconds, Timezone);
 
 end;
 
 
-function xsdFormatDateTime(Value: TDateTime; Timezone: PXsdTimezone): Utf8String;
 
+function xsdFormatDateTime(Value: TDateTime; Timezone: PXsdTimezone): AnsiString;
 
 var
 
   Year, Month, Day, Hour, Minute, Second, Milliseconds: Word;
 
 begin
 
@@ -451,62 +451,62 @@ begin
 
   Result := xsdFormatDateTime(Year, Month, Day, Hour, Minute, Second, Milliseconds, False, Timezone);
 
 end;
 
 
-function xsdFormatDecimal(Value: Extended; Precision: Integer; Digits: Integer): Utf8String;
 
+function xsdFormatDecimal(Value: Extended; Precision: Integer; Digits: Integer): AnsiString;
 
 begin
 
   Result := FloatToStrF(Value, ffFixed, Precision, Digits);
 
 end;
 
 
-function xsdFormatDouble(Value: Double): Utf8String;
 
+function xsdFormatDouble(Value: Double): AnsiString;
 
 begin
 
   Result := FloatToStr(Value);
 
 end;
 
 
-function xsdFormatFloat(Value: Single): Utf8String;
 
+function xsdFormatFloat(Value: Single): AnsiString;
 
 begin
 
   Result := FloatToStr(Value);
 
 end;
 
 
-function xsdFormatByte(Value: Shortint): Utf8String;
 
+function xsdFormatByte(Value: Shortint): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatShort(Value: Smallint): Utf8String;
 
+function xsdFormatShort(Value: Smallint): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatInt(Value: Integer): Utf8String;
 
+function xsdFormatInt(Value: Integer): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatLong(Value: Int64): Utf8String;
 
+function xsdFormatLong(Value: Int64): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatUnsignedByte(Value: Byte): Utf8String;
 
+function xsdFormatUnsignedByte(Value: Byte): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatUnsignedShort(Value: Word): Utf8String;
 
+function xsdFormatUnsignedShort(Value: Word): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatUnsignedInt(Value: Longword): Utf8String;
 
+function xsdFormatUnsignedInt(Value: Longword): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatUnsignedLong(Value: QWord): Utf8String;
 
+function xsdFormatUnsignedLong(Value: QWord): AnsiString;
 
 begin
 
   Result := IntToStr(Value);
 
 end;
 
 
-function xsdFormatEnum(enum: array of Utf8String; Value: Integer): Utf8String;
 
+function xsdFormatEnum(enum: array of AnsiString; Value: Integer): AnsiString;
 
 begin
 
   Result := enum[Value];
 
 end;
 
@@ -1046,7 +1046,7 @@ begin
 
     Result := False;
 
 end;
 
 
-function xsdTryParseString(Chars: PChar; Len: Integer; out Value: Utf8String): Boolean;
 
+function xsdTryParseString(Chars: PChar; Len: Integer; out Value: AnsiString): Boolean;
 
 const
 
   AllocChars = 256;
 
 var
 
@@ -1103,7 +1103,7 @@ end;
 
     Result := False;
 
 end;}
 
 
-function xsdTryParseStringLower(Chars: PChar; Len: Integer; out Value: Utf8String): Boolean;
 
+function xsdTryParseStringLower(Chars: PChar; Len: Integer; out Value: AnsiString): Boolean;
 
 const
 
   AllocChars = 256;
 
 var
 
@@ -1152,7 +1152,7 @@ begin
 
     Result := False;
 
 end;
 
 
-function __strpas(Chars: PChar; Len: Integer): Utf8String;
 
+function __strpas(Chars: PChar; Len: Integer): AnsiString;
 
 begin
 
   if not xsdTryParseString(Chars, Len, Result) then
 
     Result := '';
 
@@ -1459,9 +1459,9 @@ begin
 
   Result := xsdTryParseNonNegativeInteger(Chars, Len, Value)
 
 end;
 
 
-function xsdTryParseEnum(Chars: PChar; Len: Integer; enum: array of Utf8String; out Value: Integer): Boolean;
 
+function xsdTryParseEnum(Chars: PChar; Len: Integer; enum: array of AnsiString; out Value: Integer): Boolean;
 
 var
 
-  Temp: Utf8String;
 
+  Temp: AnsiString;
 
   I: Integer;
 
 begin
 
   Temp := '';
 
@@ -1478,13 +1478,13 @@ begin
 
   end;
 
 end;
 
 
-function xsdParseStringDef(Chars: PChar; Len: Integer; Default: Utf8String): Utf8String;
 
+function xsdParseStringDef(Chars: PChar; Len: Integer; Default: AnsiString): AnsiString;
 
 begin
 
   if not xsdTryParseString(Chars, Len, Result) then
 
     Result := Default;
 
 end;
 
 
-function xsdParseStringLowerDef(Chars: PChar; Len: Integer; Default: Utf8String): Utf8String;
 
+function xsdParseStringLowerDef(Chars: PChar; Len: Integer; Default: AnsiString): AnsiString;
 
 begin
 
   if not xsdTryParseStringLower(Chars, Len, Result) then
 
     Result := Default;
 
@@ -1610,7 +1610,7 @@ begin
 
     Result := Default;
 
 end;
 
 
-function xsdParseEnumDef(Chars: PChar; Len: Integer; enum: array of Utf8String; Default: Integer): Integer;
 
+function xsdParseEnumDef(Chars: PChar; Len: Integer; enum: array of AnsiString; Default: Integer): Integer;
 
 begin
 
   if not xsdTryParseEnum(Chars, Len, enum, Result) then
 
     Result := Default;
 
@@ -1622,13 +1622,13 @@ begin
 
     raise EConvertError.CreateFmt(SXsdParserError, [__strpas(Chars,Len), 'xs:base64Binary']);
 
 end;
 
 
-procedure xsdParseString(Chars: PChar; Len: Integer; out Value: Utf8String);
 
+procedure xsdParseString(Chars: PChar; Len: Integer; out Value: AnsiString);
 
 begin
 
   if not xsdTryParseString(Chars, Len, Value) then
 
     raise EConvertError.CreateFmt(SXsdParserError, [__strpas(Chars,Len), 'xs:string']);
 
 end;
 
 
-procedure xsdParseStringLower(Chars: PChar; Len: Integer; out Value: Utf8String);
 
+procedure xsdParseStringLower(Chars: PChar; Len: Integer; out Value: AnsiString);
 
 begin
 
   if not xsdTryParseStringLower(Chars, Len, Value) then
 
     raise EConvertError.CreateFmt(SXsdParserError, [__strpas(Chars,Len), 'xs:string']);
 
@@ -1772,18 +1772,18 @@ begin
 
     raise EConvertError.CreateFmt(SXsdParserError, [__strpas(Chars,Len), 'xs:unsignedLong']);
 
 end;
 
 
-procedure xsdParseEnum(Chars: PChar; Len: Integer; enum: array of Utf8String; out Value: Integer);
 
+procedure xsdParseEnum(Chars: PChar; Len: Integer; enum: array of AnsiString; out Value: Integer);
 
 begin
 
   if not xsdTryParseEnum(Chars, Len, enum, Value) then
 
     raise EConvertError.CreateFmt(SXsdParserError, [__strpas(Chars,Len), 'xs:enum']);
 
 end;
 
 
-function xsdParseString(Chars: PChar; Len: Integer): Utf8String;
 
+function xsdParseString(Chars: PChar; Len: Integer): AnsiString;
 
 begin
 
   xsdParseString(Chars, Len, Result);
 
 end;
 
 
-function xsdParseStringLower(Chars: PChar; Len: Integer): Utf8String;
 
+function xsdParseStringLower(Chars: PChar; Len: Integer): AnsiString;
 
 begin
 
   xsdParseStringLower(Chars, Len, Result);
 
 end;
 
@@ -1888,540 +1888,540 @@ begin
 
   xsdParseUnsignedLong(Chars, Len, Result);
 
 end;
 
 
-function xsdParseEnum(Chars: PChar; Len: Integer; enum: array of Utf8String): Integer;
 
+function xsdParseEnum(Chars: PChar; Len: Integer; enum: array of AnsiString): Integer;
 
 begin
 
   xsdParseEnum(Chars, Len, enum, Result);
 
 end;
 
 (*
 
-function xsdTryParseBase64(const S: UTF8String; const Value: TStream): Boolean;
 
+function xsdTryParseBase64(const S: AnsiString; const Value: TStream): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseString(const S: UTF8String; out Value: Utf8String): Boolean;
 
+function xsdTryParseString(const S: AnsiString; out Value: AnsiString): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseStringLower(const S: UTF8String; out Value: Utf8String
 
+function xsdTryParseStringLower(const S: AnsiString; out Value: AnsiString
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseBoolean(const S: UTF8String; out Value: Boolean): Boolean;
 
+function xsdTryParseBoolean(const S: AnsiString; out Value: Boolean): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseDate(const S: UTF8String; out Year, Month, Day: Longword;
 
+function xsdTryParseDate(const S: AnsiString; out Year, Month, Day: Longword;
 
   Timezone: PXsdTimezone; BC: PBoolean): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseDate(const S: UTF8String; out Value: TDateTime;
 
+function xsdTryParseDate(const S: AnsiString; out Value: TDateTime;
 
   Timezone: PXsdTimezone): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseTime(const S: UTF8String; out Hour, Minute, Second,
 
+function xsdTryParseTime(const S: AnsiString; out Hour, Minute, Second,
 
   Milliseconds: Longword; Timezone: PXsdTimezone): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseTime(const S: UTF8String; out Value: TDateTime;
 
+function xsdTryParseTime(const S: AnsiString; out Value: TDateTime;
 
   Timezone: PXsdTimezone): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseDateTime(const S: UTF8String; out Year, Month, Day, Hour,
 
+function xsdTryParseDateTime(const S: AnsiString; out Year, Month, Day, Hour,
 
   Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone; BC: PBoolean
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseDateTime(const S: UTF8String; out Value: TDateTime;
 
+function xsdTryParseDateTime(const S: AnsiString; out Value: TDateTime;
 
   Timezone: PXsdTimezone): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseDecimal(const S: UTF8String; out Value: Extended): Boolean;
 
+function xsdTryParseDecimal(const S: AnsiString; out Value: Extended): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseDouble(const S: UTF8String; out Value: Double): Boolean;
 
+function xsdTryParseDouble(const S: AnsiString; out Value: Double): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseFloat(const S: UTF8String; out Value: Single): Boolean;
 
+function xsdTryParseFloat(const S: AnsiString; out Value: Single): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseInteger(const S: UTF8String; out Value: Int64): Boolean;
 
+function xsdTryParseInteger(const S: AnsiString; out Value: Int64): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseNonNegativeInteger(const S: UTF8String; out Value: QWord
 
+function xsdTryParseNonNegativeInteger(const S: AnsiString; out Value: QWord
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseNonPositiveInteger(const S: UTF8String; out Value: Int64
 
+function xsdTryParseNonPositiveInteger(const S: AnsiString; out Value: Int64
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseNegativeInteger(const S: UTF8String; out Value: Int64
 
+function xsdTryParseNegativeInteger(const S: AnsiString; out Value: Int64
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParsePositiveInteger(const S: UTF8String; out Value: QWord
 
+function xsdTryParsePositiveInteger(const S: AnsiString; out Value: QWord
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseByte(const S: UTF8String; out Value: Shortint): Boolean;
 
+function xsdTryParseByte(const S: AnsiString; out Value: Shortint): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseShort(const S: UTF8String; out Value: Smallint): Boolean;
 
+function xsdTryParseShort(const S: AnsiString; out Value: Smallint): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseInt(const S: UTF8String; out Value: Longint): Boolean;
 
+function xsdTryParseInt(const S: AnsiString; out Value: Longint): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseLong(const S: UTF8String; out Value: Int64): Boolean;
 
+function xsdTryParseLong(const S: AnsiString; out Value: Int64): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseUnsignedByte(const S: UTF8String; out Value: Byte): Boolean;
 
+function xsdTryParseUnsignedByte(const S: AnsiString; out Value: Byte): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseUnsignedShort(const S: UTF8String; out Value: Word
 
+function xsdTryParseUnsignedShort(const S: AnsiString; out Value: Word
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseUnsignedInt(const S: UTF8String; out Value: Longword
 
+function xsdTryParseUnsignedInt(const S: AnsiString; out Value: Longword
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseUnsignedLong(const S: UTF8String; out Value: QWord
 
+function xsdTryParseUnsignedLong(const S: AnsiString; out Value: QWord
 
   ): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdTryParseEnum(const S: UTF8String; enum: array of Utf8String;
 
+function xsdTryParseEnum(const S: AnsiString; enum: array of AnsiString;
 
   out Value: Integer): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdParseStringDef(const S: UTF8String; Default: Utf8String
 
-  ): Utf8String;
 
+function xsdParseStringDef(const S: AnsiString; Default: AnsiString
 
+  ): AnsiString;
 
 begin
 
 
 end;
 
 
-function xsdParseStringLowerDef(const S: UTF8String; Default: Utf8String
 
-  ): Utf8String;
 
+function xsdParseStringLowerDef(const S: AnsiString; Default: AnsiString
 
+  ): AnsiString;
 
 begin
 
 
 end;
 
 
-function xsdParseBooleanDef(const S: UTF8String; Default: Boolean): Boolean;
 
+function xsdParseBooleanDef(const S: AnsiString; Default: Boolean): Boolean;
 
 begin
 
 
 end;
 
 
-function xsdParseDateDef(const S: UTF8String; Default: TDateTime;
 
+function xsdParseDateDef(const S: AnsiString; Default: TDateTime;
 
   Timezone: PXsdTimezone): TDateTime;
 
 begin
 
 
 end;
 
 
-function xsdParseTimeDef(const S: UTF8String; Default: TDateTime;
 
+function xsdParseTimeDef(const S: AnsiString; Default: TDateTime;
 
   Timezone: PXsdTimezone): TDateTime;
 
 begin
 
 
 end;
 
 
-function xsdParseDateTimeDef(const S: UTF8String; Default: TDateTime;
 
+function xsdParseDateTimeDef(const S: AnsiString; Default: TDateTime;
 
   Timezone: PXsdTimezone): TDateTime;
 
 begin
 
 
 end;
 
 
-function xsdParseDecimalDef(const S: UTF8String; Default: Extended): Extended;
 
+function xsdParseDecimalDef(const S: AnsiString; Default: Extended): Extended;
 
 begin
 
 
 end;
 
 
-function xsdParseDoubleDef(const S: UTF8String; Default: Double): Double;
 
+function xsdParseDoubleDef(const S: AnsiString; Default: Double): Double;
 
 begin
 
 
 end;
 
 
-function xsdParseFloatDef(const S: UTF8String; Default: Single): Single;
 
+function xsdParseFloatDef(const S: AnsiString; Default: Single): Single;
 
 begin
 
 
 end;
 
 
-function xsdParseIntegerDef(const S: UTF8String; Default: Int64): Int64;
 
+function xsdParseIntegerDef(const S: AnsiString; Default: Int64): Int64;
 
 begin
 
 
 end;
 
 
-function xsdParseNonNegativeIntegerDef(const S: UTF8String; Default: QWord
 
+function xsdParseNonNegativeIntegerDef(const S: AnsiString; Default: QWord
 
   ): QWord;
 
 begin
 
 
 end;
 
 
-function xsdParseNonPositiveIntegerDef(const S: UTF8String; Default: Int64
 
+function xsdParseNonPositiveIntegerDef(const S: AnsiString; Default: Int64
 
   ): Int64;
 
 begin
 
 
 end;
 
 
-function xsdParseNegativeIntegerDef(const S: UTF8String; Default: Int64): Int64;
 
+function xsdParseNegativeIntegerDef(const S: AnsiString; Default: Int64): Int64;
 
 begin
 
 
 end;
 
 
-function xsdParsePositiveIntegerDef(const S: UTF8String; Default: QWord): QWord;
 
+function xsdParsePositiveIntegerDef(const S: AnsiString; Default: QWord): QWord;
 
 begin
 
 
 end;
 
 
-function xsdParseByteDef(const S: UTF8String; Default: Shortint): Shortint;
 
+function xsdParseByteDef(const S: AnsiString; Default: Shortint): Shortint;
 
 begin
 
 
 end;
 
 
-function xsdParseShortDef(const S: UTF8String; Default: Smallint): Smallint;
 
+function xsdParseShortDef(const S: AnsiString; Default: Smallint): Smallint;
 
 begin
 
 
 end;
 
 
-function xsdParseIntDef(const S: UTF8String; Default: Longint): Longint;
 
+function xsdParseIntDef(const S: AnsiString; Default: Longint): Longint;
 
 begin
 
 
 end;
 
 
-function xsdParseLongDef(const S: UTF8String; Default: Int64): Int64;
 
+function xsdParseLongDef(const S: AnsiString; Default: Int64): Int64;
 
 begin
 
 
 end;
 
 
-function xsdParseUnsignedByteDef(const S: UTF8String; Default: Byte): Byte;
 
+function xsdParseUnsignedByteDef(const S: AnsiString; Default: Byte): Byte;
 
 begin
 
 
 end;
 
 
-function xsdParseUnsignedShortDef(const S: UTF8String; Default: Word): Word;
 
+function xsdParseUnsignedShortDef(const S: AnsiString; Default: Word): Word;
 
 begin
 
 
 end;
 
 
-function xsdParseUnsignedIntDef(const S: UTF8String; Default: Longword
 
+function xsdParseUnsignedIntDef(const S: AnsiString; Default: Longword
 
   ): Longword;
 
 begin
 
 
 end;
 
 
-function xsdParseUnsignedLongDef(const S: UTF8String; Default: QWord): QWord;
 
+function xsdParseUnsignedLongDef(const S: AnsiString; Default: QWord): QWord;
 
 begin
 
 
 end;
 
 
-function xsdParseEnumDef(const S: UTF8String; enum: array of Utf8String;
 
+function xsdParseEnumDef(const S: AnsiString; enum: array of AnsiString;
 
   Default: Integer): Integer;
 
 begin
 
 
 end;*)
 
 
-procedure xsdParseBase64(const S: UTF8String; const Value: TStream);
 
+procedure xsdParseBase64(const S: AnsiString; const Value: TStream);
 
 begin
 
   xsdParseBase64(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseString(const S: UTF8String; out Value: Utf8String);
 
+procedure xsdParseString(const S: AnsiString; out Value: AnsiString);
 
 begin
 
   xsdParseString(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseStringLower(const S: UTF8String; out Value: Utf8String);
 
+procedure xsdParseStringLower(const S: AnsiString; out Value: AnsiString);
 
 begin
 
   xsdParseStringLower(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseBoolean(const S: UTF8String; out Value: Boolean);
 
+procedure xsdParseBoolean(const S: AnsiString; out Value: Boolean);
 
 begin
 
   xsdParseBoolean(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseDate(const S: UTF8String; out Year, Month, Day: Longword;
 
+procedure xsdParseDate(const S: AnsiString; out Year, Month, Day: Longword;
 
   Timezone: PXsdTimezone; BC: PBoolean);
 
 begin
 
   xsdParseDate(PChar(S), Length(S), Year, Month, Day, Timezone, BC);
 
 end;
 
 
-procedure xsdParseDate(const S: UTF8String; out Value: TDateTime;
 
+procedure xsdParseDate(const S: AnsiString; out Value: TDateTime;
 
   Timezone: PXsdTimezone);
 
 begin
 
   xsdParseDate(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseTime(const S: UTF8String; out Hour, Minute, Second,
 
+procedure xsdParseTime(const S: AnsiString; out Hour, Minute, Second,
 
   Milliseconds: Longword; Timezone: PXsdTimezone);
 
 begin
 
   xsdParseTime(PChar(S), Length(S), Hour, Minute, Second,
 
     Milliseconds, Timezone);
 
 end;
 
 
-procedure xsdParseTime(const S: UTF8String; out Value: TDateTime;
 
+procedure xsdParseTime(const S: AnsiString; out Value: TDateTime;
 
   Timezone: PXsdTimezone);
 
 begin
 
   xsdParseTime(PChar(S), Length(S), Value, Timezone);
 
 end;
 
 
-procedure xsdParseDateTime(const S: UTF8String; out Year, Month, Day, Hour,
 
+procedure xsdParseDateTime(const S: AnsiString; out Year, Month, Day, Hour,
 
   Minute, Second, Milliseconds: Longword; Timezone: PXsdTimezone; BC: PBoolean);
 
 begin
 
   xsdParseDateTime(PChar(S), Length(S), Year, Month, Day, Hour,
 
     Minute, Second, Milliseconds, Timezone, BC);
 
 end;
 
 
-procedure xsdParseDateTime(const S: UTF8String; out Value: TDateTime;
 
+procedure xsdParseDateTime(const S: AnsiString; out Value: TDateTime;
 
   Timezone: PXsdTimezone);
 
 begin
 
   xsdParseDateTime(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseDecimal(const S: UTF8String; out Value: Extended);
 
+procedure xsdParseDecimal(const S: AnsiString; out Value: Extended);
 
 begin
 
   xsdParseDecimal(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseDouble(const S: UTF8String; out Value: Double);
 
+procedure xsdParseDouble(const S: AnsiString; out Value: Double);
 
 begin
 
   xsdParseDouble(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseFloat(const S: UTF8String; out Value: Single);
 
+procedure xsdParseFloat(const S: AnsiString; out Value: Single);
 
 begin
 
   xsdParseFloat(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseInteger(const S: UTF8String; out Value: Int64);
 
+procedure xsdParseInteger(const S: AnsiString; out Value: Int64);
 
 begin
 
   xsdParseInteger(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseNonNegativeInteger(const S: UTF8String; out Value: QWord);
 
+procedure xsdParseNonNegativeInteger(const S: AnsiString; out Value: QWord);
 
 begin
 
   xsdParseNonNegativeInteger(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseNonPositiveInteger(const S: UTF8String; out Value: Int64);
 
+procedure xsdParseNonPositiveInteger(const S: AnsiString; out Value: Int64);
 
 begin
 
   xsdParseNonPositiveInteger(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseNegativeInteger(const S: UTF8String; out Value: Int64);
 
+procedure xsdParseNegativeInteger(const S: AnsiString; out Value: Int64);
 
 begin
 
   xsdParseNegativeInteger(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParsePositiveInteger(const S: UTF8String; out Value: QWord);
 
+procedure xsdParsePositiveInteger(const S: AnsiString; out Value: QWord);
 
 begin
 
   xsdParsePositiveInteger(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseByte(const S: UTF8String; out Value: Shortint);
 
+procedure xsdParseByte(const S: AnsiString; out Value: Shortint);
 
 begin
 
   xsdParseByte(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseShort(const S: UTF8String; out Value: Smallint);
 
+procedure xsdParseShort(const S: AnsiString; out Value: Smallint);
 
 begin
 
   xsdParseShort(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseInt(const S: UTF8String; out Value: Longint);
 
+procedure xsdParseInt(const S: AnsiString; out Value: Longint);
 
 begin
 
   xsdParseInt(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseLong(const S: UTF8String; out Value: Int64);
 
+procedure xsdParseLong(const S: AnsiString; out Value: Int64);
 
 begin
 
   xsdParseLong(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseUnsignedByte(const S: UTF8String; out Value: Byte);
 
+procedure xsdParseUnsignedByte(const S: AnsiString; out Value: Byte);
 
 begin
 
   xsdParseUnsignedByte(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseUnsignedShort(const S: UTF8String; out Value: Word);
 
+procedure xsdParseUnsignedShort(const S: AnsiString; out Value: Word);
 
 begin
 
   xsdParseUnsignedShort(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseUnsignedInt(const S: UTF8String; out Value: Longword);
 
+procedure xsdParseUnsignedInt(const S: AnsiString; out Value: Longword);
 
 begin
 
   xsdParseUnsignedInt(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseUnsignedLong(const S: UTF8String; out Value: QWord);
 
+procedure xsdParseUnsignedLong(const S: AnsiString; out Value: QWord);
 
 begin
 
   xsdParseUnsignedLong(PChar(S), Length(S), Value);
 
 end;
 
 
-procedure xsdParseEnum(const S: UTF8String; enum: array of Utf8String; out Value: Integer);
 
+procedure xsdParseEnum(const S: AnsiString; enum: array of AnsiString; out Value: Integer);
 
 begin
 
   xsdParseEnum(PChar(S), Length(S), enum, Value);
 
 end;
 
 
-function xsdParseString(const S: UTF8String): Utf8String;
 
+function xsdParseString(const S: AnsiString): AnsiString;
 
 begin
 
   xsdParseString(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseStringLower(const S: UTF8String): Utf8String;
 
+function xsdParseStringLower(const S: AnsiString): AnsiString;
 
 begin
 
   xsdParseStringLower(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseBoolean(const S: UTF8String): Boolean;
 
+function xsdParseBoolean(const S: AnsiString): Boolean;
 
 begin
 
   xsdParseBoolean(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseDate(const S: UTF8String; Timezone: PXsdTimezone): TDateTime;
 
+function xsdParseDate(const S: AnsiString; Timezone: PXsdTimezone): TDateTime;
 
 begin
 
   xsdParseDate(PChar(S), Length(S), Result, Timezone);
 
 end;
 
 
-function xsdParseTime(const S: UTF8String; Timezone: PXsdTimezone): TDateTime;
 
+function xsdParseTime(const S: AnsiString; Timezone: PXsdTimezone): TDateTime;
 
 begin
 
   xsdParseTime(PChar(S), Length(S), Result, Timezone);
 
 end;
 
 
-function xsdParseDateTime(const S: UTF8String; Timezone: PXsdTimezone): TDateTime;
 
+function xsdParseDateTime(const S: AnsiString; Timezone: PXsdTimezone): TDateTime;
 
 begin
 
   xsdParseDateTime(PChar(S), Length(S), Result, Timezone);
 
 end;
 
 
-function xsdParseDecimal(const S: UTF8String): Extended;
 
+function xsdParseDecimal(const S: AnsiString): Extended;
 
 begin
 
   xsdParseDecimal(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseDouble(const S: UTF8String): Double;
 
+function xsdParseDouble(const S: AnsiString): Double;
 
 begin
 
   xsdParseDouble(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseFloat(const S: UTF8String): Single;
 
+function xsdParseFloat(const S: AnsiString): Single;
 
 begin
 
   xsdParseFloat(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseInteger(const S: UTF8String): Int64;
 
+function xsdParseInteger(const S: AnsiString): Int64;
 
 begin
 
   xsdParseInteger(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseNonNegativeInteger(const S: UTF8String): QWord;
 
+function xsdParseNonNegativeInteger(const S: AnsiString): QWord;
 
 begin
 
   xsdParseNonNegativeInteger(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseNonPositiveInteger(const S: UTF8String): Int64;
 
+function xsdParseNonPositiveInteger(const S: AnsiString): Int64;
 
 begin
 
   xsdParseNonPositiveInteger(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseNegativeInteger(const S: UTF8String): Int64;
 
+function xsdParseNegativeInteger(const S: AnsiString): Int64;
 
 begin
 
   xsdParseNegativeInteger(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParsePositiveInteger(const S: UTF8String): QWord;
 
+function xsdParsePositiveInteger(const S: AnsiString): QWord;
 
 begin
 
   xsdParsePositiveInteger(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseByte(const S: UTF8String): Shortint;
 
+function xsdParseByte(const S: AnsiString): Shortint;
 
 begin
 
   xsdParseByte(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseShort(const S: UTF8String): Smallint;
 
+function xsdParseShort(const S: AnsiString): Smallint;
 
 begin
 
   xsdParseShort(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseInt(const S: UTF8String): Longint;
 
+function xsdParseInt(const S: AnsiString): Longint;
 
 begin
 
   xsdParseInt(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseLong(const S: UTF8String): Int64;
 
+function xsdParseLong(const S: AnsiString): Int64;
 
 begin
 
   xsdParseLong(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseUnsignedByte(const S: UTF8String): Byte;
 
+function xsdParseUnsignedByte(const S: AnsiString): Byte;
 
 begin
 
   xsdParseUnsignedByte(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseUnsignedShort(const S: UTF8String): Word;
 
+function xsdParseUnsignedShort(const S: AnsiString): Word;
 
 begin
 
   xsdParseUnsignedShort(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseUnsignedInt(const S: UTF8String): Longword;
 
+function xsdParseUnsignedInt(const S: AnsiString): Longword;
 
 begin
 
   xsdParseUnsignedInt(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseUnsignedLong(const S: UTF8String): QWord;
 
+function xsdParseUnsignedLong(const S: AnsiString): QWord;
 
 begin
 
   xsdParseUnsignedLong(PChar(S), Length(S), Result);
 
 end;
 
 
-function xsdParseEnum(const S: UTF8String; enum: array of Utf8String): Integer;
 
+function xsdParseEnum(const S: AnsiString; enum: array of AnsiString): Integer;
 
 begin
 
   xsdParseEnum(PChar(S), Length(S), enum, Result);
 
 end;