Programme leichter internationalisieren mit parametrierbaren Zeichenketten
Veröffentlicht: 14. Jun 2000 | Aktualisiert: 15. Jun 2004
Von Ralf Westphal
Diesen Artikel können Sie hier lesen dank freundlicher Unterstützung der Zeitschrift:
.gif "Bild04")
Überblick Der Artikel stellt eine Funktion vor, die es erlaubt, statt zusammengesetzter Zeichenketten parametrierte Strings zu benutzen, die leicht mit Übersetzungswerkzeugen behandelt werden können. Technik |
Bei der Internationalisierung von Software müssen wir während der Codierung ganz unterschiedliche Aspekte berücksichtigen: Zahlenformate, Datumseingaben, Symbolauswahl, Beschriftungen und vieles mehr sollen sich möglichst automatisch an die Landesgepflogenheiten anpassen. Betriebssystem und Werkzeuge zur Übersetzung helfen dabei nach Kräften und haben den Prozeß stark vereinfacht. Vor einem sehr spezifischen Übersetzungsproblem kapitulieren jedoch bisher alle Hilfsmittel: den zusammengesetzten Zeichenketten.
1x1 der Internationalisierung
Die Internationalisierung von Software besteht im Wesentlichen aus zwei Schritten:
**1.**Ersetzen von Landeseigenheiten im Code durch Platzhalter
**2.**Anlegen und Pflegen von Landeseigenheiten-Ressourcen
Landeseigenheiten sind z.B. Formatierungsanweisungen für Zahlen, Bilder oder Texte. Im ersten Schritt durchforsten wir also unsere Software und prüfen, wo wir Landeseigenheiten "fest verdrahtet" haben. An einigen Stellen ist das offensichtlich, an anderen nicht:
debug.print Format(now, "mm/dd/yy") MsgBox "Hello, World!" z = Val(text1.text)
Im ersten Statement ist das Datumsformat, nicht aber das Datumstrennzeichen festgeschrieben. Die Reihenfolge von Monat, Tag, Jahr ist landesspezifisch für die USA; der Code würde außerhalb der USA zu einer falschen Ausgabe führen, da z.B. in Deutschland die Konvention Tag, Monat, Jahr gilt. Den Schrägstrich als Datumstrennzeichen ersetzt VB jedoch entsprechend den Landeseinstellungen auf Betriebssystemebene durch Punkt, Bindestrich usw.
Die Landeseigenheit in der zweiten Anweisung ist offensichtlich: Wir müssen den Text übersetzen.
Das letzte Statement scheint ohne Fehl und Tadel. Die Funktion Val wandelt eine Ziffernfolge in einem String in einen Zahlenwert. Wenn wir jedoch genauer in die VB-Dokumentation schauen, stellen wir fest, dass Val als Dezimaltrenner immer einen Punkt erwartet. Val berücksichtigt die Landeseinstellungen also nicht und führt beim Einsatz außerhalb der USA zu Problemen bei Zahlen mit Nachkommastellen.
Versteckte Landeseigenheiten
Über die im selbstgeschriebenen Code sichtbaren Landeseigenheiten hinaus bestehen gewöhnlich weitere Abhängigkeiten. Sie sind in dem Code verborgen, den VB automatisch generiert, wenn wir die Benutzerschnittstelle zusammensetzen. FRM-Dateien enthalten viele Landeseigenheiten:
Begin VB.PictureBox Picture1 Height = 975 Left = 720 Picture = "Form1.frx":0000 ... End
Hier ist ein Bild fest an das PictureBox-Steuerelement gekoppelt. Das Steuerelement verweist auf die Bildressource in der FRX-Datei.
Ob ein Bild eine Landeseigenheit enthält, muss man für jedes Bild einzeln entscheiden. So sehen Mülltonnen und Postkästen in den USA anders aus als in Deutschland, oder ein roter Halbmond steht in arabischen Länder für das Rote Kreuz.Begin VB.Form frmAppBar BorderStyle = 5 Caption = "Application Desktop Toolbar"
oder
Begin VB.Menu mnuFloating Caption = "&Floating" Shortcut = ^F Checked = -1 End
Diese Beispiele enthalten Zeichenketten, die man übersetzen muss.
Allen verborgenen Landeseigenheiten ist gemeinsam, dass wir sie nur schwer durch Platzhalter direkt am Auftrittsort, d.h. in der Menü- oder Steuerelementdefinition, ersetzen können.
Landeseigenheiten durch Platzhalter ersetzen
Nach der Identifikation aller fest verdrahteten Landeseigenheiten müssen wir sie gegen Platzhalter austauschen:
debug.print Format(now, "short date") MsgBox LoadResString(24) z = CStr(text1.text)
In dieser internationalisierten Version des ersten Beispiels nehmen die Platzhalter unterschiedliche Formen an:
Das konkrete Datumsformat wurde durch einen Format-spezifischen Platzhalter ersetzt. Die Funktion liest jetzt das korrekte Datumsformat aus den Landeseinstellungen aus.
Der Text, den wir in der Messagebox anzeigen wollen, steht nicht mehr im Code, sondern in einer Windows Resource-Datei (s. Kasten 1).
Die Funktion CStr berücksichtigt bei der Zahlenumwandlung die Landeseinstellung für Tausender- und Dezimaltrennzeichen.
Die Platzhalter sorgen dafür, dass der Code frei von Landeseigenheiten wird. Die werden jetzt zur Laufzeit aus externen Ressourcen geladen, z.B. den Windows-Landeseinstellungen. Wir haben damit einen für alle Länder einheitlichen Code geschaffen, der nicht mehr je nach Zielland neu kompiliert werden muss.
Durch diese Trennung von Code und Landeseigenheiten ist es auch möglich, die Internationalisierung personell strikt von der Programmierung zu trennen. Die mit der Internationalisierung betrauten Personen können ihre Arbeit auf die externen Landeseigenheiten-Ressourcen beschränken.
Windows Resource-Dateien Unsere Software lädt Daten aus einer Resource-Datei über eine eindeutige Nummer, die Resource-ID. Daten gleichen Typs sind in Tabellen zusammengefasst, Zeichenketten z.B. in einer String Table. Neben Modulen und Formularen können wir in VB-Projekte auch eine Resource-Datei integrieren und bearbeiten (s. Abbildung 1). Ihr Inhalt lässt sich dann über die Funktionen LoadResString, LoadResPicture und LoadResData laden. Code und Landeseigenheiten sind mit dieser einen Resource-Datei zwar getrennt, erfordern aber dennoch eine Rekompilation mit verschiedenen Resource-Dateien für die unterschiedlichen Zielsprachen/-länder. Das ist eine Einschränkung von VB. Windows selbst bietet dagegen auch die Möglichkeit, Daten vom ausführbaren Programm wirklich getrennt zu halten und von dort zur Laufzeit zu laden. Mit der VC++-Entwicklungsumgebung können wir Resource-Dateien in eigenständige DLLs übersetzen, aus denen einzelne Ressourcen (Bilder, Texte usw.) dann per Win32 API-Funktionen herausgezogen werden. Weitere Informationen zum Thema Resource-Dateien finden Sie in den VC++ und VB-Dokumentationen. |
Kasten 1: Windows Resource-Dateien dienen der Trennung von Code und Landeseigenheiten - auch in VB-Projekten.
Versteckte Landeseigenheiten durch Platzhalter ersetzen
Für eine hundertprozentige Trennung von Code und Landeseigenheiten ist es auch nötig, dass wir die versteckten Abhängigkeiten offenlegen und in externe Ressourcen auslagern. Wir müssen Menüs, Shortcuts, Beschriftungen und Bilder im Code über Platzhalter zuweisen. Bezogen auf die obigen Beispiele könnte das so aussehen:
picture1 = LoadPicture(App.Path & "\images\mypic.bmp") frmAppBar.Caption = LoadResString(72) mnuFloating.Caption = LoadResString(68)
Der Code "überschreibt" die Definitionen der FRM-Datei zur Laufzeit mit Landeseigenheiten, die er aus externen Ressourcen lädt. Das kostet ein wenig Performance, reduziert den Internationalisierungsaufwand jedoch erheblich.
Lediglich der Menü-Shortcut ^F des Beispiels kann nicht zur Laufzeit zugewiesen werden. Hierfür ist eine Änderung des FRM-Quelltextes notwendig.
Anlegen und Pflegen von Landeseigenheiten-Ressourcen
Externe Ressourcen für Landeseigenheiten müssen wir nicht in jedem Fall selbst anlegen. Für Dezimaltrenner, Datumsformate usw. führt Windows selbst die Ressourcen über die Ländereinstellungen in der Registry. Wir müssen nur darauf achten, dass wir im Code auch auf diese Ressourcen Bezug nehmen.
Für anwendungsspezifische Landeseigenheiten wie Texte und Bilder jedoch müssen wir die Ressourcen explizit erzeugen. VB bzw. Windows unterstützen uns dabei mit Resource-Dateien und einem API (s. Kasten 1 & Abbildung 1).
.gif "Bild01")
Abbildung 1: Mit dem Resource-Editor können wir externe Landeseigenheiten für Texte, Bilder, Cursor usw. verwalten. VB bietet verschiedene Funktionen, um auf die Daten innerhalb der Resource-Datei eines Projektes zuzugreifen.
Es steht uns natürlich frei, mit den Platzhaltern auch auf andere Arten von Ressourcen zuzugreifen. So können Bilder etwa in BMP-Dateien liegen oder Texte aus Datenbanken kommen. Als Gewinn bleibt immer die Trennung von Code und Daten.
Zeichenketten übersetzen
Die grundlegende Technik hinter der Software-Internationalisierung ist nicht kompliziert - wenn wir einmal von Feinheiten wie Schreibrichtung oder sprachabhängigen Textlängenunterschieden absehen. Windows und VB bieten einige Möglichkeiten für den Zugriff auf ausgelagerte Landeseigenheiten.
Keine Unterstützung bieten Windows und VB jedoch bei der Identifikation der Landeseigenheiten. Insbesondere für die am häufigsten auftretende Landeseigenheit, die Zeichenketten in unseren Programmen, bieten sie kein Hilfsmittel, um sie automatisch durch Platzhalter zu ersetzen und in eine externe Ressource auszulagern.
Hier beginnt die Arbeit von Übersetzungswerkzeugen wie LanguagePartner (Abbildung 2, www.zoschke.com) und VB Language Manager Pro (Abbildung 3, www.whippleware.com).
.gif "Bild02")
Abbildung 2: Der LanguagePartner von Zoschke Data. Übersetzungen für Schaltflächenbeschriftungen, Labels oder Code-Strings in verschiedene Sprachen können nebeneinander verwaltet werden.
.gif "Bild03")
Abbildung 3: VB Language Manager Pro (VBLM) von WhippleWare, USA . Eine Stärke des VBLM ist die Möglichkeit, Strings über reguläre Ausdrücke und Zuweisungen an bestimmte Variablen zu selektieren.
Diese Tools arbeiten mit dem VB-Quelltext einer Anwendung, suchen alle Zeichenketten aus Code und Formulardefinitionen heraus und bieten sie zur Übersetzung an.
Mit den übersetzten Zeichenketten kann anschließend auf zwei Weisen verfahren werden:
Die Übersetzungsprogramme pflegen die neuen Zeichenketten in Kopien der Quelldateien ein, d.h. sie "übersetzen" den Sourcecode direkt. Man muss ihn also für jede Sprache neu kompilieren.
Die Originalzeichenketten werden durch Platzhalter ersetzt, die die übersetzten Strings aus einer externen Ressource zur Laufzeit nachladen. Der Code verändert sich dadurch erheblich, kann dafür aber zur Laufzeit zwischen Sprachen wechseln.
Im Grunde machen die Übersetzungshilfen also nichts anderes, als wir selbst tun würden. Aber sie erleichtern uns die Arbeit der Identifikation, Extraktion und Übersetzung der Zeichenketten.
Die detaillierte Arbeitsweise der Tools ist den jeweiligen Dokumentationen zu entnehmen. Demoversionen sind im Internet unter den angegebenen Adressen verfügbar.
Das Problem zusammengesetzter Zeichenketten
Mit den Übersetzungshilfen lässt sich eine Anwendung viel einfacher internationalisieren, besonders da sie Zeichenketten nicht nur aus dem Code, sondern auch aus den Formulardefinitionen heraussuchen.
Schwierig wird es für sie jedoch, wenn ein Text sich auf mehrere Zeichenketten verteilt:
MsgBox "Es wurden " & n & " Adressen gefunden.", vbInformation
Ein Übersetzungstool würde aus diesem Beispiel zwei Zeichenketten extrahieren: "Es wurden" und " Adressen gefunden." Beide bietet es dann getrennt zur Übersetzung an, obwohl es sich eigentlich um eine einzige Zeichenkette handelt (z.B. "Es wurden 10 Adressen gefunden"). Wir mussten sie im Code jedoch auseinanderreißen, weil sie einen variablen Teil, einen Parameter, enthält.
Das Problem solcher zusammengesetzter Zeichenketten wächst mit der Anzahl ihrer Teile. Je mehr Parameter eingeflochten werden sollen, desto weiter auseinandergezogen erscheint das Ganze im Übersetzungswerkzeug.
Beim LanguagePartner von Zoschke Data kann man mehrere Zeichenketten als zusammengehörig markieren (s. umrandeten Bereich in Abbildung 2, "Vielen Dank..." bis "verschickt."). Das erhöht zwar die Übersichtlichkeit, löst jedoch nicht das Problem.
Deutlich wird dies bei zusammengesetzten Zeichenketten, deren Teile bei der Übersetzung in eine andere Sprache die Position wechseln oder entfallen:
MsgBox "Es wurden " & n & " Adressen gefunden"
wird zu
MsgBox n & " addresses found"
Es gibt viele Gründe, warum sich die Position ändern kann: Zielsprache, Höflichkeitsebene, Textlänge usw. Für diese Fälle bieten die Übersetzungswerkzeuge keine Hilfe, weil bei ihnen die Reihenfolge der Parameter und der Zeichenkettenglieder unveränderlich ist.
Parametrierbare Zeichenketten: die C-Funktion sprintf
Das Problem zusammengesetzter Zeichenketten ist nicht neu. Schon die "alte" Standardbibliothek der Sprache C bietet ein simple Lösung: parametrierbare Zeichenketten. Statt Zeichenketten auseinanderzureißen, um dazwischen die Parameter zu platzieren, lässt man die Zeichenkette zusammen und fügt Platzhalter für die Parameter ein. Aus
"Es wurden " & n & " Adressen gefunden"
wird
"Es wurden %d Adressen gefunden"
"%d" ist der Platzhalter für eine Integer-Zahl. Natürlich müssen diese Platzhalter interpretiert und ersetzt werden. Das geschieht z.B. durch die Funktion sprintf:
sprintf(buffer, "Es wurden %d Adressen gefunden", n);
sprintf erwartet als zweites Argument einen parametrierten String, dem so viele weitere Argumente folgen, wie Platzhalter darin vorkommen (im vorstehenden Beispiel nur einer: %d). Das Ergebnis der Ersetzung aller Platzhalter in der Zeichenkette legt die Funktion im ersten Parameter (buffer), einem Zeichenkettenpuffer, ab. Die Definition von sprintf lautet:
int sprintf(char *buffer, const char *format [, argument] ...);
Dem format-String, d.h. dem String, der Platzhalter enthält, können beliebig viele Werte für die Platzhalter folgen. (Die Syntax für die Platzhalter im format-String ist umfangreich und recht C-spezifisch. Bei Interesse kann sie in der Visual Studio C++-Funktionsreferenz nachgeschlagen werden.)
Mit einer Funktion wie sprintf könnte man das Problem zusammengesetzter Zeichenketten an der Wurzel packen: Zusammengesetzte Zeichenketten wären in VB-Programmen einfach nicht mehr notwendig. Stattdessen könnten wir einen parametrierten String verwenden, der auch im Übersetzungsprogramm als eine Zeichenkette inkl. ihrer Parameter verwaltet würde.
sprintf mit VB nachempfinden
Die sprintf-Funktion böte uns VB-Programmierern zweierlei Nutzen:
Unsere Programme ließen sich leichter übersetzen.
Wir könnten "Darstellung" - d.h. die konkrete Formulierung einer Zeichenkette - und Daten strikter trennen.
Leider ist der Zugriff auf die sprintf-Funktion von C aus VB heraus jedoch nicht möglich. Wir müssen die Funktion selbst programmieren. Die Definition dafür sieht so aus:
Function sprintf(ByVal message As String, ParamArray values() As Variant) As String
Der erste Parameter ist die parametrierte Zeichenkette, der beliebig viele Parameterwerte folgen. Da VB Strings als Funktionsresultate zurückliefern kann, entfällt das buffer-Argument der Originaldefinition.
Das Projekt bpTranslationPartner.vbp auf der Heft-CD realisiert diese Funktion als Klassenmethode einer GlobalMultiuse-Klasse. Dadurch steht die Funktion ohne explizite Erzeugung eines Objekts im Code bereit, sobald eine Referenz auf die Komponente gesetzt wird. (Alternativ ist die Implementation in einem BAS-Modul denkbar. Das würde die Funktionalität aber nicht wirklich kapseln, sondern alle Abhängigkeiten offen legen. Vgl. stringfunctions.bas auf der Heft-CD.)
Die Benutzung der sprintf-Methode ist sehr einfach:
MsgBox sprintf("Von [*] Entwicklern arbeiten [0.00]% mit VB.", n, p)
Anders als im Original stehen die Platzhalter für die Zeichenkettenparameter in eckigen Klammern. Das geschieht aus zwei Gründen:
Da VB-Programmierer in der Regel nicht mit der C sprintf-Platzhaltersyntax vertraut sind, erspart ihnen das Umstellungsschwierigkeiten.
Viele Optionen der Platzhaltersyntax existieren in C, weil dort Formatierungsfunktionen fehlen. VB bietet jedoch mit der Format-Funktion viele Möglichkeiten, die auch über die Platzhalter ansprechbar sein sollen.
Sonderzeichen
Die einfachsten Platzhalter im message-Parameter von sprintf sind die für Sonderzeichen (s. Tabelle 1).
debug.print sprintf("Peter Mustermann\nIsestr. 3\n12345 Musterhausen")
Mit den Sonderzeichenplatzhaltern können wir vermeiden, einen String auseinanderzureißen, nur um Teile davon durch Sonderzeichen zu trennen. Das obige Beispiel müssten wir sonst traditionell wie folgt formulieren:
debug.print "Peter Mustermann" debug.print "Isestr. 3" debug.print "12345 Musterhausen"
Die Form der Sonderzeichenplatzhalter ist den C-Funktionsbibliotheken entnommen, die eine sehr kompakte Syntax definiert: "\" gefolgt von einem Buchstaben.
Sonderzeichenplatzhalter |
Zeichen, daseingefügtwird |
\t |
Tabulator: vbTab |
\n |
eine Carriage-Return Line Feed (CRLF) Kombination: vbCRLF |
\r |
Carriage-Return: vbCR |
\\ |
\ |
\[ |
[ |
Tabelle 1: Sonderzeichenplatzhalter erlauben uns, in Zeichenketten Sonderzeichen einzufügen, ohne sie auseinanderzureißen. Die Syntax der Platzhalter sowie einige Platzhalter selbst sind den Konventionen der C-Funktionsbibliothek entnommen.
Platzhalter
Platzhalter für Parameter müssen in eckigen Klammern stehen. Als Platzhalter dient ein Formatstring für die VB Format-Funktion (s. Tabelle 2):
debug.print sprintf("Es ist [hh:mm] Uhr am [short date]", time, date)
Der Formatstring richtet sich nach dem Parameter, der dem Platzhalter entspricht. Platzhalter und Parameter müssen in derselben Reihenfolge stehen!
Soll der Parameter nicht gezielt formatiert werden, können wir statt eines Formatstrings ein "*" einsetzen:
debug.print sprintf("Es ist [*] Uhr", time)
Das hat den gleichen Effekt wie:
debug.print "Es ist " & time & " Uhr"
VB entscheidet in diesem Fall selbst, wie der Parameter zu formatieren ist.
Für den Fall, dass ein Parameter übersprungen werden soll, kann ein leerer Platzhalter eingesetzt werden:
debug.print sprintf("[]Heute ist der [short date]", time, date)
Zum Platzhalter [] gehört der Parameter time; da jedoch ein Formatstring fehlt, wird der Parameter nicht eingesetzt. Der nächste Platzhalter [short date] macht weiter mit seinem Parameter date.
Wir können darüber hinaus aber auch die Zuordnung von Platzhalter zu Parameter beliebig bestimmen:
debug.print sprintf("Es ist [2:hh:mm] Uhr am [1:short date]", date, time)
Das Ergebnis zeigt Uhrzeit und Datum in der richtigen Reihenfolge:
Es ist 14:45 Uhr am 12.05.99
Wenn der Formatstring mit einer Ziffer, gefolgt von einem Doppelpunkt, beginnt, interpretiert sprintf dies als Parameterindex und greift auf das entsprechende Argument zu. Die Indizes der Argumente liegen im Bereich von 1 bis 9.
Leere Platzhalter und indizierte Platzhalter machen es einfach, während einer Übersetzung die Daten beliebig in der Zeichenkette zu platzieren. Während die Reihenfolge der Parameter im Code festgeschrieben ist, kann ihr Nutzungsort variieren.
Platzhalter und Beispiele |
Erläuterung |
[] |
überspringt den zugehörigen Parameter von sprintf |
[*] |
fügt den Parameter ohne spezielle Formatierung ein |
[formatstring] [short date] [###,##0.00] [standard] |
fügt den Parameter über die Funktion Format mit formatstringformatiert ein: Format(parameter, formatstring) formatstring und Parametertyp müssen zueinander passen! sprintf benutzt die VB-Funktion Format für die Formatierung. |
[n:formatstring] <format size=1>[3:*] [2:short date]</font> |
fügt den Parameter mit Index n (1..9) ein |
[=VBScript-Ausdruck] [=sqr(7)] [2:=value + 10] |
berechnet den VBScript-Ausdruck und fügt das Ergebnis ein |
Tabelle 2: Platzhalter für Parameter müssen in [] eingeschlossen sein. Als Platzhalter können alle für die VB-Funktion Format zulässigen Formatstrings benutzt werden.
VBScript-Code im Platzhalter
Bis hierhin hat unsere sprintf-Funktion die Leistungsfähigkeit des C-Originals erreicht. Mit ein wenig mehr Aufwand kann sie allerdings weit darüber hinaus gehen. Wenn wir das Microsoft Scripting Control (MSC) zum Einsatz bringen, können wir neben Formatstrings auch Scriptsprachenausdrücke in Platzhaltern interpretieren.
Wir könnten z.B. bei der Übersetzung entscheiden, dass wir nicht nur den Text übersetzen, sondern auch den Parameterwert anders nutzen:
sprintf("Die Dateigröße beträgt [###,##0.0] Bytes", nBytes)
Die Übersetzung würde statt der Dateigröße in Bytes den Wert in KB ausgeben:
sprintf("File size: [=formatNumber(value/1024,1)] KB", nBytes)
Als Scriptsprache benutzt sprintf VBScript. Neben deren Funktionalität stehen aber auch noch einige Werte zur Verfügung, die sich auf die sprintf-Parameter beziehen (s. Tabelle 3):
sprintf("Die Summe ist: [=value(1)+value(2)]", wert1, wert2)
sprintf-Zusatzfunktionalität in |
Erläuterung |
Value |
Wert des zum Platzhalter gehörenden Parameters |
Value(Index) |
Wert des Parameters am angegebenen Index (1..n) |
Count |
Anzahl der Parameter im sprintf-Aufruf |
Index |
Index des zum Platzhalter gehörenden Parameters (1..n) |
Tabelle 3: sprintf-Platzhalter können auch VBScript-Ausdrücke enthalten, deren Ergebnis in die Zeichenkette eingefügt wird. Innerhalb dieser Ausdrücke können wir mit einigen reservierten Worten auf die Parameterliste des sprintf-Aufrufs zugreifen.
Zusammenfassung
Zusammengesetzte Zeichenketten machen die Übersetzung von Software schwerer als nötig. Auch Übersetzungswerkzeuge helfen dabei nicht weiter. Am besten vermeiden wir daher zusammengesetzte Zeichenketten und ersetzen sie durch parametrierte Strings. Den Aufwand zur Interpretation der Platzhalter und das Einsetzen der Parameter nimmt uns die Funktion sprintf ab. Inhalt und Daten sind damit strikt getrennt, so dass die Übersetzung leicht fällt.
Für Fragen und Anregungen erreichen Sie Ralf Westphal per E-Mail an ralfw@basicpro.de