Ich habe den Code ausführlich getestet und bisher keine Fehler gefunden.[u]korrekturen.de[/u] hat geschrieben:Die Regeln zur Verschriftlichung von Zahlen sind recht einfach: Nach Duden schreibt man Zahlen unter einer Million in Wörtern zusammen. Zahlen über einer Million schreibt man getrennt, wobei die Zahlwörter Million, Milliarde etc. großgeschrieben werden. Zu beachten ist, dass das Numerale im Plural steht, wenn das bestimmende Zahlwort größer als eins ist: eine Million; aber: zwei Millionen.
Viel Spaß damit!
Anmerkung:
Damit der eingebaute PB-Befehl Assert() funktioniert, muss man zuvor die Datei "PureUnit.res" vom PureBasic-Unterverzeichnis "Sdk\PureUnit\" in das Unterverzeichnis "Residents\" verschieben.
//edit 2020-07-20: Code etwas vereinfacht.
Code: Alles auswählen
; <https://www.purebasic.fr/german/viewtopic.php?f=8&t=32044>
; Version 1.02
; getestet mit PB 5.72 LTS x86 und x64
DeclareModule ZW
; -- Konvertieren von Zahlen in Zahlwörter und umgekehrt
Declare.s StrW (x.q) ; liefert die Ganzzahl x als deutsches Wort
Declare.q ValW (s$) ; liefert den Wert einer Ganzzahl, die als deutsches Wort gegeben ist
EndDeclareModule
Module ZW
EnableExplicit
; Die beiden folgenden Arrays werden mit der Prozedur _Group2Word() geShared.
Dim s_word_01$(9)
s_word_01$(0) = ""
s_word_01$(1) = "ein"
s_word_01$(2) = "zwei"
s_word_01$(3) = "drei"
s_word_01$(4) = "vier"
s_word_01$(5) = "fünf"
s_word_01$(6) = "sechs"
s_word_01$(7) = "sieben"
s_word_01$(8) = "acht"
s_word_01$(9) = "neun"
Dim s_word_10$(9)
s_word_10$(0) = ""
s_word_10$(1) = "zehn"
s_word_10$(2) = "zwanzig"
s_word_10$(3) = "dreißig"
s_word_10$(4) = "vierzig"
s_word_10$(5) = "fünfzig"
s_word_10$(6) = "sechzig"
s_word_10$(7) = "siebzig"
s_word_10$(8) = "achtzig"
s_word_10$(9) = "neunzig"
Procedure.s _Group2Word (group.i, p.i)
; private Funktion für StrW(): wandelt eine Gruppe aus maximal 3 Ziffern um
Shared s_word_01$(), s_word_10$()
Protected.i h, s, z, e
Protected ret$=""
h = Int(group / 100) ; Hunderter
s = group % 100
If h > 0
ret$ = s_word_01$(h) + "hundert"
EndIf
Select s
Case 11
ret$ + "elf"
Case 12
ret$ + "zwölf"
Case 16
ret$ + "sechzehn"
Case 17
ret$ + "siebzehn"
Default
e = s % 10 ; Einer
If s = 1 And ((group > 1 And p >= 6) Or p = 0)
ret$ + "eins"
ElseIf group = 1 And p >= 6
ret$ + "eine"
ElseIf e >= 1
ret$ + s_word_01$(e)
EndIf
z = Int(s / 10) ; Zehner
If z >= 1
If z >= 2 And e >= 1
ret$ + "und"
EndIf
ret$ + s_word_10$(z)
EndIf
EndSelect
ProcedureReturn ret$
EndProcedure
Procedure.s StrW (x.q)
; -- liefert die Ganzzahl x als deutsches Wort
; (zum Format s. z.B. <https://www.korrekturen.de/zahlwort/>)
Protected n.i, r.i, p.i, group.i, x$, ret$=""
If x = 0
ProcedureReturn "null"
EndIf
If x < 0
ret$ = "minus "
x = -x
EndIf
x$ = Str(x)
n = Len(x$)
r = n % 3
If r = 0
r = 3
EndIf
group = Val(Left(x$, r))
p = n - r
r + 1
While p >= 0
If group > 0
ret$ + _Group2Word(group, p)
; aktuelle Zifferngruppe nach ihrem Stellenwert benennen
Select p
Case 3
ret$ + "tausend"
Case 6
If group = 1
ret$ + " Million "
Else
ret$ + " Millionen "
EndIf
Case 9
If group = 1
ret$ + " Milliarde "
Else
ret$ + " Milliarden "
EndIf
Case 12
If group = 1
ret$ + " Billion "
Else
ret$ + " Billionen "
EndIf
Case 15
If group = 1
ret$ + " Billiarde "
Else
ret$ + " Billiarden "
EndIf
Case 18 ; Trillionen sind das Größte was eine Quad-Zahl speichern kann.
If group = 1
ret$ + " Trillion "
Else
ret$ + " Trillionen "
EndIf
EndSelect
EndIf
group = Val(Mid(x$, r, 3))
p - 3
r + 3
Wend
ProcedureReturn RTrim(ret$)
EndProcedure
;----------------------------------------------------------------------------
; Die beiden folgenden Maps werden mit der Prozedur _Group2Digits() geShared.
NewMap s_digit_01$()
s_digit_01$("") = "0"
s_digit_01$("ein") = "1"
s_digit_01$("eins") = "1"
s_digit_01$("eine") = "1"
s_digit_01$("zwei") = "2"
s_digit_01$("drei") = "3"
s_digit_01$("vier") = "4"
s_digit_01$("fünf") = "5"
s_digit_01$("sechs") = "6"
s_digit_01$("sech") = "6"
s_digit_01$("sieben") = "7"
s_digit_01$("sieb") = "7"
s_digit_01$("acht") = "8"
s_digit_01$("neun") = "9"
NewMap s_digit_10$()
s_digit_10$("zwanzig") = "2"
s_digit_10$("dreißig") = "3"
s_digit_10$("vierzig") = "4"
s_digit_10$("fünfzig") = "5"
s_digit_10$("sechzig") = "6"
s_digit_10$("siebzig") = "7"
s_digit_10$("achtzig") = "8"
s_digit_10$("neunzig") = "9"
Procedure.s _Group2Digits (group$)
; private Funktion für ValW(): wandelt eine Gruppe aus maximal 3 Ziffern um
Shared s_digit_01$(), s_digit_10$()
Protected f.i, ret$
f = FindString(group$, "hundert")
If f
ret$ = s_digit_01$(Left(group$, f-1)) ; Hunderter
group$ = Mid(group$, f+7)
Else
ret$ = "0"
EndIf
f = FindString(group$, "und")
If f
ret$ + s_digit_10$(Mid(group$, f+3)) + s_digit_01$(Left(group$, f-1))
ElseIf Right(group$, 4) = "zehn"
ret$ + "1" + s_digit_01$(Left(group$, Len(group$)-4))
ElseIf FindMapElement(s_digit_10$(), group$)
ret$ + s_digit_10$() + "0"
ElseIf FindMapElement(s_digit_01$(), group$)
ret$ + "0" + s_digit_01$()
ElseIf group$ = "elf"
ret$ + "11"
ElseIf group$ = "zwölf"
ret$ + "12"
Else
ret$ + "00"
EndIf
ProcedureReturn ret$
EndProcedure
Procedure.q ValW (s$)
; -- liefert den Wert einer Ganzzahl, die als deutsches Wort gegeben ist
; (in der Form wie von StrW() erzeugt)
Protected v.q, numFields.i, i.i, p.i, p_f.i=0, negative.i=#False, group$, x$=""
If s$ = "null"
ProcedureReturn 0
EndIf
s$ = ReplaceString(s$, "tausend", " tausend ")
numFields = CountString(s$, " ") + 1
If StringField(s$, 1, " ") = "minus"
negative = #True
i = 2
Else
i = 1
EndIf
While i <= numFields
group$ = StringField(s$, i, " ")
i + 1
; Stellenwert der aktuellen Zifferngruppe ermitteln
Select StringField(s$, i, " ")
Case ""
p = 0
Case "tausend"
p = 3
Case "Millionen", "Million"
p = 6
Case "Milliarden", "Milliarde"
p = 9
Case "Billionen", "Billion"
p = 12
Case "Billiarden", "Billiarde"
p = 15
Case "Trillionen", "Trillion" ; das Größte was eine Quad-Zahl speichern kann
p = 18
EndSelect
i + 1
If p_f > p
x$ + LSet("", p_f-p, "0")
EndIf
p_f = p - 3
x$ + _Group2Digits(group$)
Wend
If p > 0
x$ + LSet("", p, "0")
EndIf
v = Val(x$)
If negative
v = -v
EndIf
ProcedureReturn v
EndProcedure
EndModule
CompilerIf #PB_Compiler_IsMainFile
;-- Modul-Demo und -Test
EnableExplicit
Macro v (_s_)
Val(RemoveString(_s_, " "))
EndMacro
Assert(ZW::StrW(v(" - 16")) = "minus sechzehn")
Assert(ZW::StrW(v(" - 87 654 321")) = "minus siebenundachtzig Millionen sechshundertvierundfünfzigtausenddreihunderteinundzwanzig")
Assert(ZW::StrW(v(" 200")) = "zweihundert")
Assert(ZW::StrW(v(" 201")) = "zweihunderteins")
Assert(ZW::StrW(v(" 1 000")) = "eintausend")
Assert(ZW::StrW(v(" 1 001")) = "eintausendeins")
Assert(ZW::StrW(v(" 101 000")) = "einhunderteintausend")
Assert(ZW::StrW(v(" 201 000")) = "zweihunderteintausend")
Assert(ZW::StrW(v(" 1 000 000")) = "eine Million")
Assert(ZW::StrW(v(" 1 000 001")) = "eine Million eins")
Assert(ZW::StrW(v(" 90 000 010")) = "neunzig Millionen zehn")
Assert(ZW::StrW(v(" 93 040 001")) = "dreiundneunzig Millionen vierzigtausendeins")
Assert(ZW::StrW(v(" 987 654 321")) = "neunhundertsiebenundachtzig Millionen sechshundertvierundfünfzigtausenddreihunderteinundzwanzig")
Assert(ZW::StrW(v(" 651 524 892 413 015 699")) = "sechshunderteinundfünfzig Billiarden fünfhundertvierundzwanzig Billionen achthundertzweiundneunzig Milliarden vierhundertdreizehn Millionen fünfzehntausendsechshundertneunundneunzig")
Assert(ZW::StrW(v("4 284 631 793 000 961 732")) = "vier Trillionen zweihundertvierundachtzig Billiarden sechshunderteinunddreißig Billionen siebenhundertdreiundneunzig Milliarden neunhunderteinundsechzigtausendsiebenhundertzweiunddreißig")
Assert(ZW::StrW(v("8 423 508 350 219 544 536")) = "acht Trillionen vierhundertdreiundzwanzig Billiarden fünfhundertacht Billionen dreihundertfünfzig Milliarden zweihundertneunzehn Millionen fünfhundertvierundvierzigtausendfünfhundertsechsunddreißig")
Assert(ZW::StrW(v("1 747 479 282 425 819 125")) = "eine Trillion siebenhundertsiebenundvierzig Billiarden vierhundertneunundsiebzig Billionen zweihundertzweiundachtzig Milliarden vierhundertfünfundzwanzig Millionen achthundertneunzehntausendeinhundertfünfundzwanzig")
Assert(ZW::StrW(v("8 454 277 975 217 027 466")) = "acht Trillionen vierhundertvierundfünfzig Billiarden zweihundertsiebenundsiebzig Billionen neunhundertfünfundsiebzig Milliarden zweihundertsiebzehn Millionen siebenundzwanzigtausendvierhundertsechsundsechzig")
Assert(ZW::StrW(v("3 002 028 868 817 162 930")) = "drei Trillionen zwei Billiarden achtundzwanzig Billionen achthundertachtundsechzig Milliarden achthundertsiebzehn Millionen einhundertzweiundsechzigtausendneunhundertdreißig")
Assert(ZW::StrW(v("3 029 665 677 839 595 315")) = "drei Trillionen neunundzwanzig Billiarden sechshundertfünfundsechzig Billionen sechshundertsiebenundsiebzig Milliarden achthundertneununddreißig Millionen fünfhundertfünfundneunzigtausenddreihundertfünfzehn")
Assert(ZW::StrW(v("6 179 113 632 970 933 014")) = "sechs Trillionen einhundertneunundsiebzig Billiarden einhundertdreizehn Billionen sechshundertzweiunddreißig Milliarden neunhundertsiebzig Millionen neunhundertdreiunddreißigtausendvierzehn")
Assert(ZW::StrW(v("7 128 375 588 179 939 684")) = "sieben Trillionen einhundertachtundzwanzig Billiarden dreihundertfünfundsiebzig Billionen fünfhundertachtundachtzig Milliarden einhundertneunundsiebzig Millionen neunhundertneununddreißigtausendsechshundertvierundachtzig")
Assert(ZW::StrW(v("9 085 640 987 340 286 654")) = "neun Trillionen fünfundachtzig Billiarden sechshundertvierzig Billionen neunhundertsiebenundachtzig Milliarden dreihundertvierzig Millionen zweihundertsechsundachtzigtausendsechshundertvierundfünfzig")
Assert(ZW::StrW(v("9 065 186 176 374 882 956")) = "neun Trillionen fünfundsechzig Billiarden einhundertsechsundachtzig Billionen einhundertsechsundsiebzig Milliarden dreihundertvierundsiebzig Millionen achthundertzweiundachtzigtausendneunhundertsechsundfünfzig")
Assert(ZW::StrW(v("4 986 577 031 020 725 946")) = "vier Trillionen neunhundertsechsundachtzig Billiarden fünfhundertsiebenundsiebzig Billionen einunddreißig Milliarden zwanzig Millionen siebenhundertfünfundzwanzigtausendneunhundertsechsundvierzig")
Assert(ZW::StrW(v("2 381 670 853 137 415 692")) = "zwei Trillionen dreihunderteinundachtzig Billiarden sechshundertsiebzig Billionen achthundertdreiundfünfzig Milliarden einhundertsiebenunddreißig Millionen vierhundertfünfzehntausendsechshundertzweiundneunzig")
Assert(ZW::StrW(v("9 220 249 861 447 299 061")) = "neun Trillionen zweihundertzwanzig Billiarden zweihundertneunundvierzig Billionen achthunderteinundsechzig Milliarden vierhundertsiebenundvierzig Millionen zweihundertneunundneunzigtausendeinundsechzig")
Assert(ZW::StrW(v("2 481 530 840 887 536 334")) = "zwei Trillionen vierhunderteinundachtzig Billiarden fünfhundertdreißig Billionen achthundertvierzig Milliarden achthundertsiebenundachtzig Millionen fünfhundertsechsunddreißigtausenddreihundertvierunddreißig")
Assert(ZW::StrW(v("2 047 566 355 826 081 670")) = "zwei Trillionen siebenundvierzig Billiarden fünfhundertsechsundsechzig Billionen dreihundertfünfundfünfzig Milliarden achthundertsechsundzwanzig Millionen einundachtzigtausendsechshundertsiebzig")
Assert(ZW::StrW(v("1 484 490 129 443 189 903")) = "eine Trillion vierhundertvierundachtzig Billiarden vierhundertneunzig Billionen einhundertneunundzwanzig Milliarden vierhundertdreiundvierzig Millionen einhundertneunundachtzigtausendneunhundertdrei")
Assert(ZW::StrW(v("6 189 553 072 180 420 824")) = "sechs Trillionen einhundertneunundachtzig Billiarden fünfhundertdreiundfünfzig Billionen zweiundsiebzig Milliarden einhundertachtzig Millionen vierhundertzwanzigtausendachthundertvierundzwanzig")
Assert(ZW::StrW(v("1 706 814 501 005 747 650")) = "eine Trillion siebenhundertsechs Billiarden achthundertvierzehn Billionen fünfhunderteins Milliarden fünf Millionen siebenhundertsiebenundvierzigtausendsechshundertfünfzig")
Assert(ZW::StrW(v("2 101 363 237 794 137 187")) = "zwei Trillionen einhunderteins Billiarden dreihundertdreiundsechzig Billionen zweihundertsiebenunddreißig Milliarden siebenhundertvierundneunzig Millionen einhundertsiebenunddreißigtausendeinhundertsiebenundachtzig")
; max. Quad:
Assert(ZW::StrW(v("9 223 372 036 854 775 807")) = "neun Trillionen zweihundertdreiundzwanzig Billiarden dreihundertzweiundsiebzig Billionen sechsunddreißig Milliarden achthundertvierundfünfzig Millionen siebenhundertfünfundsiebzigtausendachthundertsieben")
;----------------------------------------------------------------------------
Assert(v(" - 16") = ZW::ValW("minus sechzehn"))
Assert(v(" - 87 654 321") = ZW::ValW("minus siebenundachtzig Millionen sechshundertvierundfünfzigtausenddreihunderteinundzwanzig"))
Assert(v(" 200") = ZW::ValW("zweihundert"))
Assert(v(" 201") = ZW::ValW("zweihunderteins"))
Assert(v(" 1 000") = ZW::ValW("eintausend"))
Assert(v(" 1 001") = ZW::ValW("eintausendeins"))
Assert(v(" 101 000") = ZW::ValW("einhunderteintausend"))
Assert(v(" 201 000") = ZW::ValW("zweihunderteintausend"))
Assert(v(" 1 000 000") = ZW::ValW("eine Million"))
Assert(v(" 1 000 001") = ZW::ValW("eine Million eins"))
Assert(v(" 90 000 010") = ZW::ValW("neunzig Millionen zehn"))
Assert(v(" 93 040 001") = ZW::ValW("dreiundneunzig Millionen vierzigtausendeins"))
Assert(v(" 987 654 321") = ZW::ValW("neunhundertsiebenundachtzig Millionen sechshundertvierundfünfzigtausenddreihunderteinundzwanzig"))
Assert(v(" 651 524 892 413 015 699") = ZW::ValW("sechshunderteinundfünfzig Billiarden fünfhundertvierundzwanzig Billionen achthundertzweiundneunzig Milliarden vierhundertdreizehn Millionen fünfzehntausendsechshundertneunundneunzig"))
Assert(v("4 284 631 793 000 961 732") = ZW::ValW("vier Trillionen zweihundertvierundachtzig Billiarden sechshunderteinunddreißig Billionen siebenhundertdreiundneunzig Milliarden neunhunderteinundsechzigtausendsiebenhundertzweiunddreißig"))
Assert(v("8 423 508 350 219 544 536") = ZW::ValW("acht Trillionen vierhundertdreiundzwanzig Billiarden fünfhundertacht Billionen dreihundertfünfzig Milliarden zweihundertneunzehn Millionen fünfhundertvierundvierzigtausendfünfhundertsechsunddreißig"))
Assert(v("1 747 479 282 425 819 125") = ZW::ValW("eine Trillion siebenhundertsiebenundvierzig Billiarden vierhundertneunundsiebzig Billionen zweihundertzweiundachtzig Milliarden vierhundertfünfundzwanzig Millionen achthundertneunzehntausendeinhundertfünfundzwanzig"))
Assert(v("8 454 277 975 217 027 466") = ZW::ValW("acht Trillionen vierhundertvierundfünfzig Billiarden zweihundertsiebenundsiebzig Billionen neunhundertfünfundsiebzig Milliarden zweihundertsiebzehn Millionen siebenundzwanzigtausendvierhundertsechsundsechzig"))
Assert(v("3 002 028 868 817 162 930") = ZW::ValW("drei Trillionen zwei Billiarden achtundzwanzig Billionen achthundertachtundsechzig Milliarden achthundertsiebzehn Millionen einhundertzweiundsechzigtausendneunhundertdreißig"))
Assert(v("3 029 665 677 839 595 315") = ZW::ValW("drei Trillionen neunundzwanzig Billiarden sechshundertfünfundsechzig Billionen sechshundertsiebenundsiebzig Milliarden achthundertneununddreißig Millionen fünfhundertfünfundneunzigtausenddreihundertfünfzehn"))
Assert(v("6 179 113 632 970 933 014") = ZW::ValW("sechs Trillionen einhundertneunundsiebzig Billiarden einhundertdreizehn Billionen sechshundertzweiunddreißig Milliarden neunhundertsiebzig Millionen neunhundertdreiunddreißigtausendvierzehn"))
Assert(v("7 128 375 588 179 939 684") = ZW::ValW("sieben Trillionen einhundertachtundzwanzig Billiarden dreihundertfünfundsiebzig Billionen fünfhundertachtundachtzig Milliarden einhundertneunundsiebzig Millionen neunhundertneununddreißigtausendsechshundertvierundachtzig"))
Assert(v("9 085 640 987 340 286 654") = ZW::ValW("neun Trillionen fünfundachtzig Billiarden sechshundertvierzig Billionen neunhundertsiebenundachtzig Milliarden dreihundertvierzig Millionen zweihundertsechsundachtzigtausendsechshundertvierundfünfzig"))
Assert(v("9 065 186 176 374 882 956") = ZW::ValW("neun Trillionen fünfundsechzig Billiarden einhundertsechsundachtzig Billionen einhundertsechsundsiebzig Milliarden dreihundertvierundsiebzig Millionen achthundertzweiundachtzigtausendneunhundertsechsundfünfzig"))
Assert(v("4 986 577 031 020 725 946") = ZW::ValW("vier Trillionen neunhundertsechsundachtzig Billiarden fünfhundertsiebenundsiebzig Billionen einunddreißig Milliarden zwanzig Millionen siebenhundertfünfundzwanzigtausendneunhundertsechsundvierzig"))
Assert(v("2 381 670 853 137 415 692") = ZW::ValW("zwei Trillionen dreihunderteinundachtzig Billiarden sechshundertsiebzig Billionen achthundertdreiundfünfzig Milliarden einhundertsiebenunddreißig Millionen vierhundertfünfzehntausendsechshundertzweiundneunzig"))
Assert(v("9 220 249 861 447 299 061") = ZW::ValW("neun Trillionen zweihundertzwanzig Billiarden zweihundertneunundvierzig Billionen achthunderteinundsechzig Milliarden vierhundertsiebenundvierzig Millionen zweihundertneunundneunzigtausendeinundsechzig"))
Assert(v("2 481 530 840 887 536 334") = ZW::ValW("zwei Trillionen vierhunderteinundachtzig Billiarden fünfhundertdreißig Billionen achthundertvierzig Milliarden achthundertsiebenundachtzig Millionen fünfhundertsechsunddreißigtausenddreihundertvierunddreißig"))
Assert(v("2 047 566 355 826 081 670") = ZW::ValW("zwei Trillionen siebenundvierzig Billiarden fünfhundertsechsundsechzig Billionen dreihundertfünfundfünfzig Milliarden achthundertsechsundzwanzig Millionen einundachtzigtausendsechshundertsiebzig"))
Assert(v("1 484 490 129 443 189 903") = ZW::ValW("eine Trillion vierhundertvierundachtzig Billiarden vierhundertneunzig Billionen einhundertneunundzwanzig Milliarden vierhundertdreiundvierzig Millionen einhundertneunundachtzigtausendneunhundertdrei"))
Assert(v("6 189 553 072 180 420 824") = ZW::ValW("sechs Trillionen einhundertneunundachtzig Billiarden fünfhundertdreiundfünfzig Billionen zweiundsiebzig Milliarden einhundertachtzig Millionen vierhundertzwanzigtausendachthundertvierundzwanzig"))
Assert(v("1 706 814 501 005 747 650") = ZW::ValW("eine Trillion siebenhundertsechs Billiarden achthundertvierzehn Billionen fünfhunderteins Milliarden fünf Millionen siebenhundertsiebenundvierzigtausendsechshundertfünfzig"))
Assert(v("2 101 363 237 794 137 187") = ZW::ValW("zwei Trillionen einhunderteins Billiarden dreihundertdreiundsechzig Billionen zweihundertsiebenunddreißig Milliarden siebenhundertvierundneunzig Millionen einhundertsiebenunddreißigtausendeinhundertsiebenundachtzig"))
; max. Quad:
Assert(v("9 223 372 036 854 775 807") = ZW::ValW("neun Trillionen zweihundertdreiundzwanzig Billiarden dreihundertzweiundsiebzig Billionen sechsunddreißig Milliarden achthundertvierundfünfzig Millionen siebenhundertfünfundsiebzigtausendachthundertsieben"))
;-===========================================================================
CompilerIf #PB_Compiler_Processor = #PB_Processor_x64
#MaxInteger = 9223372036854775807
#MaxWidth = 25
CompilerElse
#MaxInteger = 2147483647
#MaxWidth = 13
CompilerEndIf
Procedure.s Fmt (x.q, width.i)
Protected p.i, s$
s$ = Str(x)
p = Len(s$) + 1
While p > 4
p - 3
s$ = InsertString(s$, " ", p)
Wend
If Len(s$) < width
ProcedureReturn RSet(s$, width)
Else
ProcedureReturn s$
EndIf
EndProcedure
Macro Check (_x_, _w_)
s$ = ZW::StrW(_x_)
v = ZW::ValW(s$)
If v = _x_
Debug Fmt(_x_, _w_) + " : " + s$
Else
Debug "Fehler:"
Debug "x = " + Fmt(_x_, _w_)
Debug "s$ = " + s$
Debug "v = " + Fmt(v, _w_)
End
EndIf
EndMacro
Define i.i, x.i, v.i, s$
For x = 0 To 35
Check(x, 3)
Next
Debug " ..."
For x = 95 To 135
Check(x, 3)
Next
Debug ""
For i = 1 To 24
x = Random(#MaxInteger)
Check(x, #MaxWidth)
Next
CompilerEndIf