Contributor: HELGE OLAV HELGESEN
{
Borland Pascal 7.0 National Language Support, with support for protected
mode. Written in october 1993 by Helge Olav Helgesen
The purpose of this unit is to give you the ability to write country-
dependant programs. I won't explain much how it works; since you have the
source, feel free to explore/change the source.
To do so I have a written a colletion of procedures, which are described
here:
procedure CreateTable(cc: Word);
This one creates a new table with the specified country-code. if you
specify a value of 0, the default country will be loaded. You should
check for errors thru GetError and PeekError.
procedure DumpTable (const name: string);
This one was written for debugging only, and shoudn't be used. It saves
the current translation table to the specific file
procedure Upper(var s: OpenString);
procedure Lower(var s: OpenString);
These two translates a string into upper or lower case only.
function GetError: word;
function PeekError: word;
These two can be used to get (and clear) the result from last
CreateTable. GetError clears ErrorCode afterwards, while PeekError
doesn't.
function Convert2Time(const dt: DateTime): string8;
This one will create a formatted string containing the time specified
in DateTime.Hour, DateTime.Min and DateTime.Sec. The string is formatted
according to the loaded country.
function Convert2Date(const dt: DateTime): string8;
This one does the same as the one above, except that a date is returned
instead.
function ConvertR2Currency(no: real): string;
This one will turn a real value into a formatted string, with the county's
currency symbol placed right.
The line 'WriteLn(ConvertR2Currency(1234.123));' will result
In USA: $1,234.12
In Norway: Kr 1.234,12
function UpChar(Ch: Char): Char;
function LoChar(Ch: Char): Char;
These two are written with inline statements, and will thus place the
expanded code into your program's code segment. Since they became
fairly large, you shoudn't use them too much.
procedure DumpAllCountries;
This one is only compiled in real mode, and is only intended to use with
debugging. It writes all countries that is available to the screen.
var Table: TTranslationTable;
This is *the* 256 byte translation table, which contains the mapping to
upper and lower chars.
var ErrorCode: word;
Result from last CreateTable. This is the Dos error code, as described
in 'Run-time error messages'.
var CurrTable: word;
If last CreateTable successed, this contains the country that is loaded.
var UnitOK: boolean;
Is TRUE if
1) Dos 3+ is loaded
2) Could allocate real-mode memory (DPMI only)
var CountryInfo: PCountryInfo;
This is a pointer to the current countrys info table. This pointer should
never derefenced unless UnitOK is true. It contains only valid data if
(CurrTable>0) and UnitOK!
I haven't done much to optimize the code. So even small changes may
increase the speed. If you have any comments, suggestion etc. feel free
to leave me a note.
You can reach me thru the following nets:
ILink - thru Qmail, Programming, ASM and Pascal
PolarNet - thru Pascal and Post
Rime - thru Common, Pascal and ASM. I'm located at site MIDNIGHT
ScanNet - virtually any conference
SourceNet - thru the Pascal conference
WEB - thru the Pascal conference
You may also reach me at the following bulletin boards:
Group One BBS - +1 312 752-1258
Midnight Sun BBS - +47 755 84 545
Programmer's BBS - +47 22 71 41 07
In all cases, my name is HELGE HELGESEN. My mail address is:
Helge Olav Helgesen
Box 726
8001 BODOE
Norway
Tlf. +47 755 23 694
}
{$S-,B- Do not change these! A change will cause faults! }
{$G+,D+,R-,Q-,L+,O+}
{$IFDEF Windows}Sorry, Windows is not supported...{$ENDIF}
unit NLS;
interface
uses {$IFDEF DPMI}WinAPI,{$ENDIF}Dos;
type
TTranslationTable = array[0..1, 0..127] of char;
AChar = record { ASCIIZ char from Country Info }
Letter: char;
Dummy: byte;
end; { AChar }
PCountryInfo = ^TCountryInfo;
TCountryInfo = record
DTFormat: word; { Date/Time format }
CurrSym: array[0..4] of char; { currency symbol }
ThouSep, { thousand separator }
DeciSep, { decimal separator }
DateSep, { date separator }
TimeSep: AChar; { time separator }
CurrFmt: byte; { currency format }
Digits: byte; { digits after decimal }
TimeFmt: boolean; { FALSE=12h else 24h }
CaseMap: pointer; { real mode case map }
DataSep: AChar; { data list separator }
RFU: array[0..9] of byte; { not used }
end; { TCountryInfo }
String8 = string[12];
var
Table: TTranslationTable; { the translation table }
ErrorCode: word; { error code from last create table }
CurrTable: word; { current country loaded, or 0 if none }
UnitOK: boolean; { true if extentions are allowed }
CountryInfo: PCountryInfo; { NB! Protected Mode selector under DPMI! }
procedure CreateTable(cp: word);
{ -creates new table }
procedure DumpTable (const name: string);
{ -saves table to disk, mainly written for debugging purposes }
procedure Upper (var s: OpenString);
{ -translate string to upper case (A NAME) }
procedure Lower (var s: OpenString);
{ -translate string to lower case (a name) }
function GetError: word;
{ -get and clear error }
function PeekError: word;
{ -get error }
function Convert2Time(const dt: DateTime): string8;
{ -converts time part of DateTime rec info country dep. string }
function Convert2Date(const dt: DateTime): string8;
{ -converts date part into XX:YY:ZZ country dep. }
function ConvertR2Currency(no: real): string;
{ -converts real value to currency }
function UpChar(Ch: Char): Char;
{ -converts char to upper case }
inline($58/ { pop ax }
$88/$c4/ { mov ah, al }
$a8/$80/ { test al, 80h }
$74/$10/ { je @1 }
$8b/$d8/ { mov bx, ax }
$32/$ff/ { xor bh, bh }
$8a/$a7/ { mov ah, [bx+ }
>Table-$80/ { Table-80h] }
$84/$e4/ { test ah, ah }
$74/$0d/ { le @2 }
$88/$e0/ { mov al, ah }
$eb/$09/ { jmp @2 }
{@1:} $f6/$d4/ { not ah }
$f6/$c4/$60/{ test ah, 60h }
$75/$02/ { jne @2 }
$34/$20 { xor al, 20h }
{@2:} );
function LoChar(Ch: Char): Char;
{ -translates Ch to lower char }
inline($58/ { pop ax }
$a8/$80/ { test al, 80h }
$74/$10/ { le @1 }
$8b/$d8/ { mov bx, ax }
$32/$ff/ { xor bh, bh }
$8a/$a7/ { mov ah, [bx+ }
>Table/ { TABLE] }
$0a/$e4/ { or ah, ah }
$74/$0c/ { je @2 }
$88/$e0/ { mov al, ah }
$eb/$08/ { jmp @2 }
{@1:} $88/$c4/ { mov ah, al }
$a8/$c0/ { test al, 0c0h }
$74/$08/ { je @2 }
$34/$20 { xor al, 20h }
{@2:} );
{$IFDEF MSDOS}
procedure DumpAllCountries;
{ -dumps all country codes supported. For debugging. Works only in real mode }
{$ENDIF}
implementation
{$IFDEF DPMI}
type
TBit32 = record
Low, High: word;
end; { Bit32 }
TCallRealMode = record { DPMI structure used to call real mode procs }
EDI, ESI, EBP, RFU1, EBX,
EDX, ECX, EAX: TBit32;
Flags, rES, rDS, rFS,
rGS, rIP, rCS, rSP,
rSS: word;
end; { TCallRealMode }
var
ciSelector: TBit32; { selector and segment to CountryInfo }
MyExitProc: pointer; { DPMI exit proc to deallocate Dos memory }
{$ENDIF}
type
string2 = string[2];
Pstring = ^String;
function Convert2Digit(no: word): string2;
var
s: string8;
begin
Str(no:2, s);
if s[0]>#2 then delete(s, 1, byte(s[0])-2);
if s[1]=#32 then s[1]:='0';
Convert2Digit:=s;
end; { Convert2Digit }
{$IFDEF MSDOS}
procedure DumpAllCountries;
function TestCountry(no: word): boolean; assembler;
var dummy: TCountryInfo;
asm
push ds
mov ax, ss
mov ds, ax
lea dx, dummy
mov ax, $38ff
mov bx, no
or bh, bh
je @1
mov al, bl
@1: int $21
pop ds
jc @x
xor ax, ax
@x:
end; { DumpAllcountries.TestCountry }
var
x: word;
begin
for x:=0 to 900 do if not TestCountry(x) then write(x:10);
end; { DumpAllCountries }
{$ENDIF}
function Convert2Time;
const
AM: string2 = 'AM';
PM: string2 = 'PM';
function To12(no: word): word;
begin
if no>12 then To12:=no-12 else To12:=no;
end; { Convert2Time.To12 }
function AmPm(no: word): Pstring;
begin
if no>12 then AmPm:=@PM else AmPm:=@AM;
end; { Convert2Time.AmPm }
var
Delemiter: char;
begin { Convert2Time }
if UnitOK and (ErrorCode=0) then
Delemiter:=CountryInfo^.TimeSep.Letter
else
Delemiter:=':';
if UnitOK and (CurrTable>0) and CountryInfo^.TimeFmt then
Convert2Time:=Convert2Digit(dt.Hour)+Delemiter+ { time }
Convert2Digit(dt.Min)+Delemiter+ { min }
Convert2Digit(dt.Sec)
else
Convert2Time:=Convert2Digit(To12(dt.Hour))+Delemiter+ { time }
Convert2Digit(dt.Min)+Delemiter+ { min }
Convert2Digit(dt.Sec)+#32+AMPM(dt.Hour)^{ sec }
end; { Convert2Time }
function Convert2Date;
var
Dele: char;
begin
if UnitOK and (CurrTable>0) then
Dele:=CountryInfo^.DateSep.Letter
else
Dele:='/';
if UnitOK and (CurrTable>0) and (CountryInfo^.DTFormat>0) then
case CountryInfo^.DTFormat of
1: Convert2Date:=Convert2Digit(dt.Day)+Dele+ { date }
Convert2Digit(dt.Month)+Dele+ { month }
Convert2Digit(dt.Year); { year }
2: Convert2Date:=Convert2Digit(dt.Year)+Dele+ { year }
Convert2Digit(dt.Month)+Dele+ { month }
Convert2Digit(dt.Day);
end { case }
else { if }
Convert2Date:= Convert2Digit(dt.Month)+Dele+ { month }
Convert2Digit(dt.Day)+Dele+ { day }
Convert2Digit(dt.Year); { year }
end; { Convert2Time }
function ConvertR2Currency;
function GetCurrency: string8;
var
s: string8;
begin
s:=CountryInfo^.CurrSym;
while s[byte(s[0])]=#0 do dec(s[0]);
GetCurrency:=s;
end; { ConvertR2Currency.GetCurrency }
function FormatString(s: string): string;
var
Comma, Digits: byte;
c: integer;
Dele: char;
begin
Dele:=CountryInfo^.ThouSep.Letter; { get thousand delemiter }
Digits:=Pos('.', s); { digits before delemither }
Comma:=Digits; { save comma position }
if Digits=0 then Digits:=Length(s)+1; { start rightmost if no comma }
c:=Digits-3; { init counter }
while c>2 do
begin
Insert(Dele, s, c); { insert thousand delemither }
Dec(c, 3); { adjust pointer }
if Comma>0 then Inc(Comma); { increase comma position(if any) }
end; { while }
if Comma>0 then { adjust comma, if any }
s[Comma]:=CountryInfo^.DeciSep.Letter;
FormatString:=s;
end; { ConvertR2Currency.FormatString }
function PlaceCurrency(s: string): string;
var
x: byte;
begin
x:=Pos(CountryInfo^.DeciSep.Letter, s);
Delete(s, x, 1);
Insert(GetCurrency, s, x);
PlaceCurrency:=s;
end; { ConvertR2Currency.PlaceCurrency }
var
s: string[20];
begin { ConvertR2Currency }
if UnitOK and (CurrTable>0) then
begin
Str(no:20:CountryInfo^.Digits, s);
while s[1]=#32 do delete(s, 1, 1);
s:=FormatString(s);
end
else
begin
Str(no:20:2, s);
while s[1]=#32 do delete(s, 1, 1);
end; { if/else }
if UnitOK and (CurrTable>0) then
case CountryInfo^.CurrFmt of
0: s:=GetCurrency+s;
1: s:=s+GetCurrency;
2: s:=GetCurrency+#32+s;
3: s:=s+#32+GetCurrency;
4: s:=PlaceCurrency(s);
end; { case }
ConvertR2Currency:=s;
end; { ConvertR2Currency }
procedure DumpTable;
var
f: file of TTranslationTable;
begin
assign(f, name);
rewrite(f);
write(f, Table);
close(f);
end;
procedure CreateTable;
var
b: byte;
c, d: char;
procedure GetCountryInfo(cp: word);
var
r: Registers;
begin
r.AX:=$38FF;
if cp>255 then r.BX:=cp else r.AL:=Lo(cp);
r.DS:=Seg(CountryInfo^);
r.DX:=Ofs(CountryInfo^);
MsDos(r);
if r.Flags and 1=1 then ErrorCode:=r.AX;
if ErrorCode=0 then CurrTable:=r.BX else CurrTable:=0;
end; { CreateTable.GetCoutryInfo }
function CallCaseMap(Letter: char): char; assembler;
{$IFNDEF MSDOS}
var
regs: TCallRealMode;
{$ENDIF}
asm
mov al, Letter
{$IFNDEF MSDOS}
mov word ptr regs.EAX, ax
mov regs.rSP, 0
mov regs.rSS, 0
les di, CountryInfo
mov ax, word ptr es:[di].TCountryInfo.CaseMap
mov regs.RIP, ax
mov ax, word ptr es:[di].TCountryInfo.CaseMap+2
mov regs.RCS, ax
mov ax, ss
mov es, ax
lea di, regs
xor cx, cx
mov ax, $301
int $31 { execute real mode proc }
mov ax, word ptr regs.EAX
{$ELSE}
les di, CountryInfo
call es:[di].TCountryInfo.CaseMap
{$ENDIF}
end; { CreateTable.CallCaseMap }
procedure MapIn(NewChar, OldChar: char);
begin
Table[0, byte(OldChar) and $7f]:=NewChar;
Table[1, byte(NewChar) and $7f]:=OldChar;
end; { CreateTable.MapIn }
begin { CreateTable }
if (ErrorCode>0) or not UnitOK then exit; { leave if any pending error }
FillChar(Table, sizeof(Table), 0);
GetCountryInfo(cp);
if ErrorCode>0 then exit; { leave if any error occured }
for b:=0 to 127 do
begin
c:=CallCaseMap(char(b+128));
if c<>char(b+128) then MapIn(c, char(b+128));
end; { for }
end; { CreateTable }
procedure UpCase; assembler;
{
This translates the incoming char in AL into upper case if it is defined
in the translation table.
Please note that if you enable stack checking, this proc won't work...
}
asm
test al, $80
je @1
xor ah, ah
mov bx, ax
mov ah, byte[Table+bx-$80]
test ah, ah
je @x
mov al, ah
jmp @x
@1:
cmp al, 'z'
jg @x
cmp al, 'a'
jl @x
xor al, $20
@x:
end; { UpChar }
procedure LowChar; assembler;
asm
test al, $80
je @1
mov bx, ax
xor bh, bh
mov ah, byte[Table+bx]
or ah, ah
je @x
mov al, ah
jmp @x
@1:
cmp al, 'Z'
jg @x
cmp al, 'A'
jl @x
xor al, $20
@x:
end; { LowChar }
procedure Upper; assembler;
asm
les di, s
mov cl, es:[di]
xor ch, ch
jcxz @x
inc di
@1:
mov al, es:[di]
call UpCase
mov es:[di], al
inc di
loop @1
@x:
end; { Upper }
procedure Lower; assembler;
asm
les di, s
mov cl, es:[di]
xor ch, ch
jcxz @x
inc di
@1:
mov al, es:[di]
call LowChar
mov es:[di], al
inc di
loop @1
@x:
end; { Lower }
function GetError; assembler;
asm
mov ax, ErrorCode
mov ErrorCode, 0
end; { GetError }
function PeekError; assembler;
asm
mov ax, ErrorCode
end; { PeekError }
{$IFNDEF MSDOS}
procedure Leave; far;
begin
ExitProc:=MyExitProc; { change to old handler }
GlobalDosFree(ciSelector.High); { release Dos memory }
end; { Leave }
procedure InitExitProc;
begin
MyExitProc:=ExitProc; { save old handler }
ExitProc:=@Leave; { save my own handler }
end; { InitExitProc }
{$ENDIF}
begin { NLS }
UnitOk:=Lo(DosVersion)>=3; { does only work for Dos 3+ }
if UnitOK then { allocate memory }
begin
{$IFDEF DPMI}
longint(ciSelector):=GlobalDosAlloc(sizeof(TCountryInfo));
if ciSelector.Low=0 then UnitOK:=False; { if not enough Dos memory }
CountryInfo:=Ptr(ciSelector.Low, 0); { make protected mode pointer }
if UnitOK then InitExitProc; { change exit proc }
{$ELSE}
if MaxAvail>sizeof(CountryInfo^) then{ allocate if enough memory }
New(CountryInfo)
else
UnitOK:=False; { or disable extentions }
{$ENDIF}
end; { if UnitOK }
end.