Ticket #3829: localekit_base.patch

build/jam/HaikuImage

@@ -47 +47 @@
     uptime urlwrapper useradd uudecode uuencode
     vdir version vim vmstat waitfor wc wget whoami xargs xres yes
     zdiff zforce zgrep zip zipcloak <bin>zipgrep zipnote zipsplit zmore znew
+    collectcatkeys linkcatkeys dumpcatalog genprops
 ;
 
 SYSTEM_APPS = AboutSystem ActivityMonitor CharacterMap CodyCam DeskCalc DiskProbe
@@ -56 +57 @@
     StyledEdit Terminal TextSearch TV Workspaces
 ;
 SYSTEM_PREFERENCES = Appearance Backgrounds CPUFrequency DataTranslations E-mail
-    FileTypes Fonts Keyboard Keymap Media Menu Mouse Network Printers Screen
+    FileTypes Fonts Keyboard Keymap Locale Media Menu Mouse Network Printers Screen
     ScreenSaver Sounds Time Touchpad <preference>Tracker VirtualMemory
 ;
 SYSTEM_DEMOS = BSnow Chart Clock Cortex FontDemo
@@ -68 +69 @@
     libmail.so libtextencoding.so libz.so libfreetype.so libpng.so libmidi.so
     libmidi2.so libdevice.so libgame.so libscreensaver.so <revisioned>libroot.so
     libGL.so libfluidsynth.so liblpsolve55.so liblinprog.so libalm.so
-    libilmimf.so libiconv.so
+    libilmimf.so libiconv.so liblocale.so
 ;
 SYSTEM_SERVERS = registrar debug_server syslog_daemon media_server
     net_server media_addon_server input_server app_server fake_app_server
@@ -273 +274 @@
 # TODO/NOTE: Cannot use $(SYSTEM_PREFERENCES) here since there is
 # "<preferences>Tracker"...
 DESKBAR_PREFERENCES = Appearance Backgrounds CPUFrequency DataTranslations
-    E-mail FileTypes Fonts Keyboard Keymap Media Menu Mouse Network Printers
+    E-mail FileTypes Fonts Keyboard Keymap Locale Media Menu Mouse Network Printers
     Screen ScreenSaver Sounds Time Touchpad Tracker VirtualMemory
 ;
 for linkTarget in $(DESKBAR_PREFERENCES) {
@@ -328 +329 @@
     = [ FDirName $(HAIKU_TOP) src apps mail ] ;
 AddFilesToHaikuImage system etc word_dictionary : $(spellFiles) ;
 
+# Locale kit system-wide catalogs
+local catalogs = deutsch français ;
+catalogs = $(catalogs:G=catalogs).language ;
+SEARCH on $(catalogs)
+    = [ FDirName $(HAIKU_TOP) data etc locale languages ] ;
+AddFilesToHaikuImage system etc locale languages : $(catalogs) ;
+
 local etcFiles = bash_completion inputrc profile teapot.data ;
 etcFiles = $(etcFiles:G=etc) ;
 SEARCH on $(etcFiles) = [ FDirName $(HAIKU_TOP) data etc ] ;

src/preferences/locale/Locale.cpp

@@ +1 @@
+/*
+ * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include "Locale.h"
+#include "LocaleWindow.h"
+
+#include <Application.h>
+#include <Alert.h>
+#include <TextView.h>
+#include <FindDirectory.h>
+#include <File.h>
+#include <Path.h>
+
+#include <stdio.h>
+#include <string.h>
+
+
+const char *kSignature = "application/x-vnd.Haiku-Locale";
+
+static const uint32 kMsgLocaleSettings = 'LCst';
+
+
+class Settings {
+    public:
+        Settings();
+        ~Settings();
+
+        const BMessage &Message() const { return fMessage; }
+        void UpdateFrom(BMessage *message);
+
+    private:
+        status_t Open(BFile *file, int32 mode);
+
+        BMessage    fMessage;
+        bool        fUpdated;
+};
+
+
+class Locale : public BApplication {
+    public:
+        Locale();
+        virtual ~Locale();
+
+        virtual void ReadyToRun();
+        virtual void MessageReceived(BMessage *message);
+
+        virtual void AboutRequested();
+        virtual bool QuitRequested();
+
+    private:
+        Settings    fSettings;
+        BWindow     *fOpenWindow;
+        BRect       fWindowFrame;
+};
+
+
+//-----------------
+
+
+Settings::Settings()
+    :
+    fMessage(kMsgLocaleSettings),
+    fUpdated(false)
+{
+    BFile file;
+    if (Open(&file, B_READ_ONLY) != B_OK
+        || fMessage.Unflatten(&file) != B_OK) {
+        // set default prefs
+        fMessage.AddRect("window_frame", BRect(50, 50, 550, 500));
+        return;
+    }
+}
+
+
+Settings::~Settings()
+{
+    // only save the settings if something has changed
+    if (!fUpdated)
+        return;
+
+    BFile file;
+    if (Open(&file, B_CREATE_FILE | B_WRITE_ONLY) != B_OK)
+        return;
+
+    fMessage.Flatten(&file);
+}
+
+
+status_t 
+Settings::Open(BFile *file, int32 mode)
+{
+    BPath path;
+    if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
+        return B_ERROR;
+
+    path.Append("Locale settings");
+
+    return file->SetTo(path.Path(), mode);
+}
+
+
+void 
+Settings::UpdateFrom(BMessage *message)
+{
+    BRect frame;
+    if (message->FindRect("window_frame", &frame) == B_OK)
+        fMessage.ReplaceRect("window_frame", frame);
+
+    fUpdated = true;
+}
+
+
+//  #pragma mark -
+
+
+Locale::Locale()
+    : BApplication(kSignature)
+{
+    fWindowFrame = fSettings.Message().FindRect("window_frame");
+
+    BWindow* window = new LocaleWindow(fWindowFrame);
+    window->Show();
+}
+
+
+Locale::~Locale()
+{
+}
+
+
+void 
+Locale::ReadyToRun()
+{
+    // are there already windows open?
+    if (CountWindows() != 1)
+        return;
+
+    // if not, ask the user to open a file
+    PostMessage(kMsgOpenOpenWindow);
+}
+
+
+void 
+Locale::MessageReceived(BMessage *message)
+{
+    switch (message->what) {
+        case kMsgSettingsChanged:
+            fSettings.UpdateFrom(message);
+            break;
+
+        default:
+            BApplication::MessageReceived(message);
+            break;
+    }
+}
+
+
+void
+Locale::AboutRequested()
+{
+    BAlert *alert = new BAlert("about", "Locale\n"
+        "\twritten by Axel Dörfler\n"
+        "\tCopyright 2005, Haiku.\n\n", "Ok");
+    BTextView *view = alert->TextView();
+    BFont font;
+
+    view->SetStylable(true);
+
+    view->GetFont(&font);
+    font.SetSize(18);
+    font.SetFace(B_BOLD_FACE);          
+    view->SetFontAndColor(0, 7, &font);
+
+    alert->Go();
+}
+
+
+bool 
+Locale::QuitRequested()
+{
+    return true;
+}
+
+
+//  #pragma mark -
+
+
+int 
+main(int argc, char **argv)
+{
+    Locale app;
+
+    app.Run();
+    return 0;
+}

src/preferences/locale/Locale.h

@@ +1 @@
+/*
+ * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef LOCALE_H
+#define LOCALE_H
+
+
+#include <SupportDefs.h>
+
+
+extern const char *kSignature;
+
+static const uint32 kMsgOpenFilePanel = 'opFp';
+static const uint32 kMsgOpenOpenWindow = 'opOw';
+static const uint32 kMsgOpenWindowClosed = 'clOw';
+static const uint32 kMsgWindowClosed = 'WiCl';
+static const uint32 kMsgSettingsChanged = 'SeCh';
+
+static const uint32 kMsgOpenFindWindow = 'OpFw';
+static const uint32 kMsgFindWindowClosed = 'clFw';
+static const uint32 kMsgFindTarget = 'FTgt';
+static const uint32 kMsgFind = 'find';
+
+#endif  /* LOCALE_H */

src/preferences/locale/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src preferences locale ;
+
+AddResources Locale : Locale.rsrc ;
+
+Preference Locale :
+    Locale.cpp
+    LocaleWindow.cpp
+    : be liblocale.so ;

src/preferences/locale/LocaleWindow.cpp

@@ +1 @@
+/*
+ * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include "Locale.h"
+#include "LocaleWindow.h"
+
+#include <Application.h>
+#include <Screen.h>
+#include <TabView.h>
+#include <ScrollView.h>
+#include <ListView.h>
+#include <Button.h>
+
+
+const static uint32 kMsgSelectLanguage = 'slng';
+const static uint32 kMsgDefaults = 'dflt';
+const static uint32 kMsgRevert = 'revt';
+
+
+LocaleWindow::LocaleWindow(BRect rect)
+    : BWindow(rect, "Locale", B_TITLED_WINDOW,
+        B_NOT_RESIZABLE | B_NOT_ZOOMABLE | B_ASYNCHRONOUS_CONTROLS)
+{
+    rect = Bounds();
+    BView *view = new BView(rect, "view", B_FOLLOW_ALL, 0);
+    view->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
+    AddChild(view);
+
+    BButton *button = new BButton(rect, "defaults", "Defaults",
+        new BMessage(kMsgDefaults), B_FOLLOW_NONE);
+    button->ResizeToPreferred();
+    button->MoveTo(10, rect.bottom - 10 - button->Bounds().Height());
+    view->AddChild(button);
+
+    fRevertButton = new BButton(rect, "revert", "Revert",
+        new BMessage(kMsgRevert), B_FOLLOW_NONE);
+    fRevertButton->ResizeToPreferred();
+    fRevertButton->MoveTo(20 + button->Bounds().Width(), button->Frame().top);
+    fRevertButton->SetEnabled(false);
+    view->AddChild(fRevertButton);
+
+    rect.InsetBy(10, 10);
+    rect.bottom -= 10 + button->Bounds().Height();
+    BTabView *tabView = new BTabView(rect, "tabview");
+
+    rect = tabView->ContainerView()->Bounds();
+    rect.InsetBy(2, 2);
+    BView *tab = new BView(rect, "Language", B_FOLLOW_NONE, B_WILL_DRAW);
+    tab->SetViewColor(tabView->ViewColor());
+    tabView->AddTab(tab);
+
+    {
+        BRect frame = rect;
+        frame.InsetBy(12, 12);
+        frame.right = 100 + B_V_SCROLL_BAR_WIDTH;
+        frame.bottom = 150;
+
+        BListView *listView = new BListView(frame, "preferred", B_SINGLE_SELECTION_LIST, 
+            B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
+        listView->SetSelectionMessage(new BMessage(kMsgSelectLanguage));
+
+        BScrollView *scrollView = new BScrollView("scroller", listView, 
+            B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP, 0, false, true, B_FANCY_BORDER);
+        tab->AddChild(scrollView);
+    }
+
+    tab = new BView(rect, "Country", B_FOLLOW_NONE, B_WILL_DRAW);
+    tab->SetViewColor(tabView->ViewColor());
+    tabView->AddTab(tab);
+
+    tab = new BView(rect, "Keyboard", B_FOLLOW_NONE, B_WILL_DRAW);
+    tab->SetViewColor(tabView->ViewColor());
+    tabView->AddTab(tab);
+
+    view->AddChild(tabView);
+
+    // check if the window is on screen
+
+    rect = BScreen().Frame();
+    rect.right -= 20;
+    rect.bottom -= 20;
+
+    BPoint position = Frame().LeftTop();
+    if (!rect.Contains(position)) {
+        // center window on screen as it doesn't fit on the saved position
+        position.x = (rect.Width() - Bounds().Width()) / 2;
+        position.y = (rect.Height() - Bounds().Height()) / 2;
+    }
+    MoveTo(position);
+}
+
+
+bool
+LocaleWindow::QuitRequested()
+{
+    BMessage update(kMsgSettingsChanged);
+    update.AddRect("window_frame", Frame());
+    be_app_messenger.SendMessage(&update);
+
+    be_app_messenger.SendMessage(B_QUIT_REQUESTED);
+    return true;
+}
+
+
+void
+LocaleWindow::MessageReceived(BMessage *message)
+{
+    switch (message->what) {
+        case kMsgDefaults:
+            // reset default settings
+            break;
+
+        case kMsgRevert:
+            // revert to last settings
+            break;
+
+        default:
+            BWindow::MessageReceived(message);
+            break;
+    }
+}
+

src/preferences/locale/LocaleWindow.h

@@ +1 @@
+/*
+ * Copyright 2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef LOCALE_WINDOW_H
+#define LOCALE_WINDOW_H
+
+
+#include <Window.h>
+
+class BButton;
+
+
+class LocaleWindow : public BWindow {
+    public:
+        LocaleWindow(BRect rect);
+
+        virtual bool QuitRequested();
+        virtual void MessageReceived(BMessage *message);
+
+    private:
+        BButton*    fRevertButton;
+};
+
+#endif  /* LOCALE_WINDOW_H */

src/preferences/Jamfile

@@ -12 +12 @@
 SubInclude HAIKU_TOP src preferences joysticks ;
 SubInclude HAIKU_TOP src preferences keyboard ;
 SubInclude HAIKU_TOP src preferences keymap ;
+SubInclude HAIKU_TOP src preferences locale ;
 SubInclude HAIKU_TOP src preferences mail ;
 SubInclude HAIKU_TOP src preferences media ;
 SubInclude HAIKU_TOP src preferences menu ;

src/bin/locale/RegExp.h

@@ +1 @@
+/*
+Open Tracker License
+
+Terms and Conditions
+
+Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice applies to all licensees
+and shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Be Incorporated shall not be
+used in advertising or otherwise to promote the sale, use or other dealings in
+this Software without prior written authorization from Be Incorporated.
+
+Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
+of Be Incorporated in the United States and other countries. Other brand product
+names are registered trademarks or trademarks of their respective holders.
+All rights reserved.
+*/
+
+
+// This code is based on regexp.c, v.1.3 by Henry Spencer:
+
+// @(#)regexp.c 1.3 of 18 April 87
+//
+//  Copyright (c) 1986 by University of Toronto.
+//  Written by Henry Spencer.  Not derived from licensed software.
+//
+//  Permission is granted to anyone to use this software for any
+//  purpose on any computer system, and to redistribute it freely,
+//  subject to the following restrictions:
+//
+//  1. The author is not responsible for the consequences of use of
+//      this software, no matter how awful, even if they arise
+//      from defects in it.
+//
+//  2. The origin of this software must not be misrepresented, either
+//      by explicit claim or by omission.
+//
+//  3. Altered versions must be plainly marked as such, and must not
+//      be misrepresented as being the original software.
+//
+// Beware that some of this code is subtly aware of the way operator
+// precedence is structured in regular expressions.  Serious changes in
+// regular-expression syntax might require a total rethink.
+//
+
+// ALTERED VERSION: Adapted to ANSI C and C++ for the OpenTracker
+// project (www.opentracker.org), Jul 11, 2000.
+
+#ifndef _REG_EXP_H
+#define _REG_EXP_H
+
+#include <String.h>
+
+namespace BPrivate {
+
+enum {
+    REGEXP_UNMATCHED_PARENTHESIS = B_ERRORS_END,
+    REGEXP_TOO_BIG,
+    REGEXP_TOO_MANY_PARENTHESIS,
+    REGEXP_JUNK_ON_END,
+    REGEXP_STAR_PLUS_OPERAND_EMPTY,
+    REGEXP_NESTED_STAR_QUESTION_PLUS,
+    REGEXP_INVALID_BRACKET_RANGE,
+    REGEXP_UNMATCHED_BRACKET,
+    REGEXP_INTERNAL_ERROR,
+    REGEXP_QUESTION_PLUS_STAR_FOLLOWS_NOTHING,
+    REGEXP_TRAILING_BACKSLASH,
+    REGEXP_CORRUPTED_PROGRAM,
+    REGEXP_MEMORY_CORRUPTION,
+    REGEXP_CORRUPTED_POINTERS,
+    REGEXP_CORRUPTED_OPCODE
+};
+
+const int32 kSubExpressionMax = 10;
+
+struct regexp {
+    const char *startp[kSubExpressionMax];
+    const char *endp[kSubExpressionMax];
+    char regstart;      /* Internal use only. See RegExp.cpp for details. */
+    char reganch;       /* Internal use only. */
+    const char *regmust;/* Internal use only. */
+    int regmlen;        /* Internal use only. */
+    char program[1];    /* Unwarranted chumminess with compiler. */
+};
+
+class RegExp {
+
+public:
+    RegExp();
+    RegExp(const char *);
+    RegExp(const BString &);
+    ~RegExp();
+    
+    status_t InitCheck() const;
+    
+    status_t SetTo(const char*);
+    status_t SetTo(const BString &);
+    
+    bool Matches(const char *string) const;
+    bool Matches(const BString &) const;
+
+    int32 RunMatcher(regexp *, const char *) const;
+    regexp *Compile(const char *);
+    regexp *Expression() const;
+    const char *ErrorString() const;
+
+#ifdef DEBUG
+    void Dump();
+#endif
+
+private:
+
+    void SetError(status_t error) const;
+
+    // Working functions for Compile():
+    char *Reg(int32, int32 *);
+    char *Branch(int32 *);
+    char *Piece(int32 *);
+    char *Atom(int32 *);
+    char *Node(char);
+    char *Next(char *);
+    const char *Next(const char *) const;
+    void Char(char);
+    void Insert(char, char *);
+    void Tail(char *, char *);
+    void OpTail(char *, char *);
+
+    // Working functions for RunMatcher():
+    int32 Try(regexp *, const char *) const;
+    int32 Match(const char *) const;
+    int32 Repeat(const char *) const;
+
+    // Utility functions:
+#ifdef DEBUG
+    char *Prop(const char *) const;
+    void RegExpError(const char *) const;
+#endif
+    inline int32 UCharAt(const char *p) const;
+    inline char *Operand(char* p) const;
+    inline const char *Operand(const char* p) const;
+    inline bool IsMult(char c) const;
+
+// --------- Variables -------------
+
+    mutable status_t fError;
+    regexp *fRegExp;
+
+    // Work variables for Compile().
+
+    const char *fInputScanPointer;
+    int32 fParenthesisCount;        
+    char fDummy;
+    char *fCodeEmitPointer;     // &fDummy = don't.
+    long fCodeSize;     
+
+    // Work variables for RunMatcher().
+
+    mutable const char *fStringInputPointer;
+    mutable const char *fRegBol;    // Beginning of input, for ^ check.
+    mutable const char **fStartPArrayPointer;
+    mutable const char **fEndPArrayPointer;
+};
+
+} // namespace BPrivate
+
+using namespace BPrivate;
+
+#endif

src/bin/locale/dumpcatalog.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Oliver Tappe, zooey@hirschkaefer.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+#include <cstdio>
+#include <cstdlib>
+
+#include <Catalog.h>
+#include <DefaultCatalog.h>
+#include <File.h>
+#include <String.h>
+
+void
+usage() 
+{
+    fprintf(stderr, "usage: dumpcatalog <catalogFiles>\n");
+    exit(-1);
+}
+
+
+int
+main(int argc, char **argv)
+{
+    const char *inputFile = NULL;
+    status_t res;
+    if (!argv[1] || !strcmp(argv[1], "--help")) {
+        usage();
+    } else {
+        inputFile = argv[1];
+    }
+    if (!inputFile || !strlen(inputFile))
+        usage();
+    
+    EditableCatalog inputCatalog("Default", "dummy", "dummy");
+    if ((res = inputCatalog.InitCheck()) != B_OK) {
+        fprintf(stderr, "couldn't construct catalog %s - error: %s\n", 
+            inputFile, strerror(res));
+        exit(-1);
+    }
+    if ((res = inputCatalog.ReadFromFile(inputFile)) != B_OK) {
+        fprintf(stderr, "couldn't load input-catalog %s - error: %s\n", 
+            inputFile, strerror(res));
+        exit(-1);
+    }
+    DefaultCatalog* inputCatImpl
+        = dynamic_cast<DefaultCatalog*>(inputCatalog.CatalogAddOn());
+    if (!inputCatImpl) {
+        fprintf(stderr, "couldn't access impl of input-catalog %s\n", 
+            inputFile);
+        exit(-1);
+    }
+    // now walk over all entries in input-catalog and dump them to
+    // stdout
+    DefaultCatalog::CatWalker walker;
+    if ((res = inputCatImpl->GetWalker(&walker)) != B_OK) {
+        fprintf(stderr, "couldn't get walker for input-catalog %s - error: %s\n", 
+            inputFile, strerror(res));
+        exit(-1);
+    }
+    BString str, ctx, cmt;
+    while(!walker.AtEnd()) {
+        const CatKey &key(walker.GetKey());
+        key.GetStringParts(&str, &ctx, &cmt);
+        printf("Hash:\t\t%ld\nKey:\t\t<%s:%s:%s>\nTranslation:\t%s\n-----\n", 
+            key.fHashVal, str.String(), ctx.String(), cmt.String(), 
+            walker.GetValue());
+        walker.Next();
+    }
+    int32 count = inputCatalog.CountItems();
+    if (count)
+        fprintf(stderr, "%ld entr%s dumped\n",  count, (count==1 ? "y": "ies"));
+    else
+        fprintf(stderr, "no entries found\n");
+    return res;
+}

src/bin/locale/linkcatkeys.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Oliver Tappe, zooey@hirschkaefer.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+
+#include <Catalog.h>
+#include <DefaultCatalog.h>
+#include <Entry.h>
+#include <File.h>
+#include <String.h>
+
+void
+usage() 
+{
+    fprintf(stderr,
+        "usage: linkcatkeys [-v] [-t(a|f|r)] [-o <outfile>] [-l <catalogLang>]\n"
+        "                   -s <catalogSig> <catalogFiles>\n"
+        "options:\n"
+        "  -l <catalogLang>\tlanguage of the target-catalog (default is English)\n"
+        "  -o <outfile>\t\texplicitly specifies the name of the output-file\n"
+        "  -s <catalogSig>\tsignature of the target-catalog\n"
+        "  -t(a|f|r)\t\tspecifies target of resulting catalog (-tf is default)\n"
+        "           \t\ta => write catalog as an attribute (to output-file)\n"
+        "           \t\tf => write catalog into the output-file\n"
+        "           \t\tr => write catalog as a resource (to output-file)\n"
+        "  -v\t\t\tbe verbose, show summary\n");
+    exit(-1);
+}
+
+
+int
+main(int argc, char **argv)
+{
+    bool showSummary = false;
+    bool showWarnings = false;
+    vector<const char *> inputFiles;
+    BString outputFile("default.catalog");
+    enum TargetType {
+        TARGET_ATTRIBUTE,
+        TARGET_FILE,
+        TARGET_RESOURCE
+    };
+    TargetType outputTarget = TARGET_FILE;
+    const char *catalogSig = NULL;
+    const char *catalogLang = "English";
+    status_t res;
+    while ((++argv)[0]) {
+        if (argv[0][0] == '-' && argv[0][1] != '-') {
+            char *arg = argv[0] + 1;
+            char c;
+            while ((c = *arg++) != '\0') {
+                if (c == 's')
+                    catalogSig = (++argv)[0];
+                else if (c == 'v')
+                    showSummary = true;
+                else if (c == 'w')
+                    showWarnings = true;
+                else if (c == 'o') {
+                    outputFile = (++argv)[0];
+                    break;
+                }
+                else if (c == 't') {
+                    switch(*arg) {
+                        case 'a': outputTarget = TARGET_ATTRIBUTE; break;
+                        case 'f': outputTarget = TARGET_FILE; break;
+                        case 'r': outputTarget = TARGET_RESOURCE; break;
+                        default: usage();
+                    }
+                }
+            }
+        } else if (!strcmp(argv[0], "--help")) {
+            usage();
+        } else {
+            inputFiles.push_back(argv[0]);
+        }
+    }
+    if (inputFiles.empty() || !catalogSig || !outputFile.Length())
+        usage();
+    
+    EditableCatalog targetCatalog("Default", catalogSig, catalogLang);
+    if ((res = targetCatalog.InitCheck()) != B_OK) {
+        fprintf(stderr, "couldn't construct target-catalog %s - error: %s\n", 
+            outputFile.String(), strerror(res));
+        exit(-1);
+    }
+    DefaultCatalog* targetCatImpl
+        = dynamic_cast<DefaultCatalog*>(targetCatalog.CatalogAddOn());
+    if (!targetCatImpl) {
+        fprintf(stderr, "couldn't access impl of target-catalog %s\n", 
+            outputFile.String());
+        exit(-1);
+    }
+
+    uint32 count = inputFiles.size();
+    for( uint32 i=0; i<count; ++i) {
+        EditableCatalog inputCatalog("Default", catalogSig, "native");
+        if ((res = inputCatalog.ReadFromFile(inputFiles[i])) != B_OK) {
+            fprintf(stderr, "couldn't load target-catalog %s - error: %s\n", 
+                inputFiles[i], strerror(res));
+            exit(-1);
+        }
+        DefaultCatalog* inputCatImpl
+            = dynamic_cast<DefaultCatalog*>(inputCatalog.CatalogAddOn());
+        if (!inputCatImpl) {
+            fprintf(stderr, "couldn't access impl of input-catalog %s\n", 
+                inputFiles[i]);
+            exit(-1);
+        }
+        // now walk over all entries in input-catalog and add them to
+        // target catalog, unless they already exist there.
+        // (This could be improved by simply inserting the hashmaps,
+        // but this should be fast enough).
+        DefaultCatalog::CatWalker walker;
+        if ((res = inputCatImpl->GetWalker(&walker)) != B_OK) {
+            fprintf(stderr, "couldn't get walker for input-catalog %s - error: %s\n", 
+                inputFiles[i], strerror(res));
+            exit(-1);
+        }
+        while(!walker.AtEnd()) {
+            const CatKey &key(walker.GetKey());
+            if (!targetCatImpl->GetString(key))
+                targetCatImpl->SetString(key, walker.GetValue());
+            walker.Next();
+        }
+    }
+
+    switch(outputTarget) {
+        case TARGET_ATTRIBUTE: {
+            BEntry entry(outputFile.String());
+            entry_ref eref;
+            entry.GetRef(&eref);
+            res = targetCatalog.WriteToAttribute(&eref);
+            if (res != B_OK) {
+                fprintf(stderr, "couldn't write target-attribute to %s - error: %s\n", 
+                    outputFile.String(), strerror(res));
+                exit(-1);
+            }
+            break;
+        }
+        case TARGET_RESOURCE: {
+            BEntry entry(outputFile.String());
+            entry_ref eref;
+            entry.GetRef(&eref);
+            res = targetCatalog.WriteToResource(&eref);
+            if (res != B_OK) {
+                fprintf(stderr, "couldn't write target-resource to %s - error: %s\n", 
+                    outputFile.String(), strerror(res));
+                exit(-1);
+            }
+        }
+        default: {
+            res = targetCatalog.WriteToFile(outputFile.String());
+            if (res != B_OK) {
+                fprintf(stderr, "couldn't write target-catalog to %s - error: %s\n", 
+                    outputFile.String(), strerror(res));
+                exit(-1);
+            }
+        }
+    }
+    if (showSummary) {
+        int32 count = targetCatalog.CountItems();
+        if (count)
+            fprintf(stderr, "%ld key%s found and written to %s\n",
+                count, (count==1 ? "": "s"), outputFile.String());
+        else
+            fprintf(stderr, "no keys found\n");
+    }
+
+    return res;
+}

src/bin/locale/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src bin locale ;
+
+UseHeaders [ FDirName $(HAIKU_TOP) headers os locale ] : true ;
+
+AddResources collectcatkeys : collectcatkeys.rsrc ;
+Application collectcatkeys : collectcatkeys.cpp RegExp.cpp : be liblocale.so ;
+
+AddResources linkcatkeys : linkcatkeys.rsrc ;
+Application linkcatkeys : linkcatkeys.cpp : be liblocale.so ;
+
+AddResources dumpcatalog ;
+Application dumpcatalog : dumpcatalog.cpp : be liblocale.so ;

src/bin/locale/collectcatkeys.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Oliver Tappe, zooey@hirschkaefer.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+#include <cctype>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+
+#include <Catalog.h>
+using namespace BPrivate;
+#include <Entry.h>
+#include <File.h>
+#include "RegExp.h"
+#include <String.h>
+
+bool showKeys = false;
+bool showSummary = false;
+bool showWarnings = false;
+const char *inputFile = NULL;
+BString outputFile;
+const char *catalogSig = NULL;
+const char *catalogLang = "English";
+BString rxString("be_catalog\\s*->\\s*GetString\\s*");
+
+
+BString str, ctx, cmt;
+bool haveID;
+int32 id;
+
+
+EditableCatalog *catalog = NULL;
+
+
+void
+usage() 
+{
+    fprintf(stderr,
+        "usage: collectcatkeys [-pvw] [-r <regex>] [-o <outfile>] [-l <catalogLanguage>]\n"
+        "                      -s <catalogSig> <prepCppFile>\n"
+        "options:\n"
+        "  -l <catalogLang>\tlanguage of the target-catalog (default is English)\n"
+        "  -o <outfile>\t\texplicitly specifies the name of the output-file\n"
+        "  -p\t\t\tprint keys as they are found\n"
+        "  -r <regex>\t\tchanges the regex used by the key-scanner to the one given,\n"
+        "      \t\t\tthe default is:   be_catalog\\s*->\\s*GetString\\s*\n"
+        "  -s <catalogSig>\tsignature of the target-catalog\n"
+        "  -v\t\t\tbe verbose, show summary\n"
+        "  -w\t\t\tshow warnings about catalog-accesses that couldn't be resolved completely\n");
+    exit(-1);
+}
+
+
+bool
+fetchStr(const char *&in, BString &str, bool lookForID)
+{
+    int parLevel = 0;
+    while(isspace(*in) || *in == '(') {
+        if (*in == '(')
+            parLevel++;
+        in++;
+    }
+    if (*in == '"') {
+        in++;
+        bool quoted = false;
+        while (*in != '"' || quoted) {
+            if (quoted) {
+                if (*in == 'n')
+                    str.Append("\n",1);
+                else if (*in == 't')
+                    str.Append("\t",1);
+                else if (*in == '"')
+                    str.Append("\"",1);
+                else
+                    // dump quote from unknown quoting-sequence:
+                    str.Append(in,1);
+                quoted = false;
+            } else {
+                quoted = (*in == '\\');
+                if (!quoted)
+                    str.Append(in,1);
+            }
+            in++;
+        }
+        in++;
+    } else if (!memcmp(in, "__null", 6)) {
+        // NULL is preprocessed into __null, which we parse as ""
+        in += 6;
+    } else if (lookForID && (isdigit(*in) || *in == '-' || *in == '+')) {
+        // try to parse an ID (a long):
+        errno = 0;
+        char *next;
+        id = strtol(in, &next, 10);
+        if (id != 0 || errno == 0) {
+            haveID = true;
+            in = next;
+        }
+    } else
+        return false;
+    while(isspace(*in) || *in == ')') {
+        if (*in == ')') {
+            if (!parLevel)
+                return true;
+            parLevel--;
+        }
+        in++;
+    }
+    return true;
+}
+
+
+bool
+fetchKey(const char *&in)
+{
+    str = ctx = cmt = "";
+    haveID = false;
+    // fetch native string or id:
+    if (!fetchStr(in, str, true))
+        return false;
+    if (*in == ',') {
+        in++;
+        // fetch context:
+        if (!fetchStr(in, ctx, false))
+            return false;
+        if (*in == ',') {
+            in++;
+            // fetch comment:
+            if (!fetchStr(in, cmt, false))
+                return false;
+        }
+    }
+    return true;
+}
+
+
+void
+collectAllCatalogKeys(BString& inputStr)
+{
+    RegExp rx;
+    struct regexp *rxprg = rx.Compile(rxString.String());
+    if (rx.InitCheck() != B_OK) {
+        fprintf(stderr, "regex-compilation error %s\n", rx.ErrorString());
+        return;
+    }
+    status_t res;
+    const char *in = inputStr.String();
+    while(rx.RunMatcher(rxprg, in)) {
+        const char *start = rxprg->startp[0];
+        in = rxprg->endp[0];
+        if (fetchKey(in)) {
+            if (haveID) {
+                if (showKeys)
+                    printf("CatKey(%ld)\n", id);
+                res = catalog->SetString(id, "");
+                if (res != B_OK) {
+                    fprintf(stderr, "couldn't add key %ld - error: %s\n", 
+                        id, strerror(res));
+                    exit(-1);
+                }
+            } else {
+                if (showKeys)
+                    printf("CatKey(\"%s\", \"%s\", \"%s\")\n", str.String(), 
+                        ctx.String(), cmt.String());
+                res = catalog->SetString(str.String(), str.String(), ctx.String(), cmt.String());
+                if (res != B_OK) {
+                    fprintf(stderr, "couldn't add key %s,%s,%s - error: %s\n", 
+                        str.String(), ctx.String(), cmt.String(), strerror(res));
+                    exit(-1);
+                }
+            }
+        } else if (showWarnings) {
+            const char *end = strchr(in, ';');
+            BString match;
+            if (end)
+                match.SetTo(start, end-start+1);
+            else
+                // can't determine end of statement, we output next 40 characters
+                match.SetTo(start, 40);
+            fprintf(stderr, "Warning: couldn't resolve catalog-access:\n\t%s\n",
+                match.String());
+        }
+    }
+}
+
+
+int
+main(int argc, char **argv)
+{
+    while ((++argv)[0]) {
+        if (argv[0][0] == '-' && argv[0][1] != '-') {
+            char *arg = argv[0] + 1;
+            char c;
+            while ((c = *arg++) != '\0') {
+                if (c == 'p')
+                    showKeys = true;
+                else if (c == 'l')
+                    catalogLang = (++argv)[0];
+                else if (c == 's')
+                    catalogSig = (++argv)[0];
+                else if (c == 'v')
+                    showSummary = true;
+                else if (c == 'w')
+                    showWarnings = true;
+                else if (c == 'o') {
+                    outputFile = (++argv)[0];
+                    break;
+                }
+                else if (c == 'r') {
+                    rxString = (++argv)[0];
+                    break;
+                }
+            }
+        } else if (!strcmp(argv[0], "--help")) {
+            usage();
+        } else {
+            if (!inputFile)
+                inputFile = argv[0];
+            else
+                usage();
+        }
+    }
+    if (!outputFile.Length() && inputFile) {
+        // generate default output-file from input-file by replacing 
+        // the extension with '.catkeys':
+        outputFile = inputFile;
+        int32 dot = outputFile.FindLast('.');
+        if (dot >= B_OK)
+            outputFile.Truncate(dot);
+        outputFile << ".catkeys";
+    }
+    if (!inputFile || !catalogSig || !outputFile.Length() || !catalogLang)
+        usage();
+    
+    BFile inFile;
+    status_t res = inFile.SetTo(inputFile, B_READ_ONLY);
+    if (res != B_OK) {
+        fprintf(stderr, "unable to open inputfile %s - error: %s\n", inputFile, 
+            strerror(res));
+        exit(-1);
+    }
+    off_t sz;
+    inFile.GetSize(&sz);
+    if (sz > 0) {
+        BString inputStr;
+        char *buf = inputStr.LockBuffer(sz);
+        off_t rsz = inFile.Read(buf, sz);
+        if (rsz < sz) {
+            fprintf(stderr, "couldn't read %Ld bytes from %s (got only %Ld)\n", 
+                sz, inputFile, rsz);
+            exit(-1);
+        }
+        inputStr.UnlockBuffer(rsz);
+        catalog = new EditableCatalog("Default", catalogSig, catalogLang);
+        collectAllCatalogKeys(inputStr);
+        res = catalog->WriteToFile(outputFile.String());
+        if (res != B_OK) {
+            fprintf(stderr, "couldn't write catalog to %s - error: %s\n", 
+                outputFile.String(), strerror(res));
+            exit(-1);
+        }
+        if (showSummary) {
+            int32 count = catalog->CountItems();
+            if (count)
+                fprintf(stderr, "%ld key%s found and written to %s\n",
+                    count, (count==1 ? "": "s"), outputFile.String());
+            else
+                fprintf(stderr, "no keys found\n");
+        }
+        delete catalog;
+    }
+
+//  BEntry inEntry(inputFile);
+//  inEntry.Remove();
+    
+    return res;
+}

src/bin/locale/RegExp.cpp

@@ +1 @@
+/*
+Open Tracker License
+
+Terms and Conditions
+
+Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice applies to all licensees
+and shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Be Incorporated shall not be
+used in advertising or otherwise to promote the sale, use or other dealings in
+this Software without prior written authorization from Be Incorporated.
+
+Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
+of Be Incorporated in the United States and other countries. Other brand product
+names are registered trademarks or trademarks of their respective holders.
+All rights reserved.
+*/
+
+// This code is based on regexp.c, v.1.3 by Henry Spencer:
+
+// @(#)regexp.c 1.3 of 18 April 87
+//
+//  Copyright (c) 1986 by University of Toronto.
+//  Written by Henry Spencer.  Not derived from licensed software.
+//
+//  Permission is granted to anyone to use this software for any
+//  purpose on any computer system, and to redistribute it freely,
+//  subject to the following restrictions:
+//
+//  1. The author is not responsible for the consequences of use of
+//      this software, no matter how awful, even if they arise
+//      from defects in it.
+//
+//  2. The origin of this software must not be misrepresented, either
+//      by explicit claim or by omission.
+//
+//  3. Altered versions must be plainly marked as such, and must not
+//      be misrepresented as being the original software.
+//
+// Beware that some of this code is subtly aware of the way operator
+// precedence is structured in regular expressions.  Serious changes in
+// regular-expression syntax might require a total rethink.
+//
+
+// ALTERED VERSION: Adapted to ANSI C and C++ for the OpenTracker
+// project (www.opentracker.org), Jul 11, 2000.
+
+#include <malloc.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <Errors.h>
+
+#include "RegExp.h"
+
+// The first byte of the regexp internal "program" is actually this magic
+// number; the start node begins in the second byte.
+
+const uint8 kRegExpMagic = 0234;
+
+// The "internal use only" fields in RegExp.h are present to pass info from
+// compile to execute that permits the execute phase to run lots faster on
+// simple cases.  They are:
+//
+// regstart char that must begin a match; '\0' if none obvious
+// reganch  is the match anchored (at beginning-of-line only)?
+// regmust  string (pointer into program) that match must include, or NULL
+// regmlen  length of regmust string
+//
+// Regstart and reganch permit very fast decisions on suitable starting points
+// for a match, cutting down the work a lot.  Regmust permits fast rejection
+// of lines that cannot possibly match.  The regmust tests are costly enough
+// that Compile() supplies a regmust only if the r.e. contains something
+// potentially expensive (at present, the only such thing detected is * or +
+// at the start of the r.e., which can involve a lot of backup).  Regmlen is
+// supplied because the test in RunMatcher() needs it and Compile() is computing
+// it anyway.
+//
+//
+//
+// Structure for regexp "program".  This is essentially a linear encoding
+// of a nondeterministic finite-state machine (aka syntax charts or
+// "railroad normal form" in parsing technology).  Each node is an opcode
+// plus a "next" pointer, possibly plus an operand.  "Next" pointers of
+// all nodes except kRegExpBranch implement concatenation; a "next" pointer with
+// a kRegExpBranch on both ends of it is connecting two alternatives.  (Here we
+// have one of the subtle syntax dependencies:  an individual kRegExpBranch (as
+// opposed to a collection of them) is never concatenated with anything
+// because of operator precedence.)  The operand of some types of node is
+// a literal string; for others, it is a node leading into a sub-FSM.  In
+// particular, the operand of a kRegExpBranch node is the first node of the branch.
+// (NB this is *not* a tree structure:  the tail of the branch connects
+// to the thing following the set of kRegExpBranches.)  The opcodes are:
+//
+
+// definition   number  opnd?   meaning 
+enum {
+    kRegExpEnd = 0,     // no   End of program. 
+    kRegExpBol = 1,     // no   Match "" at beginning of line. 
+    kRegExpEol = 2,     // no   Match "" at end of line. 
+    kRegExpAny = 3,     // no   Match any one character. 
+    kRegExpAnyOf = 4,   // str  Match any character in this string. 
+    kRegExpAnyBut = 5,  // str  Match any character not in this string. 
+    kRegExpBranch = 6,  // node Match this alternative, or the next... 
+    kRegExpBack = 7,    // no   Match "", "next" ptr points backward. 
+    kRegExpExactly = 8, // str  Match this string. 
+    kRegExpNothing = 9, // no   Match empty string. 
+    kRegExpStar = 10,   // node Match this (simple) thing 0 or more times. 
+    kRegExpPlus = 11,   // node Match this (simple) thing 1 or more times. 
+    kRegExpOpen = 20,   // no   Mark this point in input as start of #n. 
+                            //  kRegExpOpen + 1 is number 1, etc. 
+    kRegExpClose = 30   // no   Analogous to kRegExpOpen. 
+};
+
+//
+// Opcode notes:
+//
+// kRegExpBranch    The set of branches constituting a single choice are hooked
+//      together with their "next" pointers, since precedence prevents
+//      anything being concatenated to any individual branch.  The
+//      "next" pointer of the last kRegExpBranch in a choice points to the
+//      thing following the whole choice.  This is also where the
+//      final "next" pointer of each individual branch points; each
+//      branch starts with the operand node of a kRegExpBranch node.
+//
+// kRegExpBack      Normal "next" pointers all implicitly point forward; kRegExpBack
+//      exists to make loop structures possible.
+//
+// kRegExpStar,kRegExpPlus  '?', and complex '*' and '+', are implemented as circular
+//      kRegExpBranch structures using kRegExpBack.  Simple cases (one character
+//      per match) are implemented with kRegExpStar and kRegExpPlus for speed
+//      and to minimize recursive plunges.
+//
+// kRegExpOpen,kRegExpClose ...are numbered at compile time.
+// 
+//
+//
+// A node is one char of opcode followed by two chars of "next" pointer.
+// "Next" pointers are stored as two 8-bit pieces, high order first.  The
+// value is a positive offset from the opcode of the node containing it.
+// An operand, if any, simply follows the node.  (Note that much of the
+// code generation knows about this implicit relationship.)
+//
+// Using two bytes for the "next" pointer is vast overkill for most things,
+// but allows patterns to get big without disasters.
+//
+
+const char *kMeta = "^$.[()|?+*\\";
+const int32 kMaxSize = 32767L;      // Probably could be 65535L.
+
+// Flags to be passed up and down:
+enum {
+    kHasWidth = 01, // Known never to match null string. 
+    kSimple = 02,   // Simple enough to be kRegExpStar/kRegExpPlus operand. 
+    kSPStart = 04,  // Starts with * or +. 
+    kWorst = 0  // Worst case. 
+};
+
+const char *kRegExpErrorStringArray[] = {
+    "Unmatched parenthesis.",
+    "Expression too long.",
+    "Too many parenthesis.",
+    "Junk on end.",
+    "*+? operand may be empty.",
+    "Nested *?+.",
+    "Invalid bracket range.",
+    "Unmatched brackets.",
+    "Internal error.",
+    "?+* follows nothing.",
+    "Trailing \\.",
+    "Corrupted expression.",
+    "Memory corruption.",
+    "Corrupted pointers.",
+    "Corrupted opcode."
+};
+
+#ifdef DEBUG
+int32 regnarrate = 0;
+#endif
+
+RegExp::RegExp()
+    :   fError(B_OK),
+        fRegExp(NULL)
+{
+}
+
+RegExp::RegExp(const char *pattern)
+    :   fError(B_OK),
+        fRegExp(NULL)
+{
+    fRegExp = Compile(pattern);
+}
+
+RegExp::RegExp(const BString &pattern)
+    :   fError(B_OK),
+        fRegExp(NULL)
+{
+    fRegExp = Compile(pattern.String());
+}
+
+RegExp::~RegExp()
+{
+    free(fRegExp);
+}
+
+
+
+status_t
+RegExp::InitCheck() const
+{
+    return fError;
+}
+
+status_t
+RegExp::SetTo(const char *pattern)
+{
+    fError = B_OK;
+    free(fRegExp);
+    fRegExp = Compile(pattern);
+    return fError;
+}
+
+status_t
+RegExp::SetTo(const BString &pattern)
+{
+    fError = B_OK;
+    free(fRegExp);
+    fRegExp = Compile(pattern.String());
+    return fError;
+}
+
+bool
+RegExp::Matches(const char *string) const
+{
+    if (!fRegExp || !string)
+        return false;
+        
+    return RunMatcher(fRegExp, string) == 1;
+}
+
+bool
+RegExp::Matches(const BString &string) const
+{
+    if (!fRegExp)
+        return false;
+
+    return RunMatcher(fRegExp, string.String()) == 1;
+}
+
+
+//
+// - Compile - compile a regular expression into internal code
+//
+// We can't allocate space until we know how big the compiled form will be,
+// but we can't compile it (and thus know how big it is) until we've got a
+// place to put the code.  So we cheat:  we compile it twice, once with code
+// generation turned off and size counting turned on, and once "for real".
+// This also means that we don't allocate space until we are sure that the
+// thing really will compile successfully, and we never have to move the
+// code and thus invalidate pointers into it.  (Note that it has to be in
+// one piece because free() must be able to free it all.)
+//
+// Beware that the optimization-preparation code in here knows about some
+// of the structure of the compiled regexp.
+
+regexp *
+RegExp::Compile(const char *exp)
+{
+    regexp *r;
+    const char *scan;
+    const char *longest;
+    int32 len;
+    int32 flags;
+
+    if (exp == NULL) {
+        SetError(B_BAD_VALUE);
+        return NULL;
+    }
+
+    // First pass: determine size, legality.
+    fInputScanPointer = exp;
+    fParenthesisCount = 1;
+    fCodeSize = 0L;
+    fCodeEmitPointer = &fDummy;
+    Char(kRegExpMagic);
+    if (Reg(0, &flags) == NULL)
+        return NULL;
+
+    // Small enough for pointer-storage convention? 
+    if (fCodeSize >= kMaxSize) {
+        SetError(REGEXP_TOO_BIG);
+        return NULL;
+    }
+
+    // Allocate space.
+    r = (regexp *)malloc(sizeof(regexp) + fCodeSize);
+
+    if (!r) {
+        SetError(B_NO_MEMORY);
+        return NULL;
+    }
+
+    // Second pass: emit code.
+    fInputScanPointer = exp;
+    fParenthesisCount = 1;
+    fCodeEmitPointer = r->program;
+    Char(kRegExpMagic);
+    if (Reg(0, &flags) == NULL) {
+        free(r);
+        return NULL;
+    }
+    
+    // Dig out information for optimizations.
+    r->regstart = '\0'; // Worst-case defaults.
+    r->reganch = 0;
+    r->regmust = NULL;
+    r->regmlen = 0;
+    scan = r->program + 1;          // First kRegExpBranch. 
+    if (*Next((char *)scan) == kRegExpEnd) {        // Only one top-level choice.
+        scan = Operand(scan);
+
+        // Starting-point info.
+        if (*scan == kRegExpExactly)
+            r->regstart = *Operand(scan);
+        else if (*scan == kRegExpBol)
+            r->reganch++;
+
+        //
+        // If there's something expensive in the r.e., find the
+        // longest literal string that must appear and make it the
+        // regmust.  Resolve ties in favor of later strings, since
+        // the regstart check works with the beginning of the r.e.
+        // and avoiding duplication strengthens checking.  Not a
+        // strong reason, but sufficient in the absence of others.
+        //
+        if (flags&kSPStart) {
+            longest = NULL;
+            len = 0;
+            for (; scan != NULL; scan = Next((char *)scan))
+                if (*scan == kRegExpExactly && (int32)strlen(Operand(scan)) >= len) {
+                    longest = Operand(scan);
+                    len = (int32)strlen(Operand(scan));
+                }
+            r->regmust = longest;
+            r->regmlen = len;
+        }
+    }
+
+    return r;
+}
+
+regexp *
+RegExp::Expression() const
+{
+    return fRegExp;
+}
+
+const char *
+RegExp::ErrorString() const
+{
+    if (fError >= REGEXP_UNMATCHED_PARENTHESIS
+        && fError <= REGEXP_CORRUPTED_OPCODE)
+        return kRegExpErrorStringArray[fError - B_ERRORS_END];
+
+    return strerror(fError);
+}
+
+
+void
+RegExp::SetError(status_t error) const
+{
+    fError = error;
+}
+
+
+//
+// - Reg - regular expression, i.e. main body or parenthesized thing
+//
+// Caller must absorb opening parenthesis.
+//
+// Combining parenthesis handling with the base level of regular expression
+// is a trifle forced, but the need to tie the tails of the branches to what
+// follows makes it hard to avoid.
+//
+char *
+RegExp::Reg(int32 paren, int32 *flagp)
+{
+    char *ret;
+    char *br;
+    char *ender;
+    int32 parno = 0;
+    int32 flags;
+
+    *flagp = kHasWidth; // Tentatively.
+
+    // Make an kRegExpOpen node, if parenthesized.
+    if (paren) {
+        if (fParenthesisCount >= kSubExpressionMax) {
+            SetError(REGEXP_TOO_MANY_PARENTHESIS);
+            return NULL;
+        }
+        parno = fParenthesisCount;
+        fParenthesisCount++;
+        ret = Node((char)(kRegExpOpen + parno));
+    } else
+        ret = NULL;
+
+    // Pick up the branches, linking them together.
+    br = Branch(&flags);
+    if (br == NULL)
+        return NULL;
+    if (ret != NULL)
+        Tail(ret, br);  // kRegExpOpen -> first
+    else
+        ret = br;
+    if (!(flags & kHasWidth))
+        *flagp &= ~kHasWidth;
+    *flagp |= flags&kSPStart;
+    while (*fInputScanPointer == '|') {
+        fInputScanPointer++;
+        br = Branch(&flags);
+        if (br == NULL)
+            return NULL;
+        Tail(ret, br);  // kRegExpBranch -> kRegExpBranch.
+        if (!(flags & kHasWidth))
+            *flagp &= ~kHasWidth;
+        *flagp |= flags&kSPStart;
+    }
+
+    // Make a closing node, and hook it on the end.
+    ender = Node(paren ? (char)(kRegExpClose + parno) : (char)kRegExpEnd);  
+    Tail(ret, ender);
+
+    // Hook the tails of the branches to the closing node.
+    for (br = ret; br != NULL; br = Next(br))
+        OpTail(br, ender);
+
+    // Check for proper termination.
+    if (paren && *fInputScanPointer++ != ')') {
+        SetError(REGEXP_UNMATCHED_PARENTHESIS);
+        return NULL;
+    } else if (!paren && *fInputScanPointer != '\0') {
+        if (*fInputScanPointer == ')') {
+            SetError(REGEXP_UNMATCHED_PARENTHESIS);
+            return NULL;
+        } else {
+            SetError(REGEXP_JUNK_ON_END);
+            return NULL;    //  "Can't happen".
+        }
+        // NOTREACHED
+    }
+
+    return ret;
+}
+
+//
+// - Branch - one alternative of an | operator
+//
+// Implements the concatenation operator.
+//
+char *
+RegExp::Branch(int32 *flagp)
+{
+    char *ret;
+    char *chain;
+    char *latest;
+    int32 flags;
+
+    *flagp = kWorst;        // Tentatively.
+
+    ret = Node(kRegExpBranch);
+    chain = NULL;
+    while (*fInputScanPointer != '\0'
+        && *fInputScanPointer != '|'
+        && *fInputScanPointer != ')') {
+        latest = Piece(&flags);
+        if (latest == NULL)
+            return NULL;
+        *flagp |= flags & kHasWidth;
+        if (chain == NULL)  // First piece.
+            *flagp |= flags & kSPStart;
+        else
+            Tail(chain, latest);
+        chain = latest;
+    }
+    if (chain == NULL)  // Loop ran zero times.
+        Node(kRegExpNothing);
+
+    return ret;
+}
+
+//
+// - Piece - something followed by possible [*+?]
+//
+// Note that the branching code sequences used for ? and the general cases
+// of * and + are somewhat optimized:  they use the same kRegExpNothing node as
+// both the endmarker for their branch list and the body of the last branch.
+// It might seem that this node could be dispensed with entirely, but the
+// endmarker role is not redundant.
+//
+char *
+RegExp::Piece(int32 *flagp)
+{
+    char *ret;
+    char op;
+    char *next;
+    int32 flags;
+
+    ret = Atom(&flags);
+    if (ret == NULL)
+        return NULL;
+
+    op = *fInputScanPointer;
+    if (!IsMult(op)) {
+        *flagp = flags;
+        return ret;
+    }
+
+    if (!(flags & kHasWidth) && op != '?') {
+        SetError(REGEXP_STAR_PLUS_OPERAND_EMPTY);
+        return NULL;
+    }
+    *flagp = op != '+' ? kWorst | kSPStart :  kWorst | kHasWidth;
+
+    if (op == '*' && (flags & kSimple))
+        Insert(kRegExpStar, ret);
+    else if (op == '*') {
+        // Emit x* as (x&|), where & means "self".
+        Insert(kRegExpBranch, ret);             // Either x 
+        OpTail(ret, Node(kRegExpBack));     // and loop
+        OpTail(ret, ret);               // back
+        Tail(ret, Node(kRegExpBranch));     // or
+        Tail(ret, Node(kRegExpNothing));        // null.
+    } else if (op == '+' && (flags & kSimple))
+        Insert(kRegExpPlus, ret);
+    else if (op == '+') {
+        // Emit x+ as x(&|), where & means "self".
+        next = Node(kRegExpBranch);             // Either
+        Tail(ret, next);
+        Tail(Node(kRegExpBack), ret);       // loop back
+        Tail(next, Node(kRegExpBranch));        // or
+        Tail(ret, Node(kRegExpNothing));        // null.
+    } else if (op == '?') {
+        // Emit x? as (x|)
+        Insert(kRegExpBranch, ret);         // Either x
+        Tail(ret, Node(kRegExpBranch)); // or 
+        next = Node(kRegExpNothing);        // null.
+        Tail(ret, next);
+        OpTail(ret, next);
+    }
+    fInputScanPointer++;
+    if (IsMult(*fInputScanPointer)) {
+        SetError(REGEXP_NESTED_STAR_QUESTION_PLUS); 
+        return NULL;
+    }
+    return ret;
+}
+
+//
+// - Atom - the lowest level
+//
+// Optimization:  gobbles an entire sequence of ordinary characters so that
+// it can turn them into a single node, which is smaller to store and
+// faster to run.  Backslashed characters are exceptions, each becoming a
+// separate node; the code is simpler that way and it's not worth fixing.
+//
+char *
+RegExp::Atom(int32 *flagp)
+{
+    char *ret;
+    int32 flags;
+
+    *flagp = kWorst;        // Tentatively.
+
+    switch (*fInputScanPointer++) {
+        case '^':
+            ret = Node(kRegExpBol);
+            break;
+        case '$':
+            ret = Node(kRegExpEol);
+            break;
+        case '.':
+            ret = Node(kRegExpAny);
+            *flagp |= kHasWidth|kSimple;
+            break;
+        case '[':
+            {
+                int32 cclass;
+                int32 classend;
+    
+                if (*fInputScanPointer == '^') {    // Complement of range.
+                    ret = Node(kRegExpAnyBut);
+                    fInputScanPointer++;
+                } else
+                    ret = Node(kRegExpAnyOf);
+                if (*fInputScanPointer == ']' || *fInputScanPointer == '-')
+                    Char(*fInputScanPointer++);
+                while (*fInputScanPointer != '\0' && *fInputScanPointer != ']') {
+                    if (*fInputScanPointer == '-') {
+                        fInputScanPointer++;
+                        if (*fInputScanPointer == ']' || *fInputScanPointer == '\0')
+                            Char('-');
+                        else {
+                            cclass = UCharAt(fInputScanPointer - 2) + 1;
+                            classend = UCharAt(fInputScanPointer);
+                            if (cclass > classend + 1) {
+                                SetError(REGEXP_INVALID_BRACKET_RANGE);
+                                return NULL;
+                            }
+                            for (; cclass <= classend; cclass++)
+                                Char((char)cclass);
+                            fInputScanPointer++;
+                        }
+                    } else
+                        Char(*fInputScanPointer++);
+                }
+                Char('\0');
+                if (*fInputScanPointer != ']') {
+                    SetError(REGEXP_UNMATCHED_BRACKET);
+                    return NULL;
+                }
+                fInputScanPointer++;
+                *flagp |= kHasWidth | kSimple;
+            }
+            break;
+        case '(':
+            ret = Reg(1, &flags);
+            if (ret == NULL)
+                return NULL;
+            *flagp |= flags & (kHasWidth | kSPStart);
+            break;
+        case '\0':
+        case '|':
+        case ')':
+            SetError(REGEXP_INTERNAL_ERROR);
+            return NULL; //  Supposed to be caught earlier.
+        case '?':
+        case '+':
+        case '*':
+            SetError(REGEXP_QUESTION_PLUS_STAR_FOLLOWS_NOTHING);
+            return NULL;
+        case '\\':
+            if (*fInputScanPointer == '\0') {
+                SetError(REGEXP_TRAILING_BACKSLASH);
+                return NULL;
+            }
+            ret = Node(kRegExpExactly);
+            Char(*fInputScanPointer++);
+            Char('\0');
+            *flagp |= kHasWidth|kSimple;
+            break;
+        default:
+            {
+                int32 len;
+                char ender;
+    
+                fInputScanPointer--;
+                len = (int32)strcspn(fInputScanPointer, kMeta);
+                if (len <= 0) {
+                    SetError(REGEXP_INTERNAL_ERROR);
+                    return NULL;
+                }
+                ender = *(fInputScanPointer + len);
+                if (len > 1 && IsMult(ender))
+                    len--;      // Back off clear of ?+* operand.
+                *flagp |= kHasWidth;
+                if (len == 1)
+                    *flagp |= kSimple;
+                ret = Node(kRegExpExactly);
+                while (len > 0) {
+                    Char(*fInputScanPointer++);
+                    len--;
+                }
+                Char('\0');
+            }
+            break;
+    }
+
+    return ret;
+}
+
+//
+// - Node - emit a node
+//
+char *          // Location.
+RegExp::Node(char op)
+{
+    char *ret;
+    char *ptr;
+
+    ret = fCodeEmitPointer;
+    if (ret == &fDummy) {
+        fCodeSize += 3;
+        return ret;
+    }
+
+    ptr = ret;
+    *ptr++ = op;
+    *ptr++ = '\0';      // Null "next" pointer.
+    *ptr++ = '\0';
+    fCodeEmitPointer = ptr;
+
+    return ret;
+}
+
+//
+// - Char - emit (if appropriate) a byte of code
+//
+void
+RegExp::Char(char b)
+{
+    if (fCodeEmitPointer != &fDummy)
+        *fCodeEmitPointer++ = b;
+    else
+        fCodeSize++;
+}
+
+//
+// - Insert - insert an operator in front of already-emitted operand
+// 
+// Means relocating the operand.
+// 
+void
+RegExp::Insert(char op, char *opnd)
+{
+    char *src;
+    char *dst;
+    char *place;
+
+    if (fCodeEmitPointer == &fDummy) {
+        fCodeSize += 3;
+        return;
+    }
+
+    src = fCodeEmitPointer;
+    fCodeEmitPointer += 3;
+    dst = fCodeEmitPointer;
+    while (src > opnd)
+        *--dst = *--src;
+
+    place = opnd;       // Op node, where operand used to be.
+    *place++ = op;
+    *place++ = '\0';
+    *place++ = '\0';
+}
+
+//
+// - Tail - set the next-pointer at the end of a node chain
+//
+void
+RegExp::Tail(char *p, char *val)
+{
+    char *scan;
+    char *temp;
+    int32 offset;
+
+    if (p == &fDummy)
+        return;
+
+    // Find last node.
+    scan = p;
+    for (;;) {
+        temp = Next(scan);
+        if (temp == NULL)
+            break;
+        scan = temp;
+    }
+
+    if (scan[0] == kRegExpBack)
+        offset = scan - val;
+    else
+        offset = val - scan;
+
+    scan[1] = (char)((offset >> 8) & 0377);
+    scan[2] = (char)(offset & 0377);
+}
+
+//
+// - OpTail - Tail on operand of first argument; nop if operandless
+//
+void
+RegExp::OpTail(char *p, char *val)
+{
+    // "Operandless" and "op != kRegExpBranch" are synonymous in practice.
+    if (p == NULL || p == &fDummy || *p != kRegExpBranch)
+        return;
+    Tail(Operand(p), val);
+}
+
+//
+// RunMatcher and friends
+//
+
+//
+// - RunMatcher - match a regexp against a string
+//
+int32
+RegExp::RunMatcher(regexp *prog, const char *string) const
+{
+    const char *s;
+
+    // Be paranoid... 
+    if (prog == NULL || string == NULL) {
+        SetError(B_BAD_VALUE); 
+        return 0;
+    }
+
+    // Check validity of program.
+    if (UCharAt(prog->program) != kRegExpMagic) {
+        SetError(REGEXP_CORRUPTED_PROGRAM); 
+        return 0;
+    }
+
+    // If there is a "must appear" string, look for it.
+    if (prog->regmust != NULL) {
+        s = string;
+        while ((s = strchr(s, prog->regmust[0])) != NULL) {
+            if (strncmp(s, prog->regmust, (size_t)prog->regmlen) == 0)
+                break;  // Found it.
+            s++;
+        }
+        if (s == NULL)  // Not present.
+            return 0;
+    }
+
+    // Mark beginning of line for ^ .
+    fRegBol = string;
+
+    // Simplest case:  anchored match need be tried only once.
+    if (prog->reganch)
+        return Try(prog, (char*)string);
+
+    // Messy cases:  unanchored match.
+    s = string;
+    if (prog->regstart != '\0')
+        // We know what char it must start with.
+        while ((s = strchr(s, prog->regstart)) != NULL) {
+            if (Try(prog, (char*)s))
+                return 1;
+            s++;
+        }
+    else
+        // We don't -- general case.
+        do {
+            if (Try(prog, (char*)s))
+                return 1;
+        } while (*s++ != '\0');
+
+    // Failure.
+    return 0;
+}
+
+//
+// - Try - try match at specific point
+//
+int32           // 0 failure, 1 success 
+RegExp::Try(regexp *prog, const char *string) const
+{
+    int32 i;
+    const char **sp;
+    const char **ep;
+
+    fStringInputPointer = string;
+    fStartPArrayPointer = prog->startp;
+    fEndPArrayPointer = prog->endp;
+
+    sp = prog->startp;
+    ep = prog->endp;
+    for (i = kSubExpressionMax; i > 0; i--) {
+        *sp++ = NULL;
+        *ep++ = NULL;
+    }
+    if (Match(prog->program + 1)) {
+        prog->startp[0] = string;
+        prog->endp[0] = fStringInputPointer;
+        return 1;
+    } else
+        return 0;
+}
+
+//
+// - Match - main matching routine
+//
+// Conceptually the strategy is simple:  check to see whether the current
+// node matches, call self recursively to see whether the rest matches,
+// and then act accordingly.  In practice we make some effort to avoid
+// recursion, in particular by going through "ordinary" nodes (that don't
+// need to know whether the rest of the match failed) by a loop instead of
+// by recursion.
+///
+int32           // 0 failure, 1 success
+RegExp::Match(const char *prog) const
+{
+    const char *scan;   // Current node.
+    const char *next;       // Next node.
+
+    scan = prog;
+#ifdef DEBUG
+    if (scan != NULL && regnarrate)
+        fprintf(stderr, "%s(\n", Prop(scan));
+#endif
+    while (scan != NULL) {
+#ifdef DEBUG
+        if (regnarrate)
+            fprintf(stderr, "%s...\n", Prop(scan));
+#endif
+        next = Next(scan);
+
+        switch (*scan) {
+            case kRegExpBol:
+                if (fStringInputPointer != fRegBol)
+                    return 0;
+                break;
+            case kRegExpEol:
+                if (*fStringInputPointer != '\0')
+                    return 0;
+                break;
+            case kRegExpAny:
+                if (*fStringInputPointer == '\0')
+                    return 0;
+                fStringInputPointer++;
+                break;
+            case kRegExpExactly:
+                {
+                    const char *opnd = Operand(scan);
+                    // Inline the first character, for speed.
+                    if (*opnd != *fStringInputPointer)
+                        return 0;
+
+                    uint32 len = strlen(opnd);
+                    if (len > 1 && strncmp(opnd, fStringInputPointer, len) != 0)
+                        return 0;
+
+                    fStringInputPointer += len;
+                }
+                break;
+            case kRegExpAnyOf:
+                if (*fStringInputPointer == '\0'
+                    || strchr(Operand(scan), *fStringInputPointer) == NULL)
+                    return 0;
+                fStringInputPointer++;
+                break;
+            case kRegExpAnyBut:
+                if (*fStringInputPointer == '\0'
+                    || strchr(Operand(scan), *fStringInputPointer) != NULL)
+                    return 0;
+                fStringInputPointer++;
+                break;
+            case kRegExpNothing:
+                break;
+            case kRegExpBack:
+                break;
+            case kRegExpOpen + 1:
+            case kRegExpOpen + 2:
+            case kRegExpOpen + 3:
+            case kRegExpOpen + 4:
+            case kRegExpOpen + 5:
+            case kRegExpOpen + 6:
+            case kRegExpOpen + 7:
+            case kRegExpOpen + 8:
+            case kRegExpOpen + 9:
+                {
+                    int32 no;
+                    const char *save;
+    
+                    no = *scan - kRegExpOpen;
+                    save = fStringInputPointer;
+    
+                    if (Match(next)) {
+                        //
+                        // Don't set startp if some later
+                        // invocation of the same parentheses
+                        // already has.
+                        //
+                        if (fStartPArrayPointer[no] == NULL)
+                            fStartPArrayPointer[no] = save;
+                        return 1;
+                    } else
+                        return 0;
+                }
+                break;
+            case kRegExpClose + 1:
+            case kRegExpClose + 2:
+            case kRegExpClose + 3:
+            case kRegExpClose + 4:
+            case kRegExpClose + 5:
+            case kRegExpClose + 6:
+            case kRegExpClose + 7:
+            case kRegExpClose + 8:
+            case kRegExpClose + 9:
+                {
+                    int32 no;
+                    const char *save;
+    
+                    no = *scan - kRegExpClose;
+                    save = fStringInputPointer;
+    
+                    if (Match(next)) {
+                        //
+                        // Don't set endp if some later
+                        // invocation of the same parentheses
+                        // already has.
+                        //
+                        if (fEndPArrayPointer[no] == NULL)
+                            fEndPArrayPointer[no] = save;
+                        return 1;
+                    } else
+                        return 0;
+                }
+                break;
+            case kRegExpBranch:
+                {
+                    const char *save;
+    
+                    if (*next != kRegExpBranch)     // No choice.
+                        next = Operand(scan);   // Avoid recursion.
+                    else {
+                        do {
+                            save = fStringInputPointer;
+                            if (Match(Operand(scan)))
+                                return 1;
+                            fStringInputPointer = save;
+                            scan = Next(scan);
+                        } while (scan != NULL && *scan == kRegExpBranch);
+                        return 0;
+                        // NOTREACHED/
+                    }
+                }
+                break;
+            case kRegExpStar:
+            case kRegExpPlus:
+                {
+                    char nextch;
+                    int32 no;
+                    const char *save;
+                    int32 min;
+    
+                    //
+                    //Lookahead to avoid useless match attempts
+                    // when we know what character comes next.
+                    //
+                    nextch = '\0';
+                    if (*next == kRegExpExactly)
+                        nextch = *Operand(next);
+                    min = (*scan == kRegExpStar) ? 0 : 1;
+                    save = fStringInputPointer;
+                    no = Repeat(Operand(scan));
+                    while (no >= min) {
+                        // If it could work, try it.
+                        if (nextch == '\0' || *fStringInputPointer == nextch)
+                            if (Match(next))
+                                return 1;
+                        // Couldn't or didn't -- back up.
+                        no--;
+                        fStringInputPointer = save + no;
+                    }
+                    return 0;
+                }
+                break;
+            case kRegExpEnd:
+                return 1;   // Success!
+
+            default:
+                SetError(REGEXP_MEMORY_CORRUPTION);
+                return 0;
+            }
+
+        scan = next;
+    }
+
+    //
+    // We get here only if there's trouble -- normally "case kRegExpEnd" is
+    // the terminating point.
+    //
+    SetError(REGEXP_CORRUPTED_POINTERS);
+    return 0;
+}
+
+//
+// - Repeat - repeatedly match something simple, report how many
+//
+int32
+RegExp::Repeat(const char *p) const
+{
+    int32 count = 0;
+    const char *scan;
+    const char *opnd;
+
+    scan = fStringInputPointer;
+    opnd = Operand(p);
+    switch (*p) {
+        case kRegExpAny:
+            count = (int32)strlen(scan);
+            scan += count;
+            break;
+
+        case kRegExpExactly:
+            while (*opnd == *scan) {
+                count++;
+                scan++;
+            }
+            break;
+
+        case kRegExpAnyOf:
+            while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
+                count++;
+                scan++;
+            }
+            break;
+
+        case kRegExpAnyBut:
+            while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
+                count++;
+                scan++;
+            }
+            break;
+
+        default:        // Oh dear.  Called inappropriately.
+            SetError(REGEXP_INTERNAL_ERROR);
+            count = 0;  // Best compromise.
+            break;
+    }
+    fStringInputPointer = scan;
+
+    return count;
+}
+
+//
+// - Next - dig the "next" pointer out of a node
+//
+char *
+RegExp::Next(char *p)
+{
+    int32 offset;
+
+    if (p == &fDummy)
+        return NULL;
+
+    offset = ((*(p + 1) & 0377) << 8) + (*(p + 2) & 0377);
+    if (offset == 0)
+        return NULL;
+
+    if (*p == kRegExpBack)
+        return p - offset;
+    else
+        return p + offset;
+}
+
+const char *
+RegExp::Next(const char *p) const
+{
+    int32 offset;
+
+    if (p == &fDummy)
+        return NULL;
+
+    offset = ((*(p + 1) & 0377) << 8) + (*(p + 2) & 0377);
+    if (offset == 0)
+        return NULL;
+
+    if (*p == kRegExpBack)
+        return p - offset;
+    else
+        return p + offset;
+}
+
+inline int32
+RegExp::UCharAt(const char *p) const
+{
+    return (int32)*(unsigned char *)p;
+}
+
+inline char *
+RegExp::Operand(char* p) const
+{
+    return p + 3;
+}
+
+inline const char *
+RegExp::Operand(const char* p) const
+{
+    return p + 3;
+}
+
+inline bool
+RegExp::IsMult(char c) const
+{
+    return c == '*' || c == '+' || c == '?';
+}
+
+
+#ifdef DEBUG
+
+//
+// - Dump - dump a regexp onto stdout in vaguely comprehensible form
+//
+void
+RegExp::Dump()
+{
+    char *s;
+    char op = kRegExpExactly;   // Arbitrary non-kRegExpEnd op.
+    char *next;
+
+    s = fRegExp->program + 1;
+    while (op != kRegExpEnd) {  // While that wasn't kRegExpEnd last time...
+        op = *s;
+        printf("%2ld%s", s - fRegExp->program, Prop(s));    // Where, what.
+        next = this->Next(s);
+        if (next == NULL)       // Next ptr.
+            printf("(0)");
+        else 
+            printf("(%ld)", (s - fRegExp->program) + (next - s));
+        s += 3;
+        if (op == kRegExpAnyOf || op == kRegExpAnyBut || op == kRegExpExactly) {
+            // Literal string, where present.
+            while (*s != '\0') {
+                putchar(*s);
+                s++;
+            }
+            s++;
+        }
+        putchar('\n');
+    }
+
+    // Header fields of interest.
+    if (fRegExp->regstart != '\0')
+        printf("start `%c' ", fRegExp->regstart);
+    if (fRegExp->reganch)
+        printf("anchored ");
+    if (fRegExp->regmust != NULL)
+        printf("must have \"%s\"", fRegExp->regmust);
+    printf("\n");
+}
+
+//
+// - Prop - printable representation of opcode
+//
+char *
+RegExp::Prop(const char *op) const
+{
+    char *p = NULL;
+    static char buf[50];
+
+    (void) strcpy(buf, ":");
+
+    switch (*op) {
+        case kRegExpBol:
+            p = "kRegExpBol";
+            break;
+        case kRegExpEol:
+            p = "kRegExpEol";
+            break;
+        case kRegExpAny:
+            p = "kRegExpAny";
+            break;
+        case kRegExpAnyOf:
+            p = "kRegExpAnyOf";
+            break;
+        case kRegExpAnyBut:
+            p = "kRegExpAnyBut";
+            break;
+        case kRegExpBranch:
+            p = "kRegExpBranch";
+            break;
+        case kRegExpExactly:
+            p = "kRegExpExactly";
+            break;
+        case kRegExpNothing:
+            p = "kRegExpNothing";
+            break;
+        case kRegExpBack:
+            p = "kRegExpBack";
+            break;
+        case kRegExpEnd:
+            p = "kRegExpEnd";
+            break;
+        case kRegExpOpen + 1:
+        case kRegExpOpen + 2:
+        case kRegExpOpen + 3:
+        case kRegExpOpen + 4:
+        case kRegExpOpen + 5:
+        case kRegExpOpen + 6:
+        case kRegExpOpen + 7:
+        case kRegExpOpen + 8:
+        case kRegExpOpen + 9:
+            sprintf(buf + strlen(buf), "kRegExpOpen%d", *op - kRegExpOpen);
+            p = NULL;
+            break;
+        case kRegExpClose + 1:
+        case kRegExpClose + 2:
+        case kRegExpClose + 3:
+        case kRegExpClose + 4:
+        case kRegExpClose + 5:
+        case kRegExpClose + 6:
+        case kRegExpClose + 7:
+        case kRegExpClose + 8:
+        case kRegExpClose + 9:
+            sprintf(buf + strlen(buf), "kRegExpClose%d", *op - kRegExpClose);
+            p = NULL;
+            break;
+        case kRegExpStar:
+            p = "kRegExpStar";
+            break;
+        case kRegExpPlus:
+            p = "kRegExpPlus";
+            break;
+        default:
+            RegExpError("corrupted opcode");
+            break;
+    }
+
+    if (p != NULL)
+        strcat(buf, p);
+
+    return buf;
+}
+
+void
+RegExp::RegExpError(const char *) const
+{
+    // does nothing now, perhaps it should printf?
+}
+
+#endif

src/bin/Jamfile

@@ -222 +222 @@
 # Network command line tools
 SubInclude HAIKU_TOP src bin network ;
 
+# Locale kit tools
+SubInclude HAIKU_TOP src bin locale ;
+
 # Compression command line tools
 SubInclude HAIKU_TOP src bin unzip ;
 SubInclude HAIKU_TOP src bin zip ;

src/kits/locale/GenericNumberFormat.cpp

@@ +1 @@
+#include <algorithm>
+#include <float.h>
+#include <math.h>
+#include <new>
+#include <stdlib.h>
+
+#include <GenericNumberFormat.h>
+#include <String.h>
+#include <UnicodeChar.h>
+
+// constants (more below the helper classes)
+
+static const int kMaxIntDigitCount = 20;    // int64: 19 + sign, uint64: 20
+static const int kMaxFloatDigitCount = DBL_DIG + 2;
+    // double: mantissa precision + 2
+
+
+// Symbol
+
+// constructor
+BGenericNumberFormat::Symbol::Symbol(const char *symbol)
+    : symbol(NULL),
+      length(0),
+      char_count(0)
+{
+    SetTo(symbol);
+}
+
+// destructor
+BGenericNumberFormat::Symbol::~Symbol()
+{
+    Unset();
+}
+
+// SetTo
+status_t
+BGenericNumberFormat::Symbol::SetTo(const char *symbol)
+{
+    // unset old
+    if (this->symbol) {
+        free(this->symbol);
+        length = 0;
+        char_count = 0;
+    }
+    // set new
+    if (symbol) {
+        this->symbol = strdup(symbol);
+        if (!this->symbol)
+            return B_NO_MEMORY;
+        length = strlen(this->symbol);
+        char_count = BUnicodeChar::UTF8StringLength(this->symbol);
+    }
+    return B_OK;
+}
+
+
+// SpecialNumberSymbols
+struct BGenericNumberFormat::SpecialNumberSymbols {
+    const Symbol    *nan;
+    const Symbol    *infinity;
+    const Symbol    *negative_infinity;
+};
+
+
+// GroupingInfo
+class BGenericNumberFormat::GroupingInfo {
+    public:
+        GroupingInfo()
+            : fSeparators(NULL),
+              fSeparatorCount(0),
+              fSizes(NULL),
+              fSizeCount(0),
+              fSumSizes(NULL),
+              fSumSeparators(NULL)
+        {
+        }
+
+        GroupingInfo(const char **separators, int32 separatorCount,
+                     const size_t *sizes, int32 sizeCount)
+            : fSeparators(NULL),
+              fSeparatorCount(0),
+              fSizes(NULL),
+              fSizeCount(0),
+              fSumSizes(NULL),
+              fSumSeparators(NULL)
+        {
+            SetTo(separators, separatorCount, sizes, sizeCount);
+        }
+
+        ~GroupingInfo()
+        {
+            Unset();
+        }
+
+        status_t SetTo(const char **separators, int32 separatorCount,
+                       const size_t *sizes, int32 sizeCount)
+        {
+            // unset old
+            Unset();
+            // set new
+            if (!separators && separatorCount <= 0 || !sizes && sizeCount <= 0)
+                return B_OK;
+            // allocate arrays
+            fSeparators = new(std::nothrow) Symbol[separatorCount];
+            fSizes = new(std::nothrow) int32[sizeCount];
+            fSumSizes = new(std::nothrow) int32[sizeCount];
+            fSumSeparators = new(std::nothrow) Symbol*[separatorCount];
+            if (!fSeparators || !fSizes || !fSumSizes || !fSumSeparators) {
+                Unset();
+                return B_NO_MEMORY;
+            }
+            fSeparatorCount = separatorCount;
+            fSizeCount = sizeCount;
+            // separators
+            for (int i = 0; i < separatorCount; i++) {
+                status_t error = fSeparators[i].SetTo(separators[i]);
+                if (error != B_OK) {
+                    Unset();
+                    return error;
+                }
+            }
+            // sizes and sum arrays
+            int32 sumSize = -1;
+            for (int32 i = 0; i < sizeCount; i++) {
+                fSizes[i] = (int32)sizes[i];
+                sumSize += fSizes[i];
+                fSumSizes[i] = sumSize;
+                fSumSeparators[i] = &fSeparators[std::min(i, fSeparatorCount)];
+            }
+            return B_OK;
+        }
+
+        void Unset()
+        {
+            if (fSeparators) {
+                delete[] fSeparators;
+                fSeparators = NULL;
+            }
+            fSeparatorCount = 0;
+            if (fSizes) {
+                delete[] fSizes;
+                fSizes = NULL;
+            }
+            fSizeCount = 0;
+            if (fSumSizes) {
+                delete[] fSumSizes;
+                fSumSizes = NULL;
+            }
+            if (fSumSeparators) {
+                delete[] fSumSeparators;
+                fSumSeparators = NULL;
+            }
+        }
+
+        const Symbol *SeparatorForDigit(int32 position) const
+        {
+            for (int i = fSizeCount - 1; i >= 0; i--) {
+                if (fSumSizes[i] <= position) {
+                    if (fSumSizes[i] == position
+                        || i == fSizeCount - 1
+                           && (position - fSumSizes[i]) % fSizes[i] == 0) {
+                        return fSumSeparators[i];
+                    }
+                    return NULL;
+                }
+            }
+            return NULL;
+        }
+
+    private:
+        Symbol  *fSeparators;
+        int32   fSeparatorCount;
+        int32   *fSizes;
+        int32   fSizeCount;
+        int32   *fSumSizes;
+        Symbol  **fSumSeparators;
+};
+
+
+// SignSymbols
+class BGenericNumberFormat::SignSymbols {
+    public:
+        SignSymbols()
+            : fPlusPrefix(),
+              fMinusPrefix(),
+              fPadPlusPrefix(),
+              fNoForcePlusPrefix(),
+              fPlusSuffix(),
+              fMinusSuffix(),
+              fPadPlusSuffix(),
+              fNoForcePlusSuffix()
+        {
+        }
+
+        SignSymbols(const char *plusPrefix, const char *minusPrefix,
+            const char *padPlusPrefix, const char *noForcePlusPrefix,
+            const char *plusSuffix, const char *minusSuffix,
+            const char *padPlusSuffix, const char *noForcePlusSuffix)
+            : fPlusPrefix(plusPrefix),
+              fMinusPrefix(minusPrefix),
+              fPadPlusPrefix(padPlusPrefix),
+              fNoForcePlusPrefix(noForcePlusPrefix),
+              fPlusSuffix(plusSuffix),
+              fMinusSuffix(minusSuffix),
+              fPadPlusSuffix(padPlusSuffix),
+              fNoForcePlusSuffix(noForcePlusSuffix)
+        {
+        }
+
+        ~SignSymbols()
+        {
+        }
+
+        status_t SetTo(const char *plusPrefix, const char *minusPrefix,
+            const char *padPlusPrefix, const char *noForcePlusPrefix,
+            const char *plusSuffix, const char *minusSuffix,
+            const char *padPlusSuffix, const char *noForcePlusSuffix)
+        {
+            status_t error = B_OK;
+            if (error == B_OK)
+                error = fPlusPrefix.SetTo(plusPrefix);
+            if (error == B_OK)
+                error = fMinusPrefix.SetTo(minusPrefix);
+            if (error == B_OK)
+                error = fPadPlusPrefix.SetTo(noForcePlusPrefix);
+            if (error == B_OK)
+                error = fNoForcePlusPrefix.SetTo(noForcePlusPrefix);
+            if (error == B_OK)
+                error = fPlusSuffix.SetTo(plusSuffix);
+            if (error == B_OK)
+                error = fMinusSuffix.SetTo(minusSuffix);
+            if (error == B_OK)
+                error = fPadPlusSuffix.SetTo(noForcePlusSuffix);
+            if (error == B_OK)
+                error = fNoForcePlusSuffix.SetTo(noForcePlusSuffix);
+            if (error != B_OK)
+                Unset();
+            return error;
+        }
+
+        void Unset()
+        {
+            fPlusPrefix.Unset();
+            fMinusPrefix.Unset();
+            fNoForcePlusPrefix.Unset();
+            fPadPlusPrefix.Unset();
+            fPlusSuffix.Unset();
+            fMinusSuffix.Unset();
+            fNoForcePlusSuffix.Unset();
+            fPadPlusSuffix.Unset();
+        }
+
+        const Symbol *PlusPrefix() const
+        {
+            return &fPlusPrefix;
+        }
+
+        const Symbol *MinusPrefix() const
+        {
+            return &fMinusPrefix;
+        }
+
+        const Symbol *PadPlusPrefix() const
+        {
+            return &fPadPlusPrefix;
+        }
+
+        const Symbol *NoForcePlusPrefix() const
+        {
+            return &fNoForcePlusPrefix;
+        }
+
+        const Symbol *PlusSuffix() const
+        {
+            return &fPlusSuffix;
+        }
+
+        const Symbol *MinusSuffix() const
+        {
+            return &fMinusSuffix;
+        }
+
+        const Symbol *PadPlusSuffix() const
+        {
+            return &fPadPlusSuffix;
+        }
+
+        const Symbol *NoForcePlusSuffix() const
+        {
+            return &fNoForcePlusSuffix;
+        }
+
+    private:
+        Symbol  fPlusPrefix;
+        Symbol  fMinusPrefix;
+        Symbol  fPadPlusPrefix;
+        Symbol  fNoForcePlusPrefix;
+        Symbol  fPlusSuffix;
+        Symbol  fMinusSuffix;
+        Symbol  fPadPlusSuffix;
+        Symbol  fNoForcePlusSuffix;
+};
+
+
+// BufferWriter
+class BGenericNumberFormat::BufferWriter {
+    public:
+        BufferWriter(char *buffer = NULL, int32 bufferSize = 0)
+        {
+            SetTo(buffer, bufferSize);
+        }
+
+        void SetTo(char *buffer = NULL, int32 bufferSize = 0)
+        {
+            fBuffer = buffer;
+            fBufferSize = bufferSize;
+            fPosition = 0;
+            fCharCount = 0;
+            fDryRun = (!fBuffer || (fBufferSize == 0));
+            if (!fDryRun)
+                fBuffer[0] = '\0';
+        }
+
+        int32 StringLength() const
+        {
+            return fPosition;
+        }
+
+        int32 CharCount() const
+        {
+            return fCharCount;
+        }
+
+        bool IsOverflow() const
+        {
+            return (fPosition >= fBufferSize);
+        }
+
+        void Append(const char *bytes, size_t length, size_t charCount)
+        {
+            int32 newPosition = fPosition + length;
+            fDryRun |= (newPosition >= fBufferSize);
+            if (!fDryRun && length > 0) {
+                memcpy(fBuffer + fPosition, bytes, length);
+                fBuffer[newPosition] = '\0';
+            }
+            fPosition = newPosition;
+            fCharCount += charCount;
+        }
+
+        void Append(const Symbol &symbol)
+        {
+            Append(symbol.symbol, symbol.length, symbol.char_count);
+        }
+
+        void Append(const Symbol *symbol)
+        {
+            if (symbol)
+                Append(*symbol);
+        }
+
+        void Append(char c, int32 count)    // ASCII 128 chars only!
+        {
+            if (count <= 0)
+                return;
+            int32 newPosition = fPosition + count;
+            fDryRun |= (newPosition >= fBufferSize);
+            if (!fDryRun && count > 0) {
+                memset(fBuffer + fPosition, c, count);
+                fBuffer[newPosition] = '\0';
+            }
+            fPosition = newPosition;
+            fCharCount += count;
+        }
+
+        void Append(const Symbol &symbol, int32 count)
+        {
+            if (count <= 0)
+                return;
+            int32 bytes = count * symbol.length;
+            int32 newPosition = fPosition + bytes;
+            fDryRun |= (newPosition >= fBufferSize);
+            if (!fDryRun && count > 0) {
+                for (int i = 0; i < count * symbol.length; i++)
+                    fBuffer[i] = symbol.symbol[i % symbol.length];
+                fBuffer[newPosition] = '\0';
+            }
+            fPosition = newPosition;
+            fCharCount += count * symbol.char_count;
+        }
+
+        void Append(const Symbol *symbol, int32 count)
+        {
+            if (symbol)
+                Append(*symbol, count);
+        }
+
+    private:
+        char    *fBuffer;
+        int32   fBufferSize;
+        int32   fPosition;
+        int32   fCharCount;
+        bool    fDryRun;
+};
+
+
+// constants
+
+// digit symbols
+static const BGenericNumberFormat::Symbol kDefaultDigitSymbols[] = {
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
+};
+
+// decimal separator symbol
+static const BGenericNumberFormat::Symbol kDefaultFractionSeparator = ".";
+
+// grouping separator symbols
+static const char *kDefaultGroupingSeparators[] = { "," };
+static const int32 kDefaultGroupingSeparatorCount
+    = sizeof(kDefaultGroupingSeparators) / sizeof(const char*);
+static const char *kNoGroupingSeparators[] = { NULL };  // to please mwcc
+static const int32 kNoGroupingSeparatorCount = 0;
+
+// grouping sizes
+static const size_t kDefaultGroupingSizes[] = { 3 };
+static const int32 kDefaultGroupingSizeCount
+    = sizeof(kDefaultGroupingSizes) / sizeof(size_t);
+static const size_t kNoGroupingSizes[] = { 0 };         // to please mwcc
+static const int32 kNoGroupingSizeCount = 0;
+
+// grouping info
+static const BGenericNumberFormat::GroupingInfo kDefaultGroupingInfo(
+    kDefaultGroupingSeparators, kDefaultGroupingSeparatorCount,
+    kDefaultGroupingSizes, kDefaultGroupingSizeCount
+);
+static const BGenericNumberFormat::GroupingInfo kNoGroupingInfo(
+    kNoGroupingSeparators, kNoGroupingSeparatorCount,
+    kNoGroupingSizes, kNoGroupingSizeCount
+);
+
+// exponent symbol
+static const BGenericNumberFormat::Symbol kDefaultExponentSymbol = "e";
+static const BGenericNumberFormat::Symbol kDefaultUpperCaseExponentSymbol
+    = "E";
+
+// NaN symbol
+static const BGenericNumberFormat::Symbol kDefaultNaNSymbol = "NaN";
+static const BGenericNumberFormat::Symbol kDefaultUpperCaseNaNSymbol = "NaN";
+
+// infinity symbol
+static const BGenericNumberFormat::Symbol kDefaultInfinitySymbol
+    = "infinity";
+static const BGenericNumberFormat::Symbol kDefaultUpperCaseInfinitySymbol
+    = "INFINITY";
+
+// negative infinity symbol
+static const BGenericNumberFormat::Symbol kDefaultNegativeInfinitySymbol
+    = "-infinity";
+static const BGenericNumberFormat::Symbol
+    kDefaultUpperCaseNegativeInfinitySymbol = "-INFINITY";
+
+// sign symbols
+static const BGenericNumberFormat::SignSymbols kDefaultSignSymbols(
+    "+", "-", " ", "",  // prefixes
+    "", "", "", ""      // suffixes
+);
+
+// mantissa sign symbols
+static const BGenericNumberFormat::SignSymbols kDefaultMantissaSignSymbols(
+    "", "", "", "", // prefixes
+    "", "", "", ""      // suffixes
+);
+
+// exponent sign symbols
+static const BGenericNumberFormat::SignSymbols kDefaultExponentSignSymbols(
+    "+", "-", " ", "",  // prefixes
+    "", "", "", ""      // suffixes
+);
+
+
+// Integer
+class BGenericNumberFormat::Integer {
+    public:
+        Integer(int64 number)
+            : fDigitCount(0),
+              fNegative(number < 0)
+        {
+            if (fNegative)
+                Init(0ULL - (uint64)number);
+            else
+                Init(number);
+        }
+
+        Integer(uint64 number)
+            : fDigitCount(0),
+              fNegative(false)
+        {
+            Init(number);
+        }
+
+        int DigitCount() const
+        {
+            return fDigitCount;
+        }
+
+        bool IsNegative() const
+        {
+            return fNegative;
+        }
+
+        char *ToString(char *str) const
+        {
+            if (fDigitCount == 0) {
+                str[0] = '0';
+                str[1] = '\0';
+            } else if (fNegative) {
+                str[0] = '-';
+                for (int i = 0; i < fDigitCount; i++)
+                    str[i + 1] = '0' + fDigits[fDigitCount - i - 1];
+                str[fDigitCount + 1] = '\0';
+            } else {
+                for (int i = 0; i < fDigitCount; i++)
+                    str[i] = '0' + fDigits[fDigitCount - i - 1];
+                str[fDigitCount] = '\0';
+            }
+            return str;
+        }
+
+        void Format(BufferWriter &writer, const Symbol *digitSymbols,
+            const SignSymbols *signSymbols,
+            number_format_sign_policy signPolicy,
+            const GroupingInfo *groupingInfo, int32 minDigits)  const
+        {
+            const Symbol *suffix = NULL;
+            // write sign prefix
+            if (fNegative) {
+                writer.Append(signSymbols->MinusPrefix());
+                suffix = signSymbols->MinusSuffix();
+            } else {
+                switch (signPolicy) {
+                    case B_USE_NEGATIVE_SIGN_ONLY:
+                        writer.Append(signSymbols->NoForcePlusPrefix());
+                        suffix = signSymbols->NoForcePlusSuffix();
+                        break;
+                    case B_USE_SPACE_FOR_POSITIVE_SIGN:
+                        writer.Append(signSymbols->PadPlusPrefix());
+                        suffix = signSymbols->PadPlusSuffix();
+                        break;
+                    case B_USE_POSITIVE_SIGN:
+                        writer.Append(signSymbols->PlusPrefix());
+                        suffix = signSymbols->PlusSuffix();
+                        break;
+                }
+            }
+            // the digits
+            if (fDigitCount == 0 && minDigits < 1) {
+                // special case for zero and less the one minimal digit
+                writer.Append(digitSymbols[0]);
+            } else {
+                // not zero or at least one minimal digit
+                if (groupingInfo) {
+                    // use grouping
+                    // pad with zeros up to minDigits
+                    int32 digitCount = std::max(fDigitCount, minDigits);
+                    for (int i = minDigits - 1; i >= fDigitCount; i--) {
+                        if (i != digitCount - 1)
+                            writer.Append(groupingInfo->SeparatorForDigit(i));
+                        writer.Append(digitSymbols[0]);
+                    }
+                    // write digits
+                    for (int i = fDigitCount - 1; i >= 0; i--) {
+                        if (i != digitCount - 1)
+                            writer.Append(groupingInfo->SeparatorForDigit(i));
+                        writer.Append(digitSymbols[fDigits[i]]);
+                    }
+                } else {
+                    // no grouping
+                    // pad with zeros up to minDigits
+                    if (fDigitCount < minDigits)
+                        writer.Append(digitSymbols, minDigits - fDigitCount);
+                    // write digits
+                    for (int i = fDigitCount - 1; i >= 0; i--)
+                        writer.Append(digitSymbols[fDigits[i]]);
+                }
+            }
+            // append suffix
+            writer.Append(suffix);
+        }
+
+    private:
+        void Init(uint64 number)
+        {
+            fDigitCount = 0;
+            while (number) {
+                fDigits[fDigitCount] = number % 10;
+                number /= 10;
+                fDigitCount++;
+            }
+        }
+
+    private:
+        uchar   fDigits[kMaxIntDigitCount];
+        int32   fDigitCount;
+        bool    fNegative;
+};
+
+
+// Float
+class BGenericNumberFormat::Float {
+    public:
+        Float(double number)
+            : fNegative(signbit(number)),
+              fClass(fpclassify(number)),
+              fExponent(0),
+              fDigitCount(0)
+        {
+            // filter special cases
+            switch (fClass) {
+                case FP_NAN:
+                case FP_INFINITE:
+                    return;
+                case FP_ZERO:
+                    fDigits[0] = 0;
+                    fDigitCount = 1;
+                    return;
+                case FP_NORMAL:
+                case FP_SUBNORMAL:
+                    break;
+            }
+            if (fNegative)
+                number = -number;
+            // We start with an exponent great enough to make
+            // number / 10^fExponent < 10. It may even be < 1 or 0.1.
+            // We simply cut those digits later.
+            fExponent = (int)ceil(log10(number));
+            int shiftBy = kMaxFloatDigitCount - fExponent - 1;
+            // We don't multiply with 10^shiftBy not in one go, since for
+            // subnormal numbers 10^shiftBy will not be representable. Maybe
+            // also for normal numbers close to the limit -- so don't risk
+            // anything, for the time being. TODO: Optimize later.
+            double mantissa = number * pow(10, shiftBy / 2);
+            mantissa *= pow(10, shiftBy - shiftBy / 2);
+            // get the mantissa's digits -- we drop trailing zeros
+            int32 firstNonNull = -1;
+            for (int i = 0; i < kMaxFloatDigitCount; i++) {
+                char digit = (char)fmod(mantissa, 10);
+                if (firstNonNull < 0 && digit > 0)
+                    firstNonNull = i;
+                if (firstNonNull >= 0)
+                    fDigits[i - firstNonNull] = digit;
+                mantissa /= 10;
+            }
+            if (firstNonNull >= 0)
+                fDigitCount = kMaxFloatDigitCount - firstNonNull;
+            else
+                fDigitCount = 0;
+            // drop leading zeros
+            while (fDigitCount > 0 && fDigits[fDigitCount - 1] == 0) {
+                fDigitCount--;
+                fExponent--;
+            }
+            // due to rounding effects we may end up with zero: switch to its
+            // canaonical representation then
+            if (fDigitCount == 0) {
+                fExponent = 0;
+                fDigits[0] = 0;
+                fDigitCount = 1;
+            }
+        }
+
+        void Format(BufferWriter &writer, const Symbol *digitSymbols,
+            const SpecialNumberSymbols *specialNumbers,
+            const Symbol *fractionSeparator,
+            const Symbol *exponentSymbol,
+            const SignSymbols *signSymbols,
+            const SignSymbols *mantissaSignSymbols,
+            const SignSymbols *exponentSignSymbols,
+            float_format_type formatType,
+            number_format_sign_policy signPolicy,
+            const GroupingInfo *groupingInfo,
+            int32 minIntegerDigits, int32 minFractionDigits,
+            int32 maxFractionDigits, bool forceFractionSeparator,
+            bool keepTrailingFractionZeros) const
+        {
+            // deal with special numbers
+            switch (fClass) {
+                case FP_NAN:
+                    writer.Append(specialNumbers->nan);
+                    return;
+                case FP_INFINITE:
+                    if (fNegative)
+                        writer.Append(specialNumbers->negative_infinity);
+                    else
+                        writer.Append(specialNumbers->infinity);
+                    return;
+                case FP_ZERO:
+                case FP_NORMAL:
+                case FP_SUBNORMAL:
+                    break;
+            }
+            // format according to the specified format type
+            bool scientific = false;
+            switch (formatType) {
+                case B_FIXED_POINT_FLOAT_FORMAT:
+                    break;
+                case B_SCIENTIFIC_FLOAT_FORMAT:
+                    scientific = true;
+                    break;
+                case B_AUTO_FLOAT_FORMAT:
+                    // the criterion printf() uses:
+                    scientific = (fExponent >= maxFractionDigits
+                                  || fExponent < -4);
+                    break;
+            }
+            // finally invoke the respective method that does the formatting
+            if (scientific) {
+                FormatScientific(writer, digitSymbols, fractionSeparator,
+                    exponentSymbol, signSymbols, mantissaSignSymbols,
+                    exponentSignSymbols, signPolicy, minIntegerDigits,
+                    minFractionDigits, maxFractionDigits,
+                    forceFractionSeparator, keepTrailingFractionZeros);
+            } else {
+                FormatFixedPoint(writer, digitSymbols, fractionSeparator,
+                    signSymbols, mantissaSignSymbols, signPolicy, groupingInfo,
+                    minIntegerDigits, minFractionDigits, maxFractionDigits,
+                    forceFractionSeparator, keepTrailingFractionZeros);
+            }
+        }
+
+        void FormatScientific(BufferWriter &writer, const Symbol *digitSymbols,
+            const Symbol *fractionSeparator,
+            const Symbol *exponentSymbol,
+            const SignSymbols *signSymbols,
+            const SignSymbols *mantissaSignSymbols,
+            const SignSymbols *exponentSignSymbols,
+            number_format_sign_policy signPolicy,
+            int32 minIntegerDigits, int32 minFractionDigits,
+            int32 maxFractionDigits, bool forceFractionSeparator,
+            bool keepTrailingFractionZeros) const
+        {
+            const Symbol *suffix = NULL;
+            const Symbol *mantissaSuffix = NULL;
+            // write sign prefix
+            if (fNegative) {
+                writer.Append(signSymbols->MinusPrefix());
+                writer.Append(mantissaSignSymbols->MinusPrefix());
+                suffix = signSymbols->MinusSuffix();
+                mantissaSuffix = mantissaSignSymbols->MinusSuffix();
+            } else {
+                switch (signPolicy) {
+                    case B_USE_NEGATIVE_SIGN_ONLY:
+                        writer.Append(signSymbols->NoForcePlusPrefix());
+                        writer.Append(mantissaSignSymbols->NoForcePlusPrefix());
+                        suffix = signSymbols->NoForcePlusSuffix();
+                        mantissaSuffix
+                            = mantissaSignSymbols->NoForcePlusSuffix();
+                        break;
+                    case B_USE_SPACE_FOR_POSITIVE_SIGN:
+                        writer.Append(signSymbols->PadPlusPrefix());
+                        writer.Append(mantissaSignSymbols->PadPlusPrefix());
+                        suffix = signSymbols->PadPlusSuffix();
+                        mantissaSuffix = mantissaSignSymbols->PadPlusSuffix();
+                        break;
+                    case B_USE_POSITIVE_SIGN:
+                        writer.Append(signSymbols->PlusPrefix());
+                        writer.Append(mantissaSignSymbols->PlusPrefix());
+                        suffix = signSymbols->PlusSuffix();
+                        mantissaSuffix = mantissaSignSymbols->PlusSuffix();
+                        break;
+                }
+            }
+            // round
+            int32 exponent = fExponent;
+            char digits[kMaxFloatDigitCount];
+            int32 integerDigits = std::max(minIntegerDigits, 1L);
+            int32 fractionDigits
+                = std::max(fDigitCount - integerDigits, minFractionDigits);
+            fractionDigits = std::min(fractionDigits, maxFractionDigits);
+            int32 digitCount
+                = _Round(digits, integerDigits + fractionDigits, exponent);
+            fractionDigits = digitCount - integerDigits;
+            if (keepTrailingFractionZeros)
+                fractionDigits = std::max(fractionDigits, minFractionDigits);
+            fractionDigits = std::min(fractionDigits, maxFractionDigits);
+            // the mantissa
+            // integer part
+            int32 existingIntegerDigits = std::min(integerDigits, digitCount);
+            for (int i = 0; i < existingIntegerDigits; i++)
+                writer.Append(digitSymbols[digits[digitCount - i - 1]]);
+            // pad with zeros to get the desired number of integer digits
+            if (existingIntegerDigits < integerDigits) {
+                writer.Append(digitSymbols,
+                              integerDigits - existingIntegerDigits);
+            }
+            // unless the number is 0, adjust the exponent
+            if (!_IsZero(digits, digitCount))
+                exponent -= integerDigits - 1;
+            // fraction part
+            if (fractionDigits > 0 || forceFractionSeparator)
+                writer.Append(fractionSeparator);
+            int32 existingFractionDigits
+                = std::min(digitCount - integerDigits, fractionDigits);
+            for (int i = existingFractionDigits - 1; i >= 0; i--)
+                writer.Append(digitSymbols[digits[i]]);
+            // pad with zeros to get the desired number of fraction digits
+            if (fractionDigits > existingFractionDigits) {
+                writer.Append(digitSymbols,
+                              fractionDigits - existingFractionDigits);
+            }
+            writer.Append(mantissaSuffix);
+            // the exponent
+            writer.Append(exponentSymbol);
+
+            Integer(static_cast<int64>(exponent)).Format(writer, digitSymbols,
+                exponentSignSymbols, B_USE_POSITIVE_SIGN, &kNoGroupingInfo, 2);
+            // sign suffix
+            writer.Append(suffix);
+        }
+
+        void FormatFixedPoint(BufferWriter &writer, const Symbol *digitSymbols,
+            const Symbol *fractionSeparator,
+            const SignSymbols *signSymbols,
+            const SignSymbols *mantissaSignSymbols,
+            number_format_sign_policy signPolicy,
+            const GroupingInfo *groupingInfo,
+            int32 minIntegerDigits, int32 minFractionDigits,
+            int32 maxFractionDigits, bool forceFractionSeparator,
+            bool keepTrailingFractionZeros) const
+        {
+            const Symbol *suffix = NULL;
+            const Symbol *mantissaSuffix = NULL;
+            // write sign prefix
+            if (fNegative) {
+                writer.Append(signSymbols->MinusPrefix());
+                writer.Append(mantissaSignSymbols->MinusPrefix());
+                suffix = signSymbols->MinusSuffix();
+                mantissaSuffix = mantissaSignSymbols->MinusSuffix();
+            } else {
+                switch (signPolicy) {
+                    case B_USE_NEGATIVE_SIGN_ONLY:
+                        writer.Append(signSymbols->NoForcePlusPrefix());
+                        writer.Append(mantissaSignSymbols->NoForcePlusPrefix());
+                        suffix = signSymbols->NoForcePlusSuffix();
+                        mantissaSuffix
+                            = mantissaSignSymbols->NoForcePlusSuffix();
+                        break;
+                    case B_USE_SPACE_FOR_POSITIVE_SIGN:
+                        writer.Append(signSymbols->PadPlusPrefix());
+                        writer.Append(mantissaSignSymbols->PadPlusPrefix());
+                        suffix = signSymbols->PadPlusSuffix();
+                        mantissaSuffix = mantissaSignSymbols->PadPlusSuffix();
+                        break;
+                    case B_USE_POSITIVE_SIGN:
+                        writer.Append(signSymbols->PlusPrefix());
+                        writer.Append(mantissaSignSymbols->PlusPrefix());
+                        suffix = signSymbols->PlusSuffix();
+                        mantissaSuffix = mantissaSignSymbols->PlusSuffix();
+                        break;
+                }
+            }
+            // round
+            int32 exponent = fExponent;
+            char digits[kMaxFloatDigitCount];
+            int32 integerDigits = std::max(minIntegerDigits, exponent + 1L);
+            int32 fractionDigits
+                = std::max(fDigitCount - integerDigits, minFractionDigits);
+            fractionDigits = std::min(fractionDigits, maxFractionDigits);
+            int32 digitCount
+                = _Round(digits, integerDigits + fractionDigits, exponent);
+            fractionDigits = digitCount - integerDigits;
+            if (keepTrailingFractionZeros)
+                fractionDigits = std::max(fractionDigits, minFractionDigits);
+            fractionDigits = std::min(fractionDigits, maxFractionDigits);
+            // integer part
+            int32 existingIntegerDigits = std::min(integerDigits, exponent + 1);
+            existingIntegerDigits = std::max(existingIntegerDigits, 0L);
+            if (groupingInfo) {
+                // use grouping
+                // pad with zeros up to minDigits
+                for (int i = integerDigits - 1;
+                     i >= existingIntegerDigits;
+                     i--) {
+                    if (i != integerDigits - 1)
+                        writer.Append(groupingInfo->SeparatorForDigit(i));
+                    writer.Append(digitSymbols[0]);
+                }
+                // write digits
+                for (int i = existingIntegerDigits - 1; i >= 0; i--) {
+                    if (i != integerDigits - 1)
+                        writer.Append(groupingInfo->SeparatorForDigit(i));
+                    writer.Append(digitSymbols[digits[
+                        digitCount - existingIntegerDigits + i]]);
+                }
+            } else {
+                // no grouping
+                // pad with zeros to get the desired number of integer digits
+                if (existingIntegerDigits < integerDigits) {
+                    writer.Append(digitSymbols[0],
+                                  integerDigits - existingIntegerDigits);
+                }
+                // write digits
+                for (int i = 0; i < existingIntegerDigits; i++)
+                    writer.Append(digitSymbols[digits[digitCount - i - 1]]);
+            }
+            // fraction part
+            if (fractionDigits > 0 || forceFractionSeparator)
+                writer.Append(fractionSeparator);
+            int32 existingFractionDigits
+                = std::min(digitCount - existingIntegerDigits, fractionDigits);
+            for (int i = existingFractionDigits - 1; i >= 0; i--)
+                writer.Append(digitSymbols[digits[i]]);
+            // pad with zeros to get the desired number of fraction digits
+            if (fractionDigits > existingFractionDigits) {
+                writer.Append(digitSymbols,
+                              fractionDigits - existingFractionDigits);
+            }
+            // sign suffixes
+            writer.Append(mantissaSuffix);
+            writer.Append(suffix);
+        }
+
+    private:
+        int32 _Round(char *digits, int32 count, int32 &exponent) const
+        {
+            if (count > fDigitCount)
+                count = fDigitCount;
+            int firstNonNull = -1;
+// TODO: Non-hardcoded base-independent rounding.
+            bool carry = false;
+            if (count < fDigitCount)
+                carry = (fDigits[fDigitCount - count - 1] >= 5);
+            for (int i = 0; i < count; i++) {
+                char digit =  fDigits[fDigitCount - count + i];
+                if (carry) {
+                    digit++;
+                    if (digit == 10)    // == base
+                        digit = 0;
+                    else
+                        carry = false;
+                }
+                if (firstNonNull < 0 && digit > 0)
+                    firstNonNull = i;
+                if (firstNonNull >= 0)
+                    digits[i - firstNonNull] = digit;
+            }
+            if (firstNonNull < 0) {
+                if (carry) {
+                    // 9.999999... -> 10
+                    digits[0] = 1;
+                    exponent++;
+                } else {
+                    // 0.0000...1 -> 0
+                    exponent = 0;
+                    digits[0] = 0;
+                }
+                count = 1;
+            } else
+                count -= firstNonNull;
+            return count;
+        }
+
+        static bool _IsZero(const char *digits, int32 digitCount)
+        {
+            return (digitCount == 1 && digits[0] == 0);
+        }
+
+    private:
+        bool    fNegative;
+        int     fClass;
+        int32   fExponent;
+        char    fDigits[kMaxFloatDigitCount];
+        int32   fDigitCount;
+};
+
+
+// constructor
+BGenericNumberFormat::BGenericNumberFormat()
+    : fIntegerParameters(),
+      fFloatParameters(),
+      fDigitSymbols(NULL),
+      fFractionSeparator(NULL),
+      fGroupingInfo(NULL),
+      fExponentSymbol(NULL),
+      fUpperCaseExponentSymbol(NULL),
+      fNaNSymbol(NULL),
+      fUpperCaseNaNSymbol(NULL),
+      fInfinitySymbol(NULL),
+      fUpperCaseInfinitySymbol(NULL),
+      fNegativeInfinitySymbol(NULL),
+      fUpperCaseNegativeInfinitySymbol(NULL),
+      fSignSymbols(NULL),
+      fMantissaSignSymbols(NULL),
+      fExponentSignSymbols(NULL)
+{
+}
+
+// destructor
+BGenericNumberFormat::~BGenericNumberFormat()
+{
+}
+
+// FormatInteger
+status_t
+BGenericNumberFormat::FormatInteger(
+    const BIntegerFormatParameters *parameters, int64 number, BString *buffer,
+    format_field_position *positions, int32 positionCount, int32 *fieldCount,
+    bool allFieldPositions) const
+{
+    if (!buffer)
+        return B_BAD_VALUE;
+    char localBuffer[1024];
+    status_t error = FormatInteger(parameters, number, localBuffer,
+        sizeof(localBuffer), positions, positionCount, fieldCount,
+        allFieldPositions);
+    if (error == B_OK) {
+        buffer->Append(localBuffer);
+        // TODO: Check, if the allocation succeeded.
+    }
+    return error;
+}
+
+// FormatInteger
+status_t
+BGenericNumberFormat::FormatInteger(
+    const BIntegerFormatParameters *parameters, uint64 number, BString *buffer,
+    format_field_position *positions, int32 positionCount, int32 *fieldCount,
+    bool allFieldPositions) const
+{
+    if (!buffer)
+        return B_BAD_VALUE;
+    char localBuffer[1024];
+    status_t error = FormatInteger(parameters, number, localBuffer,
+        sizeof(localBuffer), positions, positionCount, fieldCount,
+        allFieldPositions);
+    if (error == B_OK) {
+        buffer->Append(localBuffer);
+        // TODO: Check, if the allocation succeeded.
+    }
+    return error;
+}
+
+// FormatInteger
+status_t
+BGenericNumberFormat::FormatInteger(
+    const BIntegerFormatParameters *parameters, int64 number, char *buffer,
+    size_t bufferSize, format_field_position *positions, int32 positionCount,
+    int32 *fieldCount, bool allFieldPositions) const
+{
+    Integer integer(number);
+    return FormatInteger(parameters, integer, buffer, bufferSize, positions,
+                         positionCount, fieldCount, allFieldPositions);
+}
+
+// FormatInteger
+status_t
+BGenericNumberFormat::FormatInteger(
+    const BIntegerFormatParameters *parameters, uint64 number, char *buffer,
+    size_t bufferSize, format_field_position *positions, int32 positionCount,
+    int32 *fieldCount, bool allFieldPositions) const
+{
+    Integer integer(number);
+    return FormatInteger(parameters, integer, buffer, bufferSize, positions,
+                         positionCount, fieldCount, allFieldPositions);
+}
+
+// FormatFloat
+status_t
+BGenericNumberFormat::FormatFloat(const BFloatFormatParameters *parameters,
+    double number, BString *buffer, format_field_position *positions,
+    int32 positionCount, int32 *fieldCount, bool allFieldPositions) const
+{
+    if (!buffer)
+        return B_BAD_VALUE;
+    // TODO: How to ensure that this is enough?
+    char localBuffer[1024];
+    status_t error = FormatFloat(parameters, number, localBuffer,
+        sizeof(localBuffer), positions, positionCount, fieldCount,
+        allFieldPositions);
+    if (error == B_OK) {
+        buffer->Append(localBuffer);
+        // TODO: Check, if the allocation succeeded.
+    }
+    return error;
+}
+
+// FormatFloat
+status_t
+BGenericNumberFormat::FormatFloat(const BFloatFormatParameters *parameters,
+    double number, char *buffer, size_t bufferSize,
+    format_field_position *positions, int32 positionCount, int32 *fieldCount,
+    bool allFieldPositions) const
+{
+    // TODO: Check parameters.
+    if (!parameters)
+        parameters = DefaultFloatFormatParameters();
+    if (bufferSize <= parameters->FormatWidth())
+        return EOVERFLOW;
+    Float floatNumber(number);
+    // prepare some parameters
+    const GroupingInfo *groupingInfo = NULL;
+    if (parameters->UseGrouping())
+        groupingInfo = GetGroupingInfo();
+    bool upperCase = parameters->UseUpperCase();
+    SpecialNumberSymbols specialSymbols;
+    GetSpecialNumberSymbols(upperCase, &specialSymbols);
+    // compute the length of the formatted string
+    BufferWriter writer;
+    floatNumber.Format(writer, DigitSymbols(), &specialSymbols,
+        FractionSeparator(), ExponentSymbol(), GetSignSymbols(),
+        MantissaSignSymbols(), ExponentSignSymbols(),
+        parameters->FloatFormatType(), parameters->SignPolicy(), groupingInfo,
+        parameters->MinimalIntegerDigits(), parameters->MinimalFractionDigits(),
+        parameters->MaximalFractionDigits(),
+        parameters->AlwaysUseFractionSeparator(),
+        parameters->KeepTrailingFractionZeros());
+    int32 stringLength = writer.StringLength();
+    int32 charCount = writer.CharCount();
+    // consider alignment and check the available space in the buffer
+    int32 padding = std::max(0L, (int32)parameters->FormatWidth() - charCount);
+// TODO: Padding with zeros.
+    if ((int32)bufferSize <= stringLength + padding)
+        return EOVERFLOW;
+    // prepare for writing
+    writer.SetTo(buffer, bufferSize);
+    // write padding for right field alignment
+    if (parameters->Alignment() == B_ALIGN_FORMAT_RIGHT && padding > 0)
+        writer.Append(' ', padding);
+    // write the number
+    floatNumber.Format(writer,  DigitSymbols(), &specialSymbols,
+        FractionSeparator(), ExponentSymbol(), GetSignSymbols(),
+        MantissaSignSymbols(), ExponentSignSymbols(),
+        parameters->FloatFormatType(), parameters->SignPolicy(), groupingInfo,
+        parameters->MinimalIntegerDigits(), parameters->MinimalFractionDigits(),
+        parameters->MaximalFractionDigits(),
+        parameters->AlwaysUseFractionSeparator(),
+        parameters->KeepTrailingFractionZeros());
+    // write padding for left field alignment
+    if (parameters->Alignment() == B_ALIGN_FORMAT_LEFT && padding > 0)
+        writer.Append(' ', padding);
+    return B_OK;
+}
+
+// SetDefaultIntegerFormatParameters
+status_t
+BGenericNumberFormat::SetDefaultIntegerFormatParameters(
+    const BIntegerFormatParameters *parameters)
+{
+    if (!parameters)
+        return B_BAD_VALUE;
+    fIntegerParameters = *parameters;
+    return B_OK;
+}
+
+// DefaultIntegerFormatParameters
+BIntegerFormatParameters *
+BGenericNumberFormat::DefaultIntegerFormatParameters()
+{
+    return &fIntegerParameters;
+}
+
+// DefaultIntegerFormatParameters
+const BIntegerFormatParameters *
+BGenericNumberFormat::DefaultIntegerFormatParameters() const
+{
+    return &fIntegerParameters;
+}
+
+// SetDefaultFloatFormatParameters
+status_t
+BGenericNumberFormat::SetDefaultFloatFormatParameters(
+    const BFloatFormatParameters *parameters)
+{
+    if (!parameters)
+        return B_BAD_VALUE;
+    fFloatParameters = *parameters;
+    return B_OK;
+}
+
+// DefaultFloatFormatParameters
+BFloatFormatParameters *
+BGenericNumberFormat::DefaultFloatFormatParameters()
+{
+    return &fFloatParameters;
+}
+
+// DefaultFloatFormatParameters
+const BFloatFormatParameters *
+BGenericNumberFormat::DefaultFloatFormatParameters() const
+{
+    return &fFloatParameters;
+}
+
+// SetDigitSymbols
+status_t
+BGenericNumberFormat::SetDigitSymbols(const char **digits)
+{
+    // check parameters
+    if (digits) {
+        for (int i = 0; i < 10; i++) {
+            if (!digits[i])
+                return B_BAD_VALUE;
+        }
+    }
+    // unset old
+    if (fDigitSymbols) {
+        delete[] fDigitSymbols;
+        fDigitSymbols = NULL;
+    }
+    // set new
+    if (digits) {
+        fDigitSymbols = new(std::nothrow) Symbol[10];
+        if (!fDigitSymbols)
+            return B_NO_MEMORY;
+        for (int i = 0; i < 10; i++) {
+            status_t error = fDigitSymbols[i].SetTo(digits[i]);
+            if (error != B_OK) {
+                SetDigitSymbols(NULL);
+                return error;
+            }
+        }
+    }
+    return B_OK;
+}
+
+// SetFractionSeparator
+status_t
+BGenericNumberFormat::SetFractionSeparator(const char *decimalSeparator)
+{
+    return _SetSymbol(&fFractionSeparator, decimalSeparator);
+}
+
+// SetGroupingInfo
+status_t
+BGenericNumberFormat::SetGroupingInfo(const char **groupingSeparators,
+    size_t separatorCount, size_t *groupingSizes, size_t sizeCount)
+{
+    // check parameters
+    if (groupingSeparators && separatorCount > 0 && groupingSizes
+        && sizeCount) {
+        for (int i = 0; i < (int)separatorCount; i++) {
+            if (!groupingSeparators[i])
+                return B_BAD_VALUE;
+        }
+    }
+    // unset old
+    if (fGroupingInfo) {
+        delete fGroupingInfo;
+        fGroupingInfo = NULL;
+    }
+    // set new
+    if (groupingSeparators && separatorCount > 0 && groupingSizes
+        && sizeCount) {
+        fGroupingInfo = new GroupingInfo;
+        if (!fGroupingInfo)
+            return B_NO_MEMORY;
+        status_t error = fGroupingInfo->SetTo(groupingSeparators,
+            separatorCount, groupingSizes, sizeCount);
+        if (error != B_OK) {
+            delete fGroupingInfo;
+            fGroupingInfo = NULL;
+            return error;
+        }
+    }
+    return B_OK;
+}
+
+// SetExponentSymbol
+status_t
+BGenericNumberFormat::SetExponentSymbol(const char *exponentSymbol,
+    const char *upperCaseExponentSymbol)
+{
+    status_t error = _SetSymbol(&fExponentSymbol, exponentSymbol);
+    if (error == B_OK)
+        error = _SetSymbol(&fUpperCaseExponentSymbol, upperCaseExponentSymbol);
+    if (error != B_OK)
+        SetExponentSymbol(NULL, NULL);
+    return error;
+}
+
+// SetSpecialNumberSymbols
+status_t
+BGenericNumberFormat::SetSpecialNumberSymbols(const char *nan,
+    const char *infinity, const char *negativeInfinity,
+    const char *upperCaseNaN, const char *upperCaseInfinity,
+    const char *upperCaseNegativeInfinity)
+{
+    status_t error = _SetSymbol(&fNaNSymbol, nan);
+    if (error == B_OK)
+        error = _SetSymbol(&fInfinitySymbol, infinity);
+    if (error == B_OK)
+        error = _SetSymbol(&fNegativeInfinitySymbol, negativeInfinity);
+    if (error == B_OK)
+        error = _SetSymbol(&fUpperCaseNaNSymbol, upperCaseNaN);
+    if (error == B_OK)
+        error = _SetSymbol(&fUpperCaseInfinitySymbol, upperCaseInfinity);
+    if (error == B_OK) {
+        error = _SetSymbol(&fUpperCaseNegativeInfinitySymbol,
+            upperCaseNegativeInfinity);
+    }
+    if (error != B_OK)
+        SetSpecialNumberSymbols(NULL, NULL, NULL, NULL, NULL, NULL);
+    return error;
+}
+
+// SetSignSymbols
+status_t
+BGenericNumberFormat::SetSignSymbols(const char *plusPrefix,
+    const char *minusPrefix, const char *padPlusPrefix,
+    const char *noForcePlusPrefix, const char *plusSuffix,
+    const char *minusSuffix, const char *padPlusSuffix,
+    const char *noForcePlusSuffix)
+{
+    if (!fSignSymbols) {
+        fSignSymbols = new(std::nothrow) SignSymbols;
+        if (!fSignSymbols)
+            return B_NO_MEMORY;
+    }
+    return fSignSymbols->SetTo(plusPrefix, minusPrefix, padPlusPrefix,
+        noForcePlusPrefix, plusSuffix, minusSuffix, padPlusSuffix,
+        noForcePlusSuffix);
+}
+
+// SetMantissaSignSymbols
+status_t
+BGenericNumberFormat::SetMantissaSignSymbols(const char *plusPrefix,
+    const char *minusPrefix, const char *padPlusPrefix,
+    const char *noForcePlusPrefix, const char *plusSuffix,
+    const char *minusSuffix, const char *padPlusSuffix,
+    const char *noForcePlusSuffix)
+{
+    if (!fMantissaSignSymbols) {
+        fMantissaSignSymbols = new(std::nothrow) SignSymbols;
+        if (!fMantissaSignSymbols)
+            return B_NO_MEMORY;
+    }
+    return fMantissaSignSymbols->SetTo(plusPrefix, minusPrefix, padPlusPrefix,
+        noForcePlusPrefix, plusSuffix, minusSuffix, padPlusSuffix,
+        noForcePlusSuffix);
+}
+
+// SetExponentSignSymbols
+status_t
+BGenericNumberFormat::SetExponentSignSymbols(const char *plusPrefix,
+    const char *minusPrefix, const char *plusSuffix, const char *minusSuffix)
+{
+    if (!fExponentSignSymbols) {
+        fExponentSignSymbols = new(std::nothrow) SignSymbols;
+        if (!fExponentSignSymbols)
+            return B_NO_MEMORY;
+    }
+    return fExponentSignSymbols->SetTo(plusPrefix, minusPrefix, plusPrefix,
+        plusPrefix, plusSuffix, minusSuffix, plusSuffix, plusSuffix);
+}
+
+// FormatInteger
+status_t
+BGenericNumberFormat::FormatInteger(
+    const BIntegerFormatParameters *parameters, const Integer &integer,
+    char *buffer, size_t bufferSize, format_field_position *positions,
+    int32 positionCount, int32 *fieldCount, bool allFieldPositions) const
+{
+    // TODO: Check parameters.
+    if (!parameters)
+        parameters = DefaultIntegerFormatParameters();
+    if (bufferSize <= parameters->FormatWidth())
+        return EOVERFLOW;
+    // prepare some parameters
+    const GroupingInfo *groupingInfo = NULL;
+    if (parameters->UseGrouping())
+        groupingInfo = GetGroupingInfo();
+    // compute the length of the formatted string
+    BufferWriter writer;
+    integer.Format(writer, DigitSymbols(),
+        GetSignSymbols(), parameters->SignPolicy(), groupingInfo,
+        parameters->MinimalIntegerDigits());
+    int32 stringLength = writer.StringLength();
+    int32 charCount = writer.CharCount();
+    // consider alignment and check the available space in the buffer
+    int32 padding = std::max(0L, (int32)parameters->FormatWidth() - charCount);
+// TODO: Padding with zeros.
+    if ((int32)bufferSize <= stringLength + padding)
+        return EOVERFLOW;
+    // prepare for writing
+    writer.SetTo(buffer, bufferSize);
+    // write padding for right field alignment
+    if (parameters->Alignment() == B_ALIGN_FORMAT_RIGHT && padding > 0)
+        writer.Append(' ', padding);
+    // write the number
+    integer.Format(writer, DigitSymbols(),
+        GetSignSymbols(), parameters->SignPolicy(), groupingInfo,
+        parameters->MinimalIntegerDigits());
+    // write padding for left field alignment
+    if (parameters->Alignment() == B_ALIGN_FORMAT_LEFT && padding > 0)
+        writer.Append(' ', padding);
+    return B_OK;
+}
+
+// DigitSymbols
+const BGenericNumberFormat::Symbol *
+BGenericNumberFormat::DigitSymbols() const
+{
+    return (fDigitSymbols ? fDigitSymbols : kDefaultDigitSymbols);
+}
+
+// FractionSeparator
+const BGenericNumberFormat::Symbol *
+BGenericNumberFormat::FractionSeparator() const
+{
+    return (fFractionSeparator ? fFractionSeparator
+                               : &kDefaultFractionSeparator);
+}
+
+// GetGroupingInfo
+const BGenericNumberFormat::GroupingInfo *
+BGenericNumberFormat::GetGroupingInfo() const
+{
+    return (fGroupingInfo ? fGroupingInfo : &kDefaultGroupingInfo);
+}
+
+// ExponentSymbol
+const BGenericNumberFormat::Symbol *
+BGenericNumberFormat::ExponentSymbol(bool upperCase) const
+{
+    if (fExponentSymbol) {
+        return (upperCase && fUpperCaseExponentSymbol ? fUpperCaseExponentSymbol
+                                                      : fExponentSymbol);
+    }
+    return (upperCase ? &kDefaultUpperCaseExponentSymbol
+                      : &kDefaultExponentSymbol);
+}
+
+// NaNSymbol
+const BGenericNumberFormat::Symbol *
+BGenericNumberFormat::NaNSymbol(bool upperCase) const
+{
+    if (fNaNSymbol) {
+        return (upperCase && fUpperCaseNaNSymbol ? fUpperCaseNaNSymbol
+                                                 : fNaNSymbol);
+    }
+    return (upperCase ? &kDefaultUpperCaseNaNSymbol
+                      : &kDefaultNaNSymbol);
+}
+
+// InfinitySymbol
+const BGenericNumberFormat::Symbol *
+BGenericNumberFormat::InfinitySymbol(bool upperCase) const
+{
+    if (fInfinitySymbol) {
+        return (upperCase && fUpperCaseInfinitySymbol ? fUpperCaseInfinitySymbol
+                                                      : fInfinitySymbol);
+    }
+    return (upperCase ? &kDefaultUpperCaseInfinitySymbol
+                      : &kDefaultInfinitySymbol);
+}
+
+// NegativeInfinitySymbol
+const BGenericNumberFormat::Symbol *
+BGenericNumberFormat::NegativeInfinitySymbol(bool upperCase) const
+{
+    if (fNegativeInfinitySymbol) {
+        return (upperCase && fUpperCaseNegativeInfinitySymbol
+            ? fUpperCaseNegativeInfinitySymbol : fNegativeInfinitySymbol);
+    }
+    return (upperCase ? &kDefaultUpperCaseNegativeInfinitySymbol
+                      : &kDefaultNegativeInfinitySymbol);
+}
+
+// GetSpecialNumberSymbols
+void
+BGenericNumberFormat::GetSpecialNumberSymbols(bool upperCase,
+    SpecialNumberSymbols *symbols) const
+{
+    symbols->nan = NaNSymbol(upperCase);
+    symbols->infinity = InfinitySymbol(upperCase);
+    symbols->negative_infinity = NegativeInfinitySymbol(upperCase);
+}
+
+// GetSignSymbols
+const BGenericNumberFormat::SignSymbols *
+BGenericNumberFormat::GetSignSymbols() const
+{
+    return (fSignSymbols ? fSignSymbols : &kDefaultSignSymbols);
+}
+
+// MantissaSignSymbols
+const BGenericNumberFormat::SignSymbols *
+BGenericNumberFormat::MantissaSignSymbols() const
+{
+    return (fMantissaSignSymbols ? fMantissaSignSymbols
+                                 : &kDefaultMantissaSignSymbols);
+}
+
+// ExponentSignSymbols
+const BGenericNumberFormat::SignSymbols *
+BGenericNumberFormat::ExponentSignSymbols() const
+{
+    return (fExponentSignSymbols ? fExponentSignSymbols
+                                 : &kDefaultExponentSignSymbols);
+}
+
+// _SetSymbol
+status_t
+BGenericNumberFormat::_SetSymbol(Symbol **symbol, const char *str)
+{
+    if (!str) {
+        // no symbol -- unset old
+        if (*symbol) {
+            delete *symbol;
+            symbol = NULL;
+        }
+    } else {
+        // allocate if not existing
+        if (!*symbol) {
+            *symbol = new(std::nothrow) Symbol;
+            if (!*symbol)
+                return B_NO_MEMORY;
+        }
+        // set symbol
+        status_t error = (*symbol)->SetTo(str);
+        if (error != B_OK) {
+            delete *symbol;
+            *symbol = NULL;
+            return B_NO_MEMORY;
+        }
+    }
+    return B_OK;
+}
+

src/kits/locale/FloatFormatImpl.cpp

@@ +1 @@
+#include <FloatFormatImpl.h>
+#include <FloatFormatParameters.h>
+
+// constructor
+BFloatFormatImpl::BFloatFormatImpl()
+    : BNumberFormatImpl()
+{
+}
+
+// destructor
+BFloatFormatImpl::~BFloatFormatImpl()
+{
+}
+
+// DefaultNumberFormatParameters
+BNumberFormatParameters *
+BFloatFormatImpl::DefaultNumberFormatParameters()
+{
+    return DefaultFloatFormatParameters();
+}
+
+// DefaultNumberFormatParameters
+const BNumberFormatParameters *
+BFloatFormatImpl::DefaultNumberFormatParameters() const
+{
+    return DefaultFloatFormatParameters();
+}
+

src/kits/locale/FloatFormatParameters.cpp

@@ +1 @@
+#include <FloatFormatParameters.h>
+
+// defaults
+static const size_t kDefaultMinimalFractionDigits = 0;
+static const size_t kDefaultMaximalFractionDigits = 6;
+static const bool kDefaultUseUpperCase = false;
+static const float_format_type kDefaultFloatFormatType = B_AUTO_FLOAT_FORMAT;
+static const bool kDefaultAlwaysUseFractionSeparator = false;
+static const bool kDefaultKeepTrailingFractionZeros = false;
+
+
+// flags
+enum {
+    MINIMAL_FRACTION_DIGITS_SET         = 0x01,
+    MAXIMAL_FRACTION_DIGITS_SET         = 0x02,
+    USE_UPPER_CASE_SET                  = 0x04,
+    FLOAT_FORMAT_TYPE_SET               = 0x08,
+    ALWAYS_USE_FRACTION_SEPARATOR_SET   = 0x10,
+    KEEP_TRAILING_FRACTION_ZEROS_SET    = 0x20,
+};
+
+// constructor
+BFloatFormatParameters::BFloatFormatParameters(
+    const BFloatFormatParameters *parent)
+    : BNumberFormatParameters(parent),
+      fParent(parent),
+      fFlags(0)
+{
+}
+
+// copy constructor
+BFloatFormatParameters::BFloatFormatParameters(
+    const BFloatFormatParameters &other)
+    : BNumberFormatParameters(other),
+      fParent(other.fParent),
+      fMinimalFractionDigits(other.fMinimalFractionDigits),
+      fMaximalFractionDigits(other.fMaximalFractionDigits),
+      fUseUpperCase(other.fUseUpperCase),
+      fFloatFormatType(other.fFloatFormatType),
+      fAlwaysUseFractionSeparator(other.fAlwaysUseFractionSeparator),
+      fKeepTrailingFractionZeros(other.fKeepTrailingFractionZeros),
+      fFlags(other.fFlags)
+{
+}
+
+// destructor
+BFloatFormatParameters::~BFloatFormatParameters()
+{
+}
+
+// SetMinimalFractionDigits
+void
+BFloatFormatParameters::SetMinimalFractionDigits(size_t minFractionDigits)
+{
+    fMinimalFractionDigits = minFractionDigits;
+    fFlags |= MINIMAL_FRACTION_DIGITS_SET;
+}
+
+// MinimalFractionDigits
+size_t
+BFloatFormatParameters::MinimalFractionDigits() const
+{
+    if (fFlags & MINIMAL_FRACTION_DIGITS_SET)
+        return fMinimalFractionDigits;
+    if (fParent)
+        return fParent->MinimalFractionDigits();
+    return kDefaultMinimalFractionDigits;
+}
+
+// SetMaximalFractionDigits
+void
+BFloatFormatParameters::SetMaximalFractionDigits(size_t maxFractionDigits)
+{
+    fMaximalFractionDigits = maxFractionDigits;
+    fFlags |= MAXIMAL_FRACTION_DIGITS_SET;
+}
+
+// MaximalFractionDigits
+size_t
+BFloatFormatParameters::MaximalFractionDigits() const
+{
+    if (fFlags & MAXIMAL_FRACTION_DIGITS_SET)
+        return fMaximalFractionDigits;
+    if (fParent)
+        return fParent->MaximalFractionDigits();
+    return kDefaultMaximalFractionDigits;
+}
+
+// SetUseUpperCase
+void
+BFloatFormatParameters::SetUseUpperCase(bool useCapitals)
+{
+    fUseUpperCase = useCapitals;
+    fFlags |= USE_UPPER_CASE_SET;
+}
+
+// UseUpperCase
+bool
+BFloatFormatParameters::UseUpperCase() const
+{
+    if (fFlags & USE_UPPER_CASE_SET)
+        return fUseUpperCase;
+    if (fParent)
+        return fParent->UseUpperCase();
+    return kDefaultUseUpperCase;
+}
+
+// SetFloatFormatType
+void
+BFloatFormatParameters::SetFloatFormatType(float_format_type type)
+{
+    fFloatFormatType = type;
+    fFlags |= FLOAT_FORMAT_TYPE_SET;
+}
+
+// FloatFormatType
+float_format_type
+BFloatFormatParameters::FloatFormatType() const
+{
+    if (fFlags & FLOAT_FORMAT_TYPE_SET)
+        return fFloatFormatType;
+    if (fParent)
+        return fParent->FloatFormatType();
+    return kDefaultFloatFormatType;
+}
+
+// SetAlwaysUseFractionSeparator
+void
+BFloatFormatParameters::SetAlwaysUseFractionSeparator(
+    bool alwaysUseFractionSeparator)
+{
+    fAlwaysUseFractionSeparator = alwaysUseFractionSeparator;
+    fFlags |= ALWAYS_USE_FRACTION_SEPARATOR_SET;
+}
+
+// AlwaysUseFractionSeparator
+bool
+BFloatFormatParameters::AlwaysUseFractionSeparator() const
+{
+    if (fFlags & ALWAYS_USE_FRACTION_SEPARATOR_SET)
+        return fAlwaysUseFractionSeparator;
+    if (fParent)
+        return fParent->AlwaysUseFractionSeparator();
+    return kDefaultAlwaysUseFractionSeparator;
+}
+
+// SetKeepTrailingFractionZeros
+void
+BFloatFormatParameters::SetKeepTrailingFractionZeros(
+    bool keepTrailingFractionZeros)
+{
+    fKeepTrailingFractionZeros = keepTrailingFractionZeros;
+    fFlags |= KEEP_TRAILING_FRACTION_ZEROS_SET;
+}
+
+// KeepTrailingFractionZeros
+bool
+BFloatFormatParameters::KeepTrailingFractionZeros() const
+{
+    if (fFlags & KEEP_TRAILING_FRACTION_ZEROS_SET)
+        return fKeepTrailingFractionZeros;
+    if (fParent)
+        return fParent->KeepTrailingFractionZeros();
+    return kDefaultKeepTrailingFractionZeros;
+}
+
+// SetParentFloatParameters
+void
+BFloatFormatParameters::SetParentFloatParameters(
+    const BFloatFormatParameters *parent)
+{
+    fParent = parent;
+    SetParentNumberParameters(parent);
+}
+
+// ParentFloatParameters
+const BFloatFormatParameters *
+BFloatFormatParameters::ParentFloatParameters() const
+{
+    return fParent;
+}
+
+// =
+BFloatFormatParameters &
+BFloatFormatParameters::operator=(const BFloatFormatParameters &other)
+{
+    BNumberFormatParameters::operator=(other);
+    fParent = other.fParent;
+    fMinimalFractionDigits = other.fMinimalFractionDigits;
+    fMaximalFractionDigits = other.fMaximalFractionDigits;
+    fUseUpperCase = other.fUseUpperCase;
+    fFloatFormatType = other.fFloatFormatType;
+    fAlwaysUseFractionSeparator = other.fAlwaysUseFractionSeparator;
+    fKeepTrailingFractionZeros = other.fKeepTrailingFractionZeros;
+    fFlags = other.fFlags;
+    return *this;
+}
+

src/kits/locale/Country.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <Country.h>
+#include <String.h>
+
+#include <monetary.h>
+#include <stdarg.h>
+
+
+const char *gStrings[] = {
+    // date/time format
+    "",
+    "",
+    "",
+    "",
+    // short date/time format
+    "",
+    "",
+    "",
+    "",
+    // am/pm string
+    "AM",
+    "PM",
+    // separators
+    ".",
+    ":",
+    " ",
+    ".",
+    ",",
+    // positive/negative sign
+    "+",
+    "-",
+    // currency/monetary
+    "US$"
+    " "
+    "."
+    ","
+};
+
+
+BCountry::BCountry()
+    :
+    fStrings(gStrings)
+{
+}
+
+
+BCountry::BCountry(const char **strings)
+    :
+    fStrings(strings)
+{
+}
+
+
+BCountry::~BCountry()
+{
+}
+
+
+const char *
+BCountry::Name() const
+{
+    return "United States Of America";
+}
+
+
+const char *
+BCountry::GetString(uint32 id) const
+{
+    if (id < B_COUNTRY_STRINGS_BASE || id >= B_NUM_COUNTRY_STRINGS)
+        return NULL;
+
+    return gStrings[id - B_COUNTRY_STRINGS_BASE];
+}
+
+
+void 
+BCountry::FormatDate(char *string, size_t maxSize, time_t time, bool longFormat)
+{
+    // ToDo: implement us
+}
+
+
+void 
+BCountry::FormatDate(BString *string, time_t time, bool longFormat)
+{
+}
+
+
+void 
+BCountry::FormatTime(char *string, size_t maxSize, time_t time, bool longFormat)
+{
+}
+
+
+void 
+BCountry::FormatTime(BString *string, time_t time, bool longFormat)
+{
+}
+
+
+const char *
+BCountry::DateFormat(bool longFormat) const
+{
+    return fStrings[longFormat ? B_DATE_FORMAT : B_SHORT_DATE_FORMAT];
+}
+
+
+const char *
+BCountry::TimeFormat(bool longFormat) const
+{
+    return fStrings[longFormat ? B_TIME_FORMAT : B_SHORT_TIME_FORMAT];
+}
+
+
+const char *
+BCountry::DateSeparator() const
+{
+    return fStrings[B_DATE_SEPARATOR];
+}
+
+
+const char *
+BCountry::TimeSeparator() const
+{
+    return fStrings[B_TIME_SEPARATOR];
+}
+
+
+void 
+BCountry::FormatNumber(char *string, size_t maxSize, double value)
+{
+}
+
+
+void 
+BCountry::FormatNumber(BString *string, double value)
+{
+}
+
+
+void 
+BCountry::FormatNumber(char *string, size_t maxSize, int32 value)
+{
+}
+
+
+void 
+BCountry::FormatNumber(BString *string, int32 value)
+{
+}
+
+
+const char *
+BCountry::DecimalPoint() const
+{
+    return fStrings[B_DECIMAL_POINT];
+}
+
+
+const char *
+BCountry::ThousandsSeparator() const
+{
+    return fStrings[B_THOUSANDS_SEPARATOR];
+}
+
+
+const char *
+BCountry::Grouping() const
+{
+    return fStrings[B_GROUPING];
+}
+
+
+const char *
+BCountry::PositiveSign() const
+{
+    return fStrings[B_POSITIVE_SIGN];
+}
+
+
+const char *
+BCountry::NegativeSign() const
+{
+    return fStrings[B_NEGATIVE_SIGN];
+}
+
+
+int8 
+BCountry::Measurement() const
+{
+    return B_US;
+}
+
+
+ssize_t
+BCountry::FormatMonetary(char *string, size_t maxSize, char *format, ...)
+{
+    va_list args;
+    va_start(args,format);
+
+    ssize_t status = vstrfmon(string, maxSize, format, args);
+
+    va_end(args);
+
+    return status;
+}
+
+
+ssize_t 
+BCountry::FormatMonetary(BString *string, char *format, ...)
+{
+    return B_OK;
+}
+
+
+const char *
+BCountry::CurrencySymbol() const
+{
+    return fStrings[B_CURRENCY_SYMBOL];
+}
+
+
+const char *
+BCountry::InternationalCurrencySymbol() const
+{
+    return fStrings[B_INT_CURRENCY_SYMBOL];
+}
+
+
+const char *
+BCountry::MonDecimalPoint() const
+{
+    return fStrings[B_MON_DECIMAL_POINT];
+}
+
+
+const char *
+BCountry::MonThousandsSeparator() const
+{
+    return fStrings[B_MON_THOUSANDS_SEPARATOR];
+}
+
+
+const char *
+BCountry::MonGrouping() const
+{
+    return fStrings[B_MON_GROUPING];
+}
+
+
+int32 
+BCountry::MonFracDigits() const
+{
+    return 2;
+}
+

src/kits/locale/IntegerFormat.cpp

@@ +1 @@
+#include <IntegerFormat.h>
+#include <IntegerFormatImpl.h>
+
+// copy constructor
+BIntegerFormat::BIntegerFormat(const BIntegerFormat &other)
+    : BNumberFormat(other),
+      BIntegerFormatParameters(other)
+{
+}
+
+// destructor
+BIntegerFormat::~BIntegerFormat()
+{
+}
+
+// Format
+status_t
+BIntegerFormat::Format(int64 number, BString *buffer) const
+{
+    if (!fImpl)
+        return B_NO_INIT;
+    return IntegerFormatImpl()->Format(this, number, buffer);
+}
+
+// Format
+status_t
+BIntegerFormat::Format(int64 number, BString *buffer,
+                       format_field_position *positions, int32 positionCount,
+                       int32 *fieldCount, bool allFieldPositions) const
+{
+    if (!fImpl)
+        return B_NO_INIT;
+    return IntegerFormatImpl()->Format(this,number, buffer, positions,
+        positionCount, fieldCount, allFieldPositions);
+}
+
+// =
+BIntegerFormat &
+BIntegerFormat::operator=(const BIntegerFormat &other)
+{
+    BNumberFormat::operator=(other);
+    BIntegerFormatParameters::operator=(other);
+    return *this;
+}
+
+// constructor
+BIntegerFormat::BIntegerFormat(BIntegerFormatImpl *impl)
+    : BNumberFormat(impl),
+      BIntegerFormatParameters(impl ? impl->DefaultIntegerFormatParameters()
+                                    : NULL)
+{
+}
+
+// IntegerFormatImpl
+inline
+BIntegerFormatImpl *
+BIntegerFormat::IntegerFormatImpl() const
+{
+    return static_cast<BIntegerFormatImpl*>(fImpl);
+}
+

src/kits/locale/cat.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <nl_types.h>
+
+
+nl_catd 
+catopen(const char *name, int oflag)
+{
+    return (nl_catd)1;
+}
+
+
+char *
+catgets(nl_catd cat, int setID, int msgID, const char *defaultMessage)
+{
+    // should return "const char *"...
+    return const_cast<char *>(defaultMessage);
+}
+
+
+int 
+catclose(nl_catd)
+{
+    return 0;
+}
+

src/kits/locale/UnicodeProperties.h

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+#ifndef _UNICODE_PROPERTIES_H_
+#define _UNICODE_PROPERTIES_H_
+
+
+#include <SupportDefs.h>
+#include <ByteOrder.h>
+
+
+#define PROPERTIES_DIRECTORY    "locale"
+#define PROPERTIES_FILE_NAME    "unicode.properties"
+#define PROPERTIES_FORMAT       'UPro'
+
+
+typedef struct {
+    uint8   size;
+    uint8   isBigEndian;
+    uint32  format;
+    uint8   version[3];
+} UnicodePropertiesHeader;
+
+#endif  /* _UNICODE_PROPERTIES_H_ */

src/kits/locale/Catalog.cpp

@@ +1 @@
+/* 
+** Distributed under the terms of the OpenBeOS License.
+** Copyright 2003-2004. All rights reserved.
+**
+** Authors: Axel Dörfler, axeld@pinc-software.de
+**          Oliver Tappe, zooey@hirschkaefer.de
+*/
+
+#include <assert.h>
+#include <syslog.h>
+
+#include <Application.h>
+#include <Catalog.h>
+#include <Locale.h>
+#include <LocaleRoster.h>
+#include <Node.h>
+#include <Roster.h>
+
+
+BCatalog* be_catalog = NULL;
+    // catalog used by translation macros
+BCatalog* be_app_catalog = NULL;
+    // app-catalog (useful for accessing app's catalog from inside an add-on,
+    // since in an add-on, be_catalog will hold the add-on's catalog.
+
+
+//#pragma mark - BCatalog
+BCatalog::BCatalog()
+    :
+    fCatalog(NULL)
+{
+}
+
+
+BCatalog::BCatalog(const char *signature, const char *language, 
+    int32 fingerprint)
+{
+    fCatalog = be_locale_roster->LoadCatalog(signature, language, fingerprint);
+}
+
+
+BCatalog::~BCatalog()
+{
+    if (be_catalog == this)
+        be_app_catalog = be_catalog = NULL;
+    be_locale_roster->UnloadCatalog(fCatalog);
+}
+
+
+const char *
+BCatalog::GetString(const char *string, const char *context, const char *comment)
+{
+    const char *translated;
+    for (BCatalogAddOn* cat = fCatalog; cat != NULL; cat = cat->fNext) {
+        translated = cat->GetString(string, context, comment);
+        if (translated)
+            return translated;
+    }
+    return string;
+}
+
+
+const char *
+BCatalog::GetString(uint32 id)
+{
+    const char *translated;
+    for (BCatalogAddOn* cat = fCatalog; cat != NULL; cat = cat->fNext) {
+        translated = cat->GetString(id);
+        if (translated)
+            return translated;
+    }
+    return "";
+}
+
+
+status_t 
+BCatalog::GetData(const char *name, BMessage *msg)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    status_t res;
+    for (BCatalogAddOn* cat = fCatalog; cat != NULL; cat = cat->fNext) {
+        res = cat->GetData(name, msg);
+        if (res != B_NAME_NOT_FOUND && res != EOPNOTSUPP)
+            return res; 
+                // return B_OK if found, or specific error-code
+    }
+    return B_NAME_NOT_FOUND;
+}
+
+
+status_t 
+BCatalog::GetData(uint32 id, BMessage *msg)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    status_t res;
+    for (BCatalogAddOn* cat = fCatalog; cat != NULL; cat = cat->fNext) {
+        res = cat->GetData(id, msg);
+        if (res != B_NAME_NOT_FOUND && res != EOPNOTSUPP)
+            return res; 
+                // return B_OK if found, or specific error-code
+    }
+    return B_NAME_NOT_FOUND;
+}
+
+
+status_t 
+BCatalog::GetAppCatalog(BCatalog* catalog) 
+{
+    app_info appInfo;
+    if (!be_app || be_app->GetAppInfo(&appInfo) != B_OK)
+        return B_ENTRY_NOT_FOUND;
+    BString sig(appInfo.signature);
+
+    // drop supertype from mimetype (should be "application/"):
+    int32 pos = sig.FindFirst('/');
+    if (pos >= 0)
+        sig.Remove(0, pos+1);
+
+    // try to fetch fingerprint from app-file (attribute):
+    int32 fingerprint = 0;
+    BNode appNode(&appInfo.ref);
+    appNode.ReadAttr(BLocaleRoster::kCatFingerprintAttr, B_INT32_TYPE, 0, 
+        &fingerprint, sizeof(int32));
+    // try to load catalog (with given fingerprint):
+    catalog->fCatalog
+        = be_locale_roster->LoadCatalog(sig.String(), NULL, fingerprint);
+
+    // load native embedded id-based catalog. If such a catalog exists, 
+    // we can fall back to native strings for id-based access, too.
+    BCatalogAddOn *embeddedCatalog 
+        = be_locale_roster->LoadEmbeddedCatalog(&appInfo.ref);
+    if (embeddedCatalog) {
+        if (!catalog->fCatalog)
+            // embedded catalog is the only catalog that was found:
+            catalog->fCatalog = embeddedCatalog;
+        else {
+            // append embedded catalog to list of loaded catalogs:
+            BCatalogAddOn *currCat = catalog->fCatalog;
+            while (currCat->fNext)
+                currCat = currCat->fNext;
+            currCat->fNext = embeddedCatalog;
+        }
+    }
+
+    // make app-catalog the current catalog for translation-macros:
+    be_app_catalog = be_catalog = catalog;
+
+    return catalog->InitCheck();
+}
+
+
+//#pragma mark - BCatalogAddOn
+BCatalogAddOn::BCatalogAddOn(const char *signature, const char *language,
+    int32 fingerprint)
+    :
+    fInitCheck(B_NO_INIT),
+    fSignature(signature),
+    fLanguageName(language),
+    fFingerprint(fingerprint),
+    fNext(NULL)
+{
+    fLanguageName.ToLower();
+        // canonicalize language-name to lowercase
+}
+
+
+BCatalogAddOn::~BCatalogAddOn()
+{
+}
+
+
+void
+BCatalogAddOn::UpdateFingerprint()
+{
+    fFingerprint = 0;
+        // base implementation always yields the same fingerprint,
+        // which means that no version-mismatch detection is possible.
+}
+
+
+status_t 
+BCatalogAddOn::InitCheck() const
+{ 
+    return fInitCheck;
+}
+
+
+bool 
+BCatalogAddOn::CanHaveData() const
+{
+    return false;
+}
+
+
+status_t 
+BCatalogAddOn::GetData(const char *name, BMessage *msg)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::GetData(uint32 id, BMessage *msg)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::SetString(const char *string, const char *translated,
+    const char *context, const char *comment)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::SetString(int32 id, const char *translated)
+{
+    return EOPNOTSUPP;
+}
+
+
+bool 
+BCatalogAddOn::CanWriteData() const
+{
+    return false;
+}
+
+
+status_t 
+BCatalogAddOn::SetData(const char *name, BMessage *msg)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::SetData(uint32 id, BMessage *msg)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::ReadFromFile(const char *path)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::ReadFromAttribute(entry_ref *appOrAddOnRef)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::ReadFromResource(entry_ref *appOrAddOnRef)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::WriteToFile(const char *path)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::WriteToAttribute(entry_ref *appOrAddOnRef)
+{
+    return EOPNOTSUPP;
+}
+
+
+status_t 
+BCatalogAddOn::WriteToResource(entry_ref *appOrAddOnRef)
+{
+    assert(0);
+    return EOPNOTSUPP;
+}
+
+
+void BCatalogAddOn::MakeEmpty()
+{
+}
+
+
+int32 
+BCatalogAddOn::CountItems() const
+{
+    return 0;
+}
+
+
+//#pragma mark - EditableCatalog
+namespace BPrivate {
+EditableCatalog::EditableCatalog(const char *type, const char *signature, 
+    const char *language)
+{
+    fCatalog = be_locale_roster->CreateCatalog(type, signature, language);
+}
+
+
+EditableCatalog::~EditableCatalog()
+{
+}
+
+
+status_t 
+EditableCatalog::SetString(const char *string, const char *translated,
+    const char *context, const char *comment)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->SetString(string, translated, context, comment);
+}
+
+
+status_t 
+EditableCatalog::SetString(int32 id, const char *translated)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->SetString(id, translated);
+}
+
+
+bool 
+EditableCatalog::CanWriteData() const
+{
+    if (!fCatalog)
+        return false;
+    return fCatalog->CanWriteData();
+}
+
+
+status_t 
+EditableCatalog::SetData(const char *name, BMessage *msg)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->SetData(name, msg);
+}
+
+
+status_t 
+EditableCatalog::SetData(uint32 id, BMessage *msg)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->SetData(id, msg);
+}
+
+
+status_t 
+EditableCatalog::ReadFromFile(const char *path)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->ReadFromFile(path);
+}
+
+
+status_t 
+EditableCatalog::ReadFromAttribute(entry_ref *appOrAddOnRef)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->ReadFromAttribute(appOrAddOnRef);
+}
+
+
+status_t 
+EditableCatalog::ReadFromResource(entry_ref *appOrAddOnRef)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->ReadFromResource(appOrAddOnRef);
+}
+
+
+status_t 
+EditableCatalog::WriteToFile(const char *path)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->WriteToFile(path);
+}
+
+
+status_t 
+EditableCatalog::WriteToAttribute(entry_ref *appOrAddOnRef)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->WriteToAttribute(appOrAddOnRef);
+}
+
+
+status_t 
+EditableCatalog::WriteToResource(entry_ref *appOrAddOnRef)
+{
+    if (!fCatalog)
+        return B_NO_INIT;
+    return fCatalog->WriteToResource(appOrAddOnRef);
+}
+
+
+void EditableCatalog::MakeEmpty()
+{
+    if (fCatalog)
+        fCatalog->MakeEmpty();
+}
+
+
+} // namespace BPrivate

src/kits/locale/FloatFormat.cpp

@@ +1 @@
+#include <FloatFormat.h>
+#include <FloatFormatImpl.h>
+
+// copy constructor
+BFloatFormat::BFloatFormat(const BFloatFormat &other)
+    : BNumberFormat(other),
+      BFloatFormatParameters(other)
+{
+}
+
+// destructor
+BFloatFormat::~BFloatFormat()
+{
+}
+
+// Format
+status_t
+BFloatFormat::Format(double number, BString *buffer) const
+{
+    if (!fImpl)
+        return B_NO_INIT;
+    return FloatFormatImpl()->Format(this, number, buffer);
+}
+
+// Format
+status_t
+BFloatFormat::Format(double number, BString *buffer,
+                     format_field_position *positions, int32 positionCount,
+                     int32 *fieldCount, bool allFieldPositions) const
+{
+    if (!fImpl)
+        return B_NO_INIT;
+    return FloatFormatImpl()->Format(this,number, buffer, positions,
+        positionCount, fieldCount, allFieldPositions);
+}
+
+// =
+BFloatFormat &
+BFloatFormat::operator=(const BFloatFormat &other)
+{
+    BNumberFormat::operator=(other);
+    BFloatFormatParameters::operator=(other);
+    return *this;
+}
+
+// constructor
+BFloatFormat::BFloatFormat(BFloatFormatImpl *impl)
+    : BNumberFormat(impl),
+      BFloatFormatParameters(impl ? impl->DefaultFloatFormatParameters()
+                                    : NULL)
+{
+}
+
+// FloatFormatImpl
+inline
+BFloatFormatImpl *
+BFloatFormat::FloatFormatImpl() const
+{
+    return static_cast<BFloatFormatImpl*>(fImpl);
+}
+

src/kits/locale/Collator.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <Collator.h>
+#include <UnicodeChar.h>
+#include <String.h>
+#include <Message.h>
+
+#include <typeinfo>
+#include <ctype.h>
+
+
+// conversion array for character ranges 192 - 223 & 224 - 255
+static const uint8 kNoDiacrits[] = {
+    'a','a','a','a','a','a','a',
+    'c',
+    'e','e','e','e',
+    'i','i','i','i',
+    240,    // eth
+    'n',
+    'o','o','o','o','o',
+    247,    //
+    'o',
+    'u','u','u','u',
+    'y',
+    254,    // thorn
+    'y'
+};
+
+
+static inline uint32
+getPrimaryChar(uint32 c)
+{
+    if (c < 0x80)
+        return tolower(c);
+
+    // this automatically returns lowercase letters
+    if (c >= 192 && c < 223)
+        return kNoDiacrits[c - 192];
+    if (c == 223)   // ß
+        return 's';
+    if (c >= 224 && c < 256)
+        return kNoDiacrits[c - 224];
+
+    return BUnicodeChar::ToLower(c);
+}
+
+
+BCollatorAddOn::input_context::input_context(bool ignorePunctuation)
+    :
+    ignore_punctuation(ignorePunctuation),
+    next_char(0),
+    reserved1(0),
+    reserved2(0)
+{
+}
+
+
+//  #pragma mark -
+
+
+BCollator::BCollator()
+    :
+    fCollatorImage(B_ERROR),
+    fStrength(B_COLLATE_PRIMARY),
+    fIgnorePunctuation(true)
+{
+    // ToDo: the collator construction will have to change; the default
+    //  collator should be constructed by the Locale/LocaleRoster, so we
+    //  only need a constructor where you specify all details
+
+    fCollator = new BCollatorAddOn();
+}
+
+
+BCollator::BCollator(BCollatorAddOn *collator, int8 strength, bool ignorePunctuation)
+    :
+    fCollator(collator),
+    fCollatorImage(B_ERROR),
+    fStrength(strength),
+    fIgnorePunctuation(ignorePunctuation)
+{
+    if (collator == NULL)
+        fCollator = new BCollatorAddOn();
+}
+
+
+BCollator::BCollator(BMessage *archive)
+    : BArchivable(archive),
+    fCollator(NULL),
+    fCollatorImage(B_ERROR)
+{
+    int32 data;
+    if (archive->FindInt32("loc:strength", &data) == B_OK)
+        fStrength = (uint8)data;
+    else
+        fStrength = B_COLLATE_PRIMARY;
+
+    if (archive->FindBool("loc:punctuation", &fIgnorePunctuation) != B_OK)
+        fIgnorePunctuation = true;
+
+    BMessage collatorArchive;
+    if (archive->FindMessage("loc:collator", &collatorArchive) == B_OK) {
+        BArchivable *unarchived = instantiate_object(&collatorArchive, &fCollatorImage);
+
+        // do we really have a BCollatorAddOn here?
+        fCollator = dynamic_cast<BCollatorAddOn *>(unarchived);
+        if (fCollator == NULL)
+            delete unarchived;
+    }
+
+    if (fCollator == NULL) {
+        fCollator = new BCollatorAddOn();
+        fCollatorImage = B_ERROR;
+    }
+}
+
+
+BCollator::~BCollator()
+{
+    delete fCollator;
+
+    if (fCollatorImage >= B_OK)
+        unload_add_on(fCollatorImage);
+}
+
+
+void
+BCollator::SetDefaultStrength(int8 strength)
+{
+    fStrength = strength;
+}
+
+
+int8
+BCollator::DefaultStrength() const
+{
+    return fStrength;
+}
+
+
+void
+BCollator::SetIgnorePunctuation(bool ignore)
+{
+    fIgnorePunctuation = ignore;
+}
+
+
+bool
+BCollator::IgnorePunctuation() const
+{
+    return fIgnorePunctuation;
+}
+
+
+status_t
+BCollator::GetSortKey(const char *string, BString *key, int8 strength)
+{
+    if (strength == B_COLLATE_DEFAULT)
+        strength = fStrength;
+
+    return fCollator->GetSortKey(string, key, strength, fIgnorePunctuation);
+}
+
+
+int
+BCollator::Compare(const char *a, const char *b, int32 length, int8 strength)
+{
+    if (length == -1)   // match the whole string
+        length = 0x7fffffff;
+
+    return fCollator->Compare(a, b, length,
+                strength == B_COLLATE_DEFAULT ? fStrength : strength, fIgnorePunctuation);
+}
+
+
+status_t 
+BCollator::Archive(BMessage *archive, bool deep) const
+{
+    status_t status = BArchivable::Archive(archive, deep);
+    if (status < B_OK)
+        return status;
+
+    if (status == B_OK)
+        status = archive->AddInt32("loc:strength", fStrength);
+    if (status == B_OK)
+        status = archive->AddBool("loc:punctuation", fIgnorePunctuation);
+
+    BMessage collatorArchive;
+    if (status == B_OK && deep
+        && typeid(*fCollator) != typeid(BCollatorAddOn)
+            // only archive subclasses from BCollatorAddOn
+        && (status = fCollator->Archive(&collatorArchive, true)) == B_OK)
+        status = archive->AddMessage("loc:collator", &collatorArchive);
+
+    return status;
+}
+
+
+BArchivable *
+BCollator::Instantiate(BMessage *archive)
+{
+    if (validate_instantiation(archive, "BCollator"))
+        return new BCollator(archive);
+
+    return NULL;
+}
+
+
+//  #pragma mark -
+
+
+BCollatorAddOn::BCollatorAddOn()
+{
+}
+
+
+BCollatorAddOn::BCollatorAddOn(BMessage *archive)
+    : BArchivable(archive)
+{
+}
+
+
+BCollatorAddOn::~BCollatorAddOn()
+{
+}
+
+
+/** This returns the next Unicode character from the UTF-8 encoded
+ *  input string, and bumps it to the next character.
+ *  It will ignore punctuation if specified by the context, and
+ *  might substitute characters if needed.
+ */
+
+uint32
+BCollatorAddOn::GetNextChar(const char **string, input_context &context)
+{
+    uint32 c = context.next_char;
+    if (c != 0) {
+        context.next_char = 0;
+        return c;
+    }
+
+    do {
+        c = BUnicodeChar::FromUTF8(string);
+    } while (context.ignore_punctuation
+        && (BUnicodeChar::IsPunctuation(c) || BUnicodeChar::IsSpace(c)));
+
+    if (c == 223) {
+        context.next_char = 's';
+        return 's';
+    }
+
+    return c;
+}
+
+
+/** Fills the specified buffer with the primary sort key. The buffer
+ *  has to be long enough to hold the key.
+ *  It returns the position in the buffer immediately after the key;
+ *  it does not add a terminating null byte!
+ */
+
+char *
+BCollatorAddOn::PutPrimaryKey(const char *string, char *buffer, int32 length,
+    bool ignorePunctuation)
+{
+    input_context context(ignorePunctuation);
+
+    uint32 c;
+    for (int32 i = 0; (c = GetNextChar(&string, context)) != 0 && i < length; i++) {
+        if (c < 0x80)
+            *buffer++ = tolower(c);
+        else
+            BUnicodeChar::ToUTF8(getPrimaryChar(c), &buffer);
+    }
+
+    return buffer;
+}
+
+
+size_t 
+BCollatorAddOn::PrimaryKeyLength(size_t length)
+{
+    return length * 2;
+        // the primary key needs to make space for doubled characters (like 'ß')
+}
+
+
+status_t 
+BCollatorAddOn::GetSortKey(const char *string, BString *key, int8 strength,
+    bool ignorePunctuation)
+{
+    if (strength >= B_COLLATE_QUATERNARY) {
+        // the difference between tertiary and quaternary collation strength
+        // are usually a different handling of punctuation characters
+        ignorePunctuation = false;
+    }
+
+    size_t length = strlen(string);
+
+    switch (strength) {
+        case B_COLLATE_PRIMARY:
+        {
+            char *begin = key->LockBuffer(PrimaryKeyLength(length));
+            if (begin == NULL)
+                return B_NO_MEMORY;
+
+            char *end = PutPrimaryKey(string, begin, length, ignorePunctuation);
+            *end = '\0';
+
+            key->UnlockBuffer(end - begin);
+            break;
+        }
+
+        case B_COLLATE_SECONDARY:
+        {
+            char *begin = key->LockBuffer(PrimaryKeyLength(length) + length + 1);
+                // the primary key + the secondary key + separator char
+            if (begin == NULL)
+                return B_NO_MEMORY;
+
+            char *buffer = PutPrimaryKey(string, begin, length, ignorePunctuation);
+            *buffer++ = '\01';
+                // separator
+
+            input_context context(ignorePunctuation);
+            uint32 c;
+            for (uint32 i = 0; (c = GetNextChar(&string, context)) && i < length; i++) {
+                if (c < 0x80)
+                    *buffer++ = tolower(c);
+                else
+                    BUnicodeChar::ToUTF8(BUnicodeChar::ToLower(c), &buffer);
+            }
+            *buffer = '\0';
+
+            key->UnlockBuffer(buffer - begin);
+            break;
+        }
+
+        case B_COLLATE_TERTIARY:
+        case B_COLLATE_QUATERNARY:
+        {
+            char *begin = key->LockBuffer(PrimaryKeyLength(length) + length + 1);
+                // the primary key + the tertiary key + separator char
+            if (begin == NULL)
+                return B_NO_MEMORY;
+
+            char *buffer = PutPrimaryKey(string, begin, length, ignorePunctuation);
+            *buffer++ = '\01';
+                // separator
+
+            input_context context(ignorePunctuation);
+            uint32 c;
+            for (uint32 i = 0; (c = GetNextChar(&string, context)) && i < length; i++) {
+                BUnicodeChar::ToUTF8(c, &buffer);
+            }
+            *buffer = '\0';
+
+            key->UnlockBuffer(buffer + length - begin);
+            break;
+        }
+
+        case B_COLLATE_IDENTICAL:
+        default:
+            key->SetTo(string, length);
+                // is there any way to check if BString::SetTo() actually succeeded?
+            break;
+    }
+    return B_OK;
+}
+
+
+int 
+BCollatorAddOn::Compare(const char *a, const char *b, int32 length, int8 strength,
+    bool ignorePunctuation)
+{
+    if (strength >= B_COLLATE_QUATERNARY) {
+        // the difference between tertiary and quaternary collation strength
+        // are usually a different handling of punctuation characters
+        ignorePunctuation = false;
+    }
+
+    input_context contextA(ignorePunctuation);
+    input_context contextB(ignorePunctuation);
+
+    switch (strength) {
+        case B_COLLATE_PRIMARY:
+        {
+            for (int32 i = 0; i < length; i++) {
+                uint32 charA = GetNextChar(&a, contextA);
+                uint32 charB = GetNextChar(&b, contextB);
+                if (charA == 0)
+                    return charB == 0 ? 0 : -(int32)charB;
+                else if (charB == 0)
+                    return (int32)charA;
+
+                charA = getPrimaryChar(charA);
+                charB = getPrimaryChar(charB);
+
+                if (charA != charB)
+                    return (int32)charA - (int32)charB;
+            }
+            return 0;
+        }
+
+        case B_COLLATE_SECONDARY:
+        {
+            // diacriticals can only change the order between equal strings
+            int32 compare = Compare(a, b, length, B_COLLATE_PRIMARY, ignorePunctuation);
+            if (compare != 0)
+                return compare;
+
+            for (int32 i = 0; i < length; i++) {
+                uint32 charA = BUnicodeChar::ToLower(GetNextChar(&a, contextA));
+                uint32 charB = BUnicodeChar::ToLower(GetNextChar(&b, contextB));
+
+                // the two strings does have the same size when we get here
+                if (charA == 0)
+                    return 0;
+
+                if (charA != charB)
+                    return (int32)charA - (int32)charB;
+            }
+            return 0;
+        }
+
+        case B_COLLATE_TERTIARY:
+        case B_COLLATE_QUATERNARY:
+        {
+            // diacriticals can only change the order between equal strings
+            int32 compare = Compare(a, b, length, B_COLLATE_PRIMARY, ignorePunctuation);
+            if (compare != 0)
+                return compare;
+
+            for (int32 i = 0; i < length; i++) {
+                uint32 charA = GetNextChar(&a, contextA);
+                uint32 charB = GetNextChar(&b, contextB);
+
+                // the two strings does have the same size when we get here
+                if (charA == 0)
+                    return 0;
+
+                if (charA != charB)
+                    return (int32)charA - (int32)charB;
+            }
+            return 0;
+        }
+
+        case B_COLLATE_IDENTICAL:
+        default:
+            return strncmp(a, b, length);
+    }
+}
+
+
+status_t 
+BCollatorAddOn::Archive(BMessage *archive, bool deep) const
+{
+    return BArchivable::Archive(archive, deep);
+}
+
+
+BArchivable *
+BCollatorAddOn::Instantiate(BMessage *archive)
+{
+    if (validate_instantiation(archive, "BCollatorAddOn"))
+        return new BCollatorAddOn(archive);
+
+    return NULL;
+}
+

src/kits/locale/OpenHashTable.h

@@ +1 @@
+/*
+Open Tracker License
+
+Terms and Conditions
+
+Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice applies to all licensees
+and shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Be Incorporated shall not be
+used in advertising or otherwise to promote the sale, use or other dealings in
+this Software without prior written authorization from Be Incorporated.
+
+Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
+of Be Incorporated in the United States and other countries. Other brand product
+names are registered trademarks or trademarks of their respective holders.
+All rights reserved.
+*/
+
+// Hash table with open addresssing
+
+#ifndef __OPEN_HASH_TABLE__
+#define __OPEN_HASH_TABLE__
+
+#include <malloc.h>
+#include <new.h>
+
+namespace BPrivate {
+
+template <class Element>
+class ElementVector {
+    // element vector for OpenHashTable needs to implement this
+    // interface
+    public:
+        Element &At(int32 index);
+        Element *Add();
+        int32 IndexOf(const Element &) const;
+        void Remove(int32 index);
+};
+
+class OpenHashElement {
+    public:
+        uint32 Hash() const;
+        bool operator==(const OpenHashElement &) const;
+        void Adopt(OpenHashElement &);
+            // low overhead copy, original element is in undefined state
+            // after call (calls Adopt on BString members, etc.)
+        int32 fNext;
+};
+
+const uint32 kPrimes [] = {
+    509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139,
+    524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859,
+    134217689, 268435399, 536870909, 1073741789, 2147483647, 0
+};
+
+template <class Element, class ElementVec = ElementVector<Element> >
+class OpenHashTable {
+    public:
+        OpenHashTable(int32 minSize, ElementVec *elementVector = 0);
+            // it is up to the subclass of OpenHashTable to supply
+            // elementVector
+        ~OpenHashTable();
+
+        void SetElementVector(ElementVec *elementVector);
+
+        Element *FindFirst(uint32 elementHash) const;
+        Element &Add(uint32 elementHash);
+
+        void Remove(Element *);
+
+        // when calling Add, any outstanding element pointer may become
+        // invalid; to deal with this, get the element index and restore
+        // it after the add
+        int32 ElementIndex(const Element *) const;
+        Element *ElementAt(int32 index) const;
+
+        int32 VectorSize() const;
+
+    protected:
+        static int32 OptimalSize(int32 minSize);
+
+        int32 fArraySize;
+        int32 *fHashArray;
+        ElementVec *fElementVector;
+};
+
+
+template <class Element>
+class OpenHashElementArray : public ElementVector<Element> {
+    // this is a straightforward implementation of an element vector
+    // deleting is handled by linking deleted elements into a free list
+    // the vector never shrinks
+    public:
+        OpenHashElementArray(int32 initialSize);
+        ~OpenHashElementArray();
+
+        Element &At(int32 index);
+        const Element &At(int32 index) const;
+        int32 Add(const Element &);
+        int32 Add();
+        void Remove(int32 index);
+        int32 IndexOf(const Element &) const;
+        int32 Size() const;
+
+    private:
+        Element *fData;
+        int32 fSize;
+        int32 fNextFree;
+        int32 fNextDeleted;
+};
+
+
+//--- inline implementation --------------------------------
+
+
+template<class Element, class ElementVec>
+OpenHashTable<Element, ElementVec>::OpenHashTable(int32 minSize,ElementVec *elementVector)
+    :
+    fArraySize(OptimalSize(minSize)),
+    fElementVector(elementVector)
+{
+    fHashArray = new int32[fArraySize];
+    for (int32 index = 0; index < fArraySize; index++)
+        fHashArray[index] = -1;
+}
+
+
+template<class Element, class ElementVec>
+OpenHashTable<Element, ElementVec>::~OpenHashTable()
+{
+    delete fHashArray;
+}
+
+
+template<class Element, class ElementVec>
+int32 
+OpenHashTable<Element, ElementVec>::OptimalSize(int32 minSize)
+{
+    for (int32 index = 0; ; index++)
+        if (!kPrimes[index] || kPrimes[index] >= (uint32)minSize)
+            return (int32)kPrimes[index];
+
+    return 0;
+}
+
+
+template<class Element, class ElementVec>
+Element *
+OpenHashTable<Element, ElementVec>::FindFirst(uint32 hash) const
+{
+    ASSERT(fElementVector);
+    hash %= fArraySize;
+    if (fHashArray[hash] < 0)
+        return 0;
+    
+    return &fElementVector->At(fHashArray[hash]);
+}
+
+
+template<class Element, class ElementVec>
+int32 
+OpenHashTable<Element, ElementVec>::ElementIndex(const Element *element) const
+{
+    return fElementVector->IndexOf(*element);
+}
+
+
+template<class Element, class ElementVec>
+Element *
+OpenHashTable<Element, ElementVec>::ElementAt(int32 index) const
+{
+    return &fElementVector->At(index);
+}
+
+
+template<class Element, class ElementVec>
+int32 
+OpenHashTable<Element, ElementVec>::VectorSize() const
+{
+     return fElementVector->Size();
+}
+
+
+template<class Element, class ElementVec>
+Element &
+OpenHashTable<Element, ElementVec>::Add(uint32 hash)
+{
+    ASSERT(fElementVector);
+    hash %= fArraySize;
+    Element &result = *fElementVector->Add();
+    result.fNext = fHashArray[hash];
+    fHashArray[hash] = fElementVector->IndexOf(result);
+    return result;
+}
+
+
+template<class Element, class ElementVec>
+void 
+OpenHashTable<Element, ElementVec>::Remove(Element *element)
+{
+    uint32 hash = element->Hash() % fArraySize;
+    int32 next = fHashArray[hash];
+    ASSERT(next >= 0);
+
+    if (&fElementVector->At(next) == element) {
+        fHashArray[hash] = element->fNext;
+        fElementVector->Remove(next);
+        return;
+    }
+
+    for (int32 index = next; index >= 0; ) {
+        // look for an existing match in table
+        int32 next = fElementVector->At(index).fNext;
+        if (next < 0) {
+            TRESPASS();
+            return;
+        }
+
+        if (&fElementVector->At(next) == element) {
+            fElementVector->At(index).fNext = element->fNext;
+            fElementVector->Remove(next);
+            return;
+        }
+        index = next;
+    }
+}
+
+
+template<class Element, class ElementVec>
+void 
+OpenHashTable<Element, ElementVec>::SetElementVector(ElementVec *elementVector)
+{
+    fElementVector = elementVector;
+}
+
+
+template<class Element>
+OpenHashElementArray<Element>::OpenHashElementArray(int32 initialSize)
+    :
+    fSize(initialSize),
+    fNextFree(0),
+    fNextDeleted(-1)
+{
+    fData = (Element *)calloc((size_t)initialSize , sizeof(Element));
+    if (!fData)
+        throw bad_alloc();
+}
+
+
+template<class Element>
+OpenHashElementArray<Element>::~OpenHashElementArray()
+{
+    free(fData);
+}
+
+
+template<class Element>
+Element &
+OpenHashElementArray<Element>::At(int32 index)
+{
+    ASSERT(index < fSize);
+    return fData[index];
+}
+
+
+template<class Element>
+const Element &
+OpenHashElementArray<Element>::At(int32 index) const
+{
+    ASSERT(index < fSize);
+    return fData[index];
+}
+
+
+template<class Element>
+int32 
+OpenHashElementArray<Element>::IndexOf(const Element &element) const
+{
+    int32 result = &element - fData;
+    if (result < 0 || result > fSize)
+        return -1;
+    
+    return result;
+}
+
+
+template<class Element>
+int32 
+OpenHashElementArray<Element>::Size() const
+{
+    return fSize;
+}
+
+
+template<class Element>
+int32 
+OpenHashElementArray<Element>::Add(const Element &newElement)
+{
+    int32 index = Add();
+    At(index).Adopt(newElement);
+    return index;
+}
+
+
+#if DEBUG
+const int32 kGrowChunk = 10;
+#else
+const int32 kGrowChunk = 1024;
+#endif
+
+
+template<class Element>
+int32 
+OpenHashElementArray<Element>::Add()
+{
+    int32 index = fNextFree;
+    if (fNextDeleted >= 0) {
+        index = fNextDeleted;
+        fNextDeleted = At(index).fNext;     
+    } else if (fNextFree >= fSize - 1) {
+        int32 newSize = fSize + kGrowChunk;
+        Element *newData = (Element *)calloc((size_t)newSize , sizeof(Element));
+        if (!fData)
+            throw bad_alloc();
+        memcpy(newData, fData, fSize * sizeof(Element));
+        free(fData);
+        fData = newData;
+        fSize = newSize;
+        index = fNextFree;
+        fNextFree++;
+    } else
+        fNextFree++;
+
+    new (&At(index)) Element;
+        // call placement new to initialize the element properly
+    ASSERT(At(index).fNext == -1);
+
+    return index;       
+}
+
+
+template<class Element>
+void 
+OpenHashElementArray<Element>::Remove(int32 index)
+{
+    // delete by chaining empty elements in a single linked
+    // list, reusing the next field
+    ASSERT(index < fSize);
+    At(index).~Element();
+        // call the destructor explicitly to destroy the element
+        // properly
+    At(index).fNext = fNextDeleted;
+    fNextDeleted = index;
+}
+
+} // namespace BPrivate
+
+using namespace BPrivate;
+
+#endif

src/kits/locale/NumberFormatImpl.cpp

@@ +1 @@
+#include <NumberFormatImpl.h>
+#include <NumberFormatParameters.h>
+
+// constructor
+BNumberFormatImpl::BNumberFormatImpl()
+    : BFormatImpl()
+{
+}
+
+// destructor
+BNumberFormatImpl::~BNumberFormatImpl()
+{
+}
+
+// DefaultFormatParameters
+BFormatParameters *
+BNumberFormatImpl::DefaultFormatParameters()
+{
+    return DefaultNumberFormatParameters();
+}
+
+// DefaultFormatParameters
+const BFormatParameters *
+BNumberFormatImpl::DefaultFormatParameters() const
+{
+    return DefaultNumberFormatParameters();
+}
+

src/kits/locale/Language.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <Language.h>
+
+#include <Path.h>
+#include <FindDirectory.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+
+static const char *gBuiltInStrings[] = {
+    "Yesterday",
+    "Today",
+    "Tomorrow",
+    "Future",
+    
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    
+    "Sun",
+    "Mon",
+    "Tue",
+    "Wed",
+    "Thu",
+    "Fri",
+    "Sat",
+    
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+    
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+    
+    "^[yY]",
+    "^[nN]",
+    "yes",
+    "no"
+};
+
+
+static char *
+TrimCopy(char *string)
+{
+    while (isspace(*string))
+        string++;
+
+    int32 length = strlen(string);
+    while (length-- > 0 && isspace(string[length]))
+        string[length] = '\0';
+
+    if (length < 0)
+        return NULL;
+
+    return strdup(string);
+}
+
+
+//  #pragma mark -
+
+
+BLanguage::BLanguage(const char *language)
+    :
+    fName(NULL),
+    fCode(NULL),
+    fFamily(NULL),
+    fDirection(B_LEFT_TO_RIGHT)
+{
+    for (int32 i = B_NUM_LANGUAGE_STRINGS;i-- > 0;)
+        fStrings[i] = NULL;
+
+    if (language == NULL) {
+        Default();
+        return;
+    }
+
+    char name[B_FILE_NAME_LENGTH];
+    sprintf(name, "locale/languages/%s.language", language);
+
+    BPath path;
+    if (find_directory(B_BEOS_ETC_DIRECTORY, &path) < B_OK) {
+        Default();
+        return;
+    }
+
+    path.Append(name);
+
+    FILE *file = fopen(path.Path(), "r");
+    if (file == NULL) {
+        Default();
+        return;
+    }
+
+    int32 count = -2;
+    while (fgets(name, B_FILE_NAME_LENGTH, file) != NULL) {
+        if (count == -2) {
+            char *family = strchr(name, ',');
+            if (family == NULL)
+                break;
+            *family++ = '\0';
+
+            // set the direction of writing         
+            char *direction = strchr(family, ',');
+            if (direction != NULL) {
+                *direction++ = '\0';
+                direction = TrimCopy(direction);
+
+                if (!strcasecmp(direction, "ltr"))
+                    fDirection = B_LEFT_TO_RIGHT;
+                else if (!strcasecmp(direction, "rtl"))
+                    fDirection = B_RIGHT_TO_LEFT;
+                else if (!strcasecmp(direction, "ttb"))
+                    fDirection = B_TOP_TO_BOTTOM;
+
+                free(direction);
+            }
+
+            fName = strdup(language);
+            fCode = TrimCopy(name);
+            fFamily = TrimCopy(family);
+            count++;
+        } else if (count == -1) {
+            if (!strcmp(name,"--\n"))
+                count++;
+        } else if (count < B_NUM_LANGUAGE_STRINGS) {
+            char *string = TrimCopy(name);
+            if (string == NULL)
+                continue;
+
+            fStrings[count++] = string; 
+        }
+    }
+
+    if (count < 0)
+        Default();
+
+    fclose(file);
+}
+
+
+BLanguage::~BLanguage()
+{
+    if (fName != NULL) 
+        free(fName);
+    if (fCode != NULL)
+        free(fCode);
+    if (fFamily != NULL)
+        free(fFamily);
+
+    for (int32 i = B_NUM_LANGUAGE_STRINGS;i-- > 0;)
+        free(fStrings[i]);
+}
+
+
+void
+BLanguage::Default()
+{
+    fName = strdup("english");
+    fCode = strdup("en");
+    fFamily = strdup("germanic");
+    fDirection = B_LEFT_TO_RIGHT;
+
+    for (int32 i = B_NUM_LANGUAGE_STRINGS;i-- > 0;) {
+        free(fStrings[i]);
+        fStrings[i] = strdup(gBuiltInStrings[i]);
+    }
+}
+
+
+uint8 
+BLanguage::Direction() const
+{
+    return fDirection;
+}
+
+
+const char *
+BLanguage::GetString(uint32 id) const
+{
+    if (id < B_LANGUAGE_STRINGS_BASE || id > B_LANGUAGE_STRINGS_BASE + B_NUM_LANGUAGE_STRINGS)
+        return NULL;
+
+    return fStrings[id - B_LANGUAGE_STRINGS_BASE];
+}
+

src/kits/locale/PropertyFile.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include "PropertyFile.h"
+#include "UnicodeProperties.h"
+
+#include <Path.h>
+#include <FindDirectory.h>
+
+#if B_BEOS_VERSION <= B_BEOS_VERSION_5 && !defined(__HAIKU__)
+// B_BAD_DATA was introduced with DANO, so we define it for R5:
+#   define B_BAD_DATA -2147483632L
+#endif
+
+
+status_t
+PropertyFile::SetTo(const char *directory, const char *name)
+{
+    BPath path;
+    status_t status = find_directory(B_BEOS_ETC_DIRECTORY, &path);
+    if (status < B_OK)
+        return status;
+
+    path.Append(directory);
+    path.Append(name);
+    status = BFile::SetTo(path.Path(), B_READ_ONLY);
+    if (status < B_OK)
+        return status;
+
+    UnicodePropertiesHeader header;
+    ssize_t bytes = Read(&header, sizeof(header));
+    if (bytes < (ssize_t)sizeof(header)
+        || header.size != (uint8)sizeof(header)
+        || header.isBigEndian != B_HOST_IS_BENDIAN
+        || header.format != PROPERTIES_FORMAT)
+        return B_BAD_DATA;
+
+    return B_OK;
+}
+
+
+off_t 
+PropertyFile::Size()
+{
+    off_t size;
+    if (GetSize(&size) < B_OK)
+        return 0;
+
+    return size - sizeof(UnicodePropertiesHeader);
+}
+

src/kits/locale/UnicodeChar.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+/* Reads the information out of the data files created by (an edited version of)
+ * IBM's ICU genprops utility. The BUnicodeChar class is mostly the counterpart
+ * to ICU's uchar module, but is not as huge or broad as that one.
+ *
+ * Note, it probably won't be able to handle the output of the orginal genprops
+ * tool and vice versa - only use the tool provided with this project to create
+ * the Unicode property file.
+ * However, the algorithmic idea behind the property file is still the same as
+ * found in ICU - nothing important has been changed, so more recent versions
+ * of genprops tool/data can probably be ported without too much effort.
+ *
+ * In case no property file can be found it will still provide basic services
+ * for the Latin-1 part of the character tables.
+ */
+
+
+#include <OS.h>
+
+#include <UnicodeChar.h>
+#include "UnicodeProperties.h"
+#include "PropertyFile.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+
+#if B_BEOS_VERSION <= B_BEOS_VERSION_5 && !defined(__HAIKU__)
+// B_BAD_DATA was introduced with DANO, so we define it for R5:
+#define B_BAD_DATA -2147483632L
+#endif
+
+static const uint16 *sPropsTable = NULL;
+#define sProps32Table ((uint32 *)sPropsTable)
+static uint16 *sIndices;
+static vint32 sHavePropsData = 0;
+
+#define FLAG(n) ((uint32)1 << (n))
+enum {
+    UF_UPPERCASE        = FLAG(B_UNICODE_UPPERCASE_LETTER),
+    UF_LOWERCASE        = FLAG(B_UNICODE_LOWERCASE_LETTER),
+    UF_TITLECASE        = FLAG(B_UNICODE_TITLECASE_LETTER),
+    UF_MODIFIER_LETTER  = FLAG(B_UNICODE_MODIFIER_LETTER),
+    UF_OTHER_LETTER     = FLAG(B_UNICODE_OTHER_LETTER),
+    UF_DECIMAL_NUMBER   = FLAG(B_UNICODE_DECIMAL_DIGIT_NUMBER),
+    UF_OTHER_NUMBER     = FLAG(B_UNICODE_OTHER_NUMBER),
+    UF_LETTER_NUMBER    = FLAG(B_UNICODE_LETTER_NUMBER)
+};
+
+
+static uint32 gStaticProps32Table[] = {
+    /* 0x00 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x04 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x08 */  0x48f,      0x20c,      0x1ce,      0x20c,
+    /* 0x0c */  0x24d,      0x1ce,      0x48f,      0x48f,
+    /* 0x10 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x14 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x18 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x1c */  0x1ce,      0x1ce,      0x1ce,      0x20c,
+    /* 0x20 */  0x24c,      0x297,      0x297,      0x117,
+    /* 0x24 */  0x119,      0x117,      0x297,      0x297,
+    /* 0x28 */  0x100a94,   0xfff00a95, 0x297,      0x118,
+    /* 0x2c */  0x197,      0x113,      0x197,      0xd7,
+    /* 0x30 */  0x89,       0x100089,   0x200089,   0x300089,
+    /* 0x34 */  0x400089,   0x500089,   0x600089,   0x700089,
+    /* 0x38 */  0x800089,   0x900089,   0x197,      0x297,
+    /* 0x3c */  0x200a98,   0x298,      0xffe00a98, 0x297,
+    /* 0x40 */  0x297,      0x2000001,  0x2000001,  0x2000001,
+    /* 0x44 */  0x2000001,  0x2000001,  0x2000001,  0x2000001,
+    /* 0x48 */  0x2000001,  0x2000001,  0x2000001,  0x2000001,
+    /* 0x4c */  0x2000001,  0x2000001,  0x2000001,  0x2000001,
+    /* 0x50 */  0x2000001,  0x2000001,  0x2000001,  0x2000001,
+    /* 0x54 */  0x2000001,  0x2000001,  0x2000001,  0x2000001,
+    /* 0x58 */  0x2000001,  0x2000001,  0x2000001,  0x200a94,
+    /* 0x5c */  0x297,      0xffe00a95, 0x29a,      0x296,
+    /* 0x60 */  0x29a,      0x2000002,  0x2000002,  0x2000002,
+    /* 0x64 */  0x2000002,  0x2000002,  0x2000002,  0x2000002,
+    /* 0x68 */  0x2000002,  0x2000002,  0x2000002,  0x2000002,
+    /* 0x6c */  0x2000002,  0x2000002,  0x2000002,  0x2000002,
+    /* 0x70 */  0x2000002,  0x2000002,  0x2000002,  0x2000002,
+    /* 0x74 */  0x2000002,  0x2000002,  0x2000002,  0x2000002,
+    /* 0x78 */  0x2000002,  0x2000002,  0x2000002,  0x200a94,
+    /* 0x7c */  0x298,      0xffe00a95, 0x298,      0x48f,
+    /* 0x80 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x84 */  0x48f,      0x1ce,      0x48f,      0x48f,
+    /* 0x88 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x8c */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x90 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x94 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x98 */  0x48f,      0x48f,      0x48f,      0x48f,
+    /* 0x9c */  0x48f,      0x48f,      0x48f,      0x48f
+};
+
+enum {
+    INDEX_STAGE_2_BITS,
+    INDEX_STAGE_3_BITS,
+    INDEX_EXCEPTIONS,
+    INDEX_STAGE_3_INDEX,
+    INDEX_PROPS,
+    INDEX_UCHARS
+};
+
+/* constants and macros for access to the data */
+enum {
+    EXC_UPPERCASE,
+    EXC_LOWERCASE,
+    EXC_TITLECASE,
+    EXC_DIGIT_VALUE,
+    EXC_NUMERIC_VALUE,
+    EXC_DENOMINATOR_VALUE,
+    EXC_MIRROR_MAPPING,
+    EXC_SPECIAL_CASING,
+    EXC_CASE_FOLDING
+};
+
+enum {
+    EXCEPTION_SHIFT = 5,
+    BIDI_SHIFT,
+    MIRROR_SHIFT    = BIDI_SHIFT + 5,
+    VALUE_SHIFT     = 20,
+
+    VALUE_BITS      = 32 - VALUE_SHIFT
+};
+
+/* number of bits in an 8-bit integer value */
+#define EXC_GROUP 8
+static uint8 gFlagsOffset[256] = {
+    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+};
+
+#ifdef UCHAR_VARIABLE_TRIE_BITS
+    // access values calculated from indices
+    static uint16_t stage23Bits, stage2Mask, stage3Mask;
+#   define sStage3Bits   indexes[INDEX_STAGE_3_BITS]
+#else
+    // Use hardcoded bit distribution for the trie table access
+#   define sStage23Bits  10
+#   define sStage2Mask   0x3f
+#   define sStage3Mask   0xf
+#   define sStage3Bits   4
+#endif
+
+
+/** We need to change the char category for ISO 8 controls, since the
+ *  genprops utility we got from IBM's ICU apparently changes it for
+ *  some characters.
+ */
+
+static inline bool
+isISO8Control(uint32 c)
+{
+    return ((uint32)c < 0x20 || (uint32)(c - 0x7f) <= 0x20);
+}
+
+
+static inline uint32
+getProperties(uint32 c)
+{
+    if (c > 0x10ffff)
+        return 0;
+
+    if (sHavePropsData > 0)
+        return sProps32Table[sPropsTable[
+                    sPropsTable[sPropsTable[8 + (c >> sStage23Bits)]
+                        + ((c >> sStage3Bits) & sStage2Mask)]
+                    + (c & sStage3Mask)]];
+
+    return c > 0x9f ? 0 : gStaticProps32Table[c];
+}
+
+
+static inline uint8
+getCategory(uint32 properties)
+{
+    return properties & 0x1f;
+}
+
+
+static inline bool
+propertyIsException(uint32 properties)
+{
+    return properties & (1UL << EXCEPTION_SHIFT);
+}
+
+
+static inline uint32
+getUnsignedValue(uint32 properties)
+{
+    return properties >> VALUE_SHIFT;
+}
+
+
+static inline uint32
+getSignedValue(uint32 properties)
+{
+    return (int32)properties >> VALUE_SHIFT;
+}
+
+
+static inline uint32 *
+getExceptions(uint32 properties)
+{
+    return sProps32Table + sIndices[INDEX_EXCEPTIONS] + getUnsignedValue(properties);
+}
+
+
+static inline bool
+haveExceptionValue(uint32 flags,int16 index)
+{
+    return flags & (1UL << index);
+}
+
+
+static inline void
+addExceptionOffset(uint32 &flags, int16 &index, uint32 **offset)
+{
+    if (index >= EXC_GROUP) {
+        *offset += gFlagsOffset[flags & ((1 << EXC_GROUP) - 1)];
+        flags >>= EXC_GROUP;
+        index -= EXC_GROUP;
+    }
+    *offset += gFlagsOffset[flags & ((1 << index) - 1)];
+}
+
+
+static status_t
+loadPropsData()
+{
+    PropertyFile file;
+    status_t status = file.SetTo(PROPERTIES_DIRECTORY, PROPERTIES_FILE_NAME);
+    if (status < B_OK) {
+        fprintf(stderr, "could not open unicode.properties file: %s\n", strerror(status));
+        return status;
+    }
+
+    off_t size = file.Size();
+    uint16 *table = (uint16 *)malloc(size);
+    if (table == NULL)
+        return B_NO_MEMORY;
+
+    if (file.Read(table, size) < size) {
+        free(table);
+        return B_IO_ERROR;
+    }
+
+    // check if the property file matches our needs
+    if (table[INDEX_STAGE_2_BITS] != 6 || table[INDEX_STAGE_3_BITS] != 4) {
+        free(table);
+        return B_BAD_DATA;
+    }
+
+    sIndices = table;
+#ifdef UCHAR_VARIABLE_TRIE_BITS
+    sStage23Bits = uint16(sIndices[INDEX_STAGE_2_BITS] + sIndices[INDEX_STAGE_3_BITS]);
+    sStage2Mask = uint16((1 << sIndices[INDEX_STAGE_2_BITS]) - 1);
+    sStage3Mask = uint16((1 << sIndices[INDEX_STAGE_3_BITS]) - 1);
+#endif
+
+    sPropsTable = table;
+    sHavePropsData = 1;
+
+    return B_OK;
+}
+
+
+//  #pragma mark -
+
+
+/** If the constructor is used for the first time, the property
+ *  file gets loaded from disk.
+ *  It makes sure that this will only happen once throughout the
+ *  application's lifetime.
+ */
+
+BUnicodeChar::BUnicodeChar()
+{
+    static int32 lock = 0;
+
+    if (atomic_add(&lock, 1) > 0) {
+        while (sHavePropsData == 0)
+            snooze(10000);
+
+        return;
+    }
+    if (loadPropsData() < B_OK)
+        sHavePropsData = -1;
+}
+
+
+bool 
+BUnicodeChar::IsAlpha(uint32 c)
+{
+    BUnicodeChar();
+    return (FLAG(getCategory(getProperties(c)))
+            & (UF_UPPERCASE | UF_LOWERCASE | UF_TITLECASE | UF_MODIFIER_LETTER | UF_OTHER_LETTER)
+           ) != 0;
+}
+
+
+/** Returns the type code of the specified unicode character */
+
+int8
+BUnicodeChar::Type(uint32 c)
+{
+    BUnicodeChar();
+    return (int8)getCategory(getProperties(c));
+}
+
+
+bool 
+BUnicodeChar::IsLower(uint32 c)
+{
+    BUnicodeChar();
+    return getCategory(getProperties(c)) == B_UNICODE_LOWERCASE_LETTER;
+}
+
+
+bool 
+BUnicodeChar::IsUpper(uint32 c)
+{
+    BUnicodeChar();
+    return getCategory(getProperties(c)) == B_UNICODE_UPPERCASE_LETTER;
+}
+
+
+bool 
+BUnicodeChar::IsTitle(uint32 c)
+{
+    BUnicodeChar();
+    return getCategory(getProperties(c)) == B_UNICODE_TITLECASE_LETTER;
+}
+
+
+bool 
+BUnicodeChar::IsDigit(uint32 c)
+{
+    BUnicodeChar();
+    return (FLAG(getCategory(getProperties(c)))
+            & (UF_DECIMAL_NUMBER | UF_OTHER_NUMBER | UF_LETTER_NUMBER)
+           ) != 0;
+}
+
+
+bool 
+BUnicodeChar::IsAlNum(uint32 c)
+{
+    BUnicodeChar();
+    return (FLAG(getCategory(getProperties(c)))
+            & (UF_DECIMAL_NUMBER | UF_OTHER_NUMBER | UF_LETTER_NUMBER | UF_UPPERCASE
+               | UF_LOWERCASE | UF_TITLECASE | UF_MODIFIER_LETTER | UF_OTHER_LETTER)
+           ) != 0;
+}
+
+
+bool 
+BUnicodeChar::IsDefined(uint32 c)
+{
+    BUnicodeChar();
+    return getProperties(c) != 0;
+}
+
+
+/** Returns true if the specified unicode character is a base
+ *  form character that can be used with a diacritic.
+ *  This doesn't mean that the character has to be distinct,
+ *  though.
+ */
+
+bool 
+BUnicodeChar::IsBase(uint32 c)
+{
+    BUnicodeChar();
+    return (FLAG(getCategory(getProperties(c)))
+            & (UF_DECIMAL_NUMBER | UF_OTHER_NUMBER | UF_LETTER_NUMBER 
+               | UF_UPPERCASE | UF_LOWERCASE | UF_TITLECASE
+               | UF_MODIFIER_LETTER | UF_OTHER_LETTER | FLAG(B_UNICODE_NON_SPACING_MARK)
+               | FLAG(B_UNICODE_ENCLOSING_MARK) | FLAG(B_UNICODE_COMBINING_SPACING_MARK))
+           ) != 0;
+}
+
+
+/** Returns true if the specified unicode character is a
+ *  control character.
+ */
+
+bool 
+BUnicodeChar::IsControl(uint32 c)
+{
+    BUnicodeChar();
+    return isISO8Control(c)
+            || (FLAG(getCategory(getProperties(c)))
+                & (FLAG(B_UNICODE_CONTROL_CHAR) | FLAG(B_UNICODE_FORMAT_CHAR)
+                    | FLAG(B_UNICODE_LINE_SEPARATOR) | FLAG(B_UNICODE_PARAGRAPH_SEPARATOR))
+               ) != 0;
+}
+
+
+/** Returns true if the specified unicode character is a
+ *  punctuation character.
+ */
+
+bool
+BUnicodeChar::IsPunctuation(uint32 c)
+{
+    BUnicodeChar();
+    return (FLAG(getCategory(getProperties(c)))
+            & (FLAG(B_UNICODE_DASH_PUNCTUATION)
+                | FLAG(B_UNICODE_START_PUNCTUATION)
+                | FLAG(B_UNICODE_END_PUNCTUATION)
+                | FLAG(B_UNICODE_CONNECTOR_PUNCTUATION)
+                | FLAG(B_UNICODE_OTHER_PUNCTUATION))
+            ) != 0;
+}
+
+
+/** Returns true if the specified unicode character is some
+ *  kind of a space character.
+ */
+
+bool 
+BUnicodeChar::IsSpace(uint32 c)
+{
+    BUnicodeChar();
+    return (FLAG(getCategory(getProperties(c)))
+            & (FLAG(B_UNICODE_SPACE_SEPARATOR)
+                | FLAG(B_UNICODE_LINE_SEPARATOR)
+                | FLAG(B_UNICODE_PARAGRAPH_SEPARATOR))
+           ) != 0;
+}
+
+
+/** Returns true if the specified unicode character is a white
+ *  space character.
+ *  This is essentially the same as IsSpace(), but excludes all
+ *  non-breakable spaces.
+ */
+
+bool 
+BUnicodeChar::IsWhitespace(uint32 c)
+{
+    BUnicodeChar();
+    return (FLAG(getCategory(getProperties(c)))
+            & (FLAG(B_UNICODE_SPACE_SEPARATOR)
+                | FLAG(B_UNICODE_LINE_SEPARATOR)
+                | FLAG(B_UNICODE_PARAGRAPH_SEPARATOR))
+           ) != 0 && c != 0xa0 && c != 0x202f && c != 0xfeff; // exclude non-breakable spaces
+}
+
+
+/** Returns true if the specified unicode character is printable.
+ */
+
+bool 
+BUnicodeChar::IsPrintable(uint32 c)
+{
+    BUnicodeChar();
+    return !isISO8Control(c)
+            && (FLAG(getCategory(getProperties(c)))
+                & ~(FLAG(B_UNICODE_UNASSIGNED) | FLAG(B_UNICODE_CONTROL_CHAR)
+                    | FLAG(B_UNICODE_FORMAT_CHAR) | FLAG(B_UNICODE_PRIVATE_USE_CHAR)
+                    | FLAG(B_UNICODE_SURROGATE) | FLAG(B_UNICODE_GENERAL_OTHER_TYPES)
+                    | FLAG(31))
+                   ) != 0;
+}
+
+
+//  #pragma mark -
+
+
+/** Transforms the specified unicode character to lowercase.
+ */
+
+uint32 
+BUnicodeChar::ToLower(uint32 c)
+{
+    BUnicodeChar();
+
+    uint32 props = getProperties(c);
+
+    if (!propertyIsException(props)) {
+        if (FLAG(getCategory(props)) & (UF_UPPERCASE | UF_TITLECASE))
+            return c + getSignedValue(props);
+    } else {
+        uint32 *exceptions = getExceptions(props);
+        uint32 firstExceptionValue = *exceptions;
+
+        if (haveExceptionValue(firstExceptionValue, EXC_LOWERCASE)) {
+            int16 index = EXC_LOWERCASE;
+            addExceptionOffset(firstExceptionValue, index, &++exceptions);
+            return *exceptions;
+        }
+    }
+    // no mapping found, just return the character unchanged
+    return c;
+}
+
+
+/** Transforms the specified unicode character to uppercase.
+ */
+
+uint32 
+BUnicodeChar::ToUpper(uint32 c)
+{
+    BUnicodeChar();
+
+    uint32 props = getProperties(c);
+
+    if (!propertyIsException(props)) {
+        if (getCategory(props) == B_UNICODE_LOWERCASE_LETTER)
+            return c - getSignedValue(props);
+    } else {
+        uint32 *exceptions = getExceptions(props);
+        uint32 firstExceptionValue = *exceptions;
+
+        if (haveExceptionValue(firstExceptionValue, EXC_UPPERCASE)) {
+            int16 index = EXC_UPPERCASE;
+            ++exceptions;
+            addExceptionOffset(firstExceptionValue, index, &exceptions);
+            return *exceptions;
+        }
+    }
+    // no mapping found, just return the character unchanged
+    return c;
+}
+
+
+/** Transforms the specified unicode character to title case.
+ */
+
+uint32 
+BUnicodeChar::ToTitle(uint32 c)
+{
+    BUnicodeChar();
+
+    uint32 props = getProperties(c);
+
+    if (!propertyIsException(props)) {
+        if (getCategory(props) == B_UNICODE_LOWERCASE_LETTER) {
+            // here, titlecase is the same as uppercase
+            return c - getSignedValue(props);
+        }
+    } else {
+        uint32 *exceptions = getExceptions(props);
+        uint32 firstExceptionValue = *exceptions;
+
+        if (haveExceptionValue(firstExceptionValue, EXC_TITLECASE)) {
+            int16 index = EXC_TITLECASE;
+            addExceptionOffset(firstExceptionValue, index, &++exceptions);
+            return (uint32)*exceptions;
+        } else if (haveExceptionValue(firstExceptionValue, EXC_UPPERCASE)) {
+            // here, titlecase is the same as uppercase
+            int16 index = EXC_UPPERCASE;
+            addExceptionOffset(firstExceptionValue, index, &++exceptions);
+            return *exceptions;
+        }
+    }
+    // no mapping found, just return the character unchanged
+    return c;
+}
+
+
+int32 
+BUnicodeChar::DigitValue(uint32 c)
+{
+    BUnicodeChar();
+
+    uint32 props = getProperties(c);
+
+    if (!propertyIsException(props)) {
+        if (getCategory(props) == B_UNICODE_DECIMAL_DIGIT_NUMBER)
+            return getSignedValue(props);
+    } else {
+        uint32 *exceptions = getExceptions(props);
+        uint32 firstExceptionValue = *exceptions;
+
+        if (haveExceptionValue(firstExceptionValue, EXC_DIGIT_VALUE)) {
+            int16 index = EXC_DIGIT_VALUE;
+            addExceptionOffset(firstExceptionValue, index, &++exceptions);
+
+            int32 value = (int32)(int16)*exceptions;
+                 // the digit value is in the lower 16 bits
+            if (value != -1)
+                return value;
+        }
+    }
+
+    // If there is no value in the properties table,
+    // then check for some special characters
+    switch (c) {
+        case 0x3007:    return 0;
+        case 0x4e00:    return 1;
+        case 0x4e8c:    return 2;
+        case 0x4e09:    return 3;
+        case 0x56d8:    return 4;
+        case 0x4e94:    return 5;
+        case 0x516d:    return 6;
+        case 0x4e03:    return 7;
+        case 0x516b:    return 8;
+        case 0x4e5d:    return 9;
+        default:        return -1;
+    }
+}
+
+
+void
+BUnicodeChar::ToUTF8(uint32 c, char **out)
+{
+    char *s = *out;
+
+    if (c < 0x80)
+        *(s++) = c;
+    else if (c < 0x800) {
+        *(s++) = 0xc0 | (c >> 6);
+        *(s++) = 0x80 | (c & 0x3f);
+    } else if (c < 0x10000) {
+        *(s++) = 0xe0 | (c >> 12);
+        *(s++) = 0x80 | ((c >> 6) & 0x3f);
+        *(s++) = 0x80 | (c & 0x3f);
+    } else if (c <= 0x10ffff) {
+        *(s++) = 0xf0 | (c >> 18);
+        *(s++) = 0x80 | ((c >> 12) & 0x3f);
+        *(s++) = 0x80 | ((c >> 6) & 0x3f);
+        *(s++) = 0x80 | (c & 0x3f);
+    }
+    *out = s;
+}
+
+
+uint32 
+BUnicodeChar::FromUTF8(const char **in)
+{
+    uint8 *bytes = (uint8 *)*in;
+    if (bytes == NULL)
+        return 0;
+
+    int32 length;
+    uint8 mask = 0x1f;
+
+    switch (bytes[0] & 0xf0) {
+        case 0xc0:
+        case 0xd0:  length = 2; break;
+        case 0xe0:  length = 3; break;
+        case 0xf0:
+            mask = 0x0f;
+            length = 4;
+            break;
+        default:
+            // valid 1-byte character
+            // and invalid characters
+            (*in)++;
+            return bytes[0];
+    }
+    uint32 c = bytes[0] & mask;
+    int32 i = 1;
+    for (;i < length && (bytes[i] & 0x80) > 0;i++)
+        c = (c << 6) | (bytes[i] & 0x3f);
+
+    if (i < length) {
+        // invalid character
+        (*in)++;
+        return (uint32)bytes[0];
+    }
+    *in += length;
+    return c;
+}
+
+size_t
+BUnicodeChar::UTF8StringLength(const char *str)
+{
+    size_t len = 0;
+    while (*str) {
+        FromUTF8(&str);
+        len++;
+    }
+    return len;
+}
+
+size_t
+BUnicodeChar::UTF8StringLength(const char *str, size_t maxLength)
+{
+    size_t len = 0;
+    while (len < maxLength && *str) {
+        FromUTF8(&str);
+        len++;
+    }
+    return len;
+}
+

src/kits/locale/NumberFormatParameters.cpp

@@ +1 @@
+#include <NumberFormatParameters.h>
+
+// defaults
+static const bool kDefaultUseGrouping = false;
+static const number_format_sign_policy kDefaultSignPolicy
+    = B_USE_NEGATIVE_SIGN_ONLY;
+static const number_format_base kDefaultBase = B_DEFAULT_BASE;
+static const bool kDefaultUseBasePrefix = false;
+static const size_t kDefaultMinimalIntegerDigits = 1;
+static const bool kDefaultUseZeroPadding = false;
+
+// flags
+enum {
+    USE_GROUPING_SET            = 0x01,
+    SIGN_POLICY_SET             = 0x02,
+    BASE_SET                    = 0x04,
+    USE_BASE_PREFIX_SET         = 0x08,
+    MINIMAL_INTEGER_DIGITS_SET  = 0x10,
+    USE_ZERO_PADDING_SET        = 0x20,
+};
+
+// constructor
+BNumberFormatParameters::BNumberFormatParameters(
+    const BNumberFormatParameters *parent)
+    : BFormatParameters(parent),
+      fParent(parent),
+      fFlags(0)
+{
+}
+
+// copy constructor
+BNumberFormatParameters::BNumberFormatParameters(
+    const BNumberFormatParameters &other)
+    : BFormatParameters(other),
+      fParent(other.fParent),
+      fUseGrouping(other.fUseGrouping),
+      fSignPolicy(other.fSignPolicy),
+      fBase(other.fBase),
+      fUseBasePrefix(other.fUseBasePrefix),
+      fMinimalIntegerDigits(other.fMinimalIntegerDigits),
+      fFlags(other.fFlags)
+{
+}
+
+// destructor
+BNumberFormatParameters::~BNumberFormatParameters()
+{
+}
+
+// SetUseGrouping
+void
+BNumberFormatParameters::SetUseGrouping(bool useGrouping)
+{
+    fUseGrouping = useGrouping;
+    fFlags |= USE_GROUPING_SET;
+}
+
+// UseGrouping
+bool
+BNumberFormatParameters::UseGrouping() const
+{
+    if (fFlags & USE_GROUPING_SET)
+        return fUseGrouping;
+    if (fParent)
+        return fParent->UseGrouping();
+    return kDefaultUseGrouping;
+}
+
+// SetSignPolicy
+void
+BNumberFormatParameters::SetSignPolicy(number_format_sign_policy policy)
+{
+    fSignPolicy = policy;
+    fFlags |= SIGN_POLICY_SET;
+}
+
+// SignPolicy
+number_format_sign_policy
+BNumberFormatParameters::SignPolicy() const
+{
+    if (fFlags & SIGN_POLICY_SET)
+        return fSignPolicy;
+    if (fParent)
+        return fParent->SignPolicy();
+    return kDefaultSignPolicy;
+}
+
+// SetBase
+void
+BNumberFormatParameters::SetBase(number_format_base base)
+{
+    fBase = base;
+    fFlags |= BASE_SET;
+}
+
+// Base
+number_format_base
+BNumberFormatParameters::Base() const
+{
+    if (fFlags & BASE_SET)
+        return fBase;
+    if (fParent)
+        return fParent->Base();
+    return kDefaultBase;
+}
+
+// SetUseBasePrefix
+void
+BNumberFormatParameters::SetUseBasePrefix(bool useBasePrefix)
+{
+    fUseBasePrefix = useBasePrefix;
+    fFlags |= USE_BASE_PREFIX_SET;
+}
+
+// UseBasePrefix
+bool
+BNumberFormatParameters::UseBasePrefix() const
+{
+    if (fFlags & USE_BASE_PREFIX_SET)
+        return fUseBasePrefix;
+    if (fParent)
+        return fParent->UseBasePrefix();
+    return kDefaultUseBasePrefix;
+}
+
+// SetMinimalIntegerDigits
+void
+BNumberFormatParameters::SetMinimalIntegerDigits(size_t minIntegerDigits)
+{
+    fMinimalIntegerDigits = minIntegerDigits;
+    fFlags |= MINIMAL_INTEGER_DIGITS_SET;
+}
+
+// MinimalIntegerDigits
+size_t
+BNumberFormatParameters::MinimalIntegerDigits() const
+{
+    if (fFlags & MINIMAL_INTEGER_DIGITS_SET)
+        return fMinimalIntegerDigits;
+    if (fParent)
+        return fParent->MinimalIntegerDigits();
+    return kDefaultMinimalIntegerDigits;
+}
+
+// SetUseZeroPadding
+void
+BNumberFormatParameters::SetUseZeroPadding(bool useZeroPadding)
+{
+    fUseZeroPadding = useZeroPadding;
+    fFlags |= USE_ZERO_PADDING_SET;
+}
+
+// UseZeroPadding
+bool
+BNumberFormatParameters::UseZeroPadding() const
+{
+    if (fFlags & USE_ZERO_PADDING_SET)
+        return fUseZeroPadding;
+    if (fParent)
+        return fParent->UseZeroPadding();
+    return kDefaultUseZeroPadding;
+}
+
+// SetParentNumberParameters
+void
+BNumberFormatParameters::SetParentNumberParameters(
+    const BNumberFormatParameters *parent)
+{
+    fParent = parent;
+    SetParentParameters(parent);
+}
+
+// ParentNumberParameters
+const BNumberFormatParameters *
+BNumberFormatParameters::ParentNumberParameters() const
+{
+    return fParent;
+}
+
+// =
+BNumberFormatParameters &
+BNumberFormatParameters::operator=(const BNumberFormatParameters &other)
+{
+    BFormatParameters::operator=(other);
+    fParent = other.fParent;
+    fUseGrouping = other.fUseGrouping;
+    fSignPolicy = other.fSignPolicy;
+    fBase = other.fBase;
+    fUseBasePrefix = other.fUseBasePrefix;
+    fMinimalIntegerDigits = other.fMinimalIntegerDigits;
+    fFlags = other.fFlags;
+    return *this;
+}
+

src/kits/locale/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src kits locale ;
+
+DEFINES += _BUILDING_locale=1 ;
+
+UsePublicHeaders [ FDirName $(HAIKU_TOP) headers os storage ] ;
+
+UseHeaders [ FDirName $(HAIKU_TOP) headers os locale ] : true ;
+UseHeaders [ FDirName $(HAIKU_TOP) headers os locale posix ] : true ;
+
+SharedLibrary liblocale.so
+    : adler32.c
+      cat.cpp
+      Catalog.cpp
+      Collator.cpp
+      Country.cpp
+      Currency.cpp
+      DefaultCatalog.cpp
+      FloatFormat.cpp
+      FloatFormatImpl.cpp
+      FloatFormatParameters.cpp
+      Format.cpp
+      FormatImpl.cpp
+      FormatParameters.cpp
+      GenericNumberFormat.cpp
+      IntegerFormat.cpp
+      IntegerFormatImpl.cpp
+      IntegerFormatParameters.cpp
+      langinfo.cpp
+      Language.cpp
+      LibraryInit.cpp
+      Locale.cpp
+      LocaleRoster.cpp
+      NumberFormat.cpp
+      NumberFormatImpl.cpp
+      NumberFormatParameters.cpp
+      PropertyFile.cpp
+      strfmon.cpp
+      UnicodeChar.cpp
+    : be
+;
+

src/kits/locale/strfmon.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <SupportDefs.h>
+
+#include <errno.h>
+
+#include <monetary.h>
+#include <locale.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+
+// ToDo: implementation is not yet working!
+
+
+enum strfmon_flags {
+    USE_GROUPING        = 1,
+    USE_SIGN            = 2,
+    USE_LOCALE_POSNEG   = 4,
+    NEG_IN_PARENTHESES  = 8,
+    NO_CURRENCY         = 16,
+    LEFT_JUSTIFIED      = 32,
+    USE_INT_CURRENCY    = 64
+};
+
+
+static int32
+parseNumber(const char **_format)
+{
+    const char *format = *_format;
+    int32 number = 0;
+    while (isdigit(*format))
+        number = number * 10 + *format++ - '0';
+
+    *_format = format;
+    return number;
+}
+
+
+ssize_t
+vstrfmon(char *string, size_t maxSize, const char *format, va_list args)
+{
+    if (format == NULL || string == NULL)
+        return B_BAD_VALUE;
+
+    struct lconv *lconv = localeconv();
+    int32 length = 0;
+
+    while (*format) {
+        if (format[0] != '%' || *++format == '%') {
+            if (++length >= (int32)maxSize)
+                return E2BIG;
+
+            *string++ = *format++;
+            continue;
+        }
+        if (format[0] == '\0')
+            return B_BAD_VALUE;
+
+        char flags = USE_GROUPING | USE_LOCALE_POSNEG;
+        char fill = ' ';
+        int32 width = 0, leftPrecision = 0, rightPrecision = -1;
+        bool isNegative = false;
+
+        // flags
+        int32 mode = 0;
+        while (*format && mode == 0) {
+            switch (*format++) {
+                case '=':
+                    fill = *format++;
+                    if (fill == '\0')
+                        return B_BAD_VALUE;
+                    break;
+                case '+':
+                    if (flags & USE_SIGN)
+                        return B_BAD_VALUE;
+                    flags |= USE_SIGN;
+                    break;
+                case '(':
+                    if (flags & USE_SIGN)
+                        return B_BAD_VALUE;
+                    flags |= USE_SIGN | NEG_IN_PARENTHESES;
+                    break;
+                case '^':
+                    flags &= ~USE_GROUPING;
+                    break;
+                case '!':
+                    flags |= NO_CURRENCY;
+                    break;
+                case '-':
+                    flags |= LEFT_JUSTIFIED;
+                    break;
+                default:
+                    mode = 1;
+            }
+        }
+
+        // width
+        if (isdigit(*format))
+            width = parseNumber(&format);
+
+        // left precision
+        if (*format == '#') {
+            format++;
+            if (!isdigit(*format))
+                return B_BAD_VALUE;
+
+            leftPrecision = parseNumber(&format);
+        }
+
+        // right precision
+        if (*format == '.') {
+            format++;
+            if (!isdigit(*format))
+                return B_BAD_VALUE;
+
+            rightPrecision = parseNumber(&format);
+        }
+
+        // which currency symbol to use?
+        switch (*format++) {
+            case 'n':
+                // national currency symbol is the default
+                break;
+            case 'i':
+                flags |= USE_INT_CURRENCY;
+                break;
+            default:
+                return B_BAD_VALUE;
+        }
+
+        // adjust the default right precision value according the currency symbol
+        if (rightPrecision == -1) {
+            rightPrecision = flags & USE_INT_CURRENCY ? lconv->int_frac_digits : lconv->frac_digits;
+            if (rightPrecision == CHAR_MAX)
+                rightPrecision = 2;
+        }
+
+        double value = va_arg(args,double);
+        if (value < 0) {
+            isNegative = true;
+            value = -value;
+        }
+
+        if (leftPrecision + rightPrecision > 255)
+            return B_BAD_VALUE;
+
+        char number[256];
+        sprintf(number, "%*.*f", (int)leftPrecision, (int)rightPrecision,
+                value);
+
+        if (leftPrecision >= 0) {
+            
+        }
+    }
+    return B_OK;
+}
+
+
+ssize_t
+strfmon(char *string, size_t maxSize, const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    
+    ssize_t status = vstrfmon(string, maxSize, format, args);
+    
+    va_end(args);
+
+    if (status < B_OK) {
+        errno = status;
+        return -1;
+    }
+    return status;
+}
+

src/kits/locale/Currency.cpp

@@ +1 @@
+#include <Currency.h>
+
+// message archive field names
+static const char *kArchivedCurrencyCodeName    = "be:currency code";
+static const char *kArchivedDefaultSymbol       = "be:default symbol";
+static const char *kArchivedDefaultFractionDigits
+    = "be:default fraction digits";
+
+// constructor
+BCurrency::BCurrency(const BCurrency &other)
+    : fCurrencyCode(),
+      fDefaultSymbol(),
+      fDefaultFractionDigits(B_NO_INIT)
+{
+    *this = other;
+}
+
+// constructor
+BCurrency::BCurrency(BMessage *archive)
+    : fCurrencyCode(),
+      fDefaultSymbol(),
+      fDefaultFractionDigits(B_NO_INIT)
+{
+    if (archive->FindString(kArchivedCurrencyCodeName, &fCurrencyCode)
+            == B_OK
+        && archive->FindString(kArchivedDefaultSymbol, &fDefaultSymbol)
+            == B_OK
+        && archive->FindInt32(kArchivedDefaultFractionDigits,
+                              &fDefaultFractionDigits) == B_OK
+        && _CheckData()) {
+        // everything went fine
+    } else
+        _Unset(B_NO_INIT);
+}
+
+// constructor
+BCurrency::BCurrency(const char *currencyCode)
+{
+    // TODO: load currency from disk
+}
+
+// destructor
+BCurrency::~BCurrency()
+{
+}
+
+// InitCheck
+status_t
+BCurrency::InitCheck() const
+{
+    return (fDefaultFractionDigits < 0 ? fDefaultFractionDigits : B_OK);
+}
+
+// Archive
+status_t
+BCurrency::Archive(BMessage *archive, bool deep) const
+{
+    status_t error = BArchivable::Archive(archive, deep);
+    if (error == B_OK) {
+        if (archive->AddString(kArchivedCurrencyCodeName, fCurrencyCode)
+                == B_OK
+            && archive->AddString(kArchivedDefaultSymbol, fDefaultSymbol)
+                == B_OK
+            && archive->AddInt32(kArchivedDefaultFractionDigits,
+                                 fDefaultFractionDigits) == B_OK) {
+            // everything went fine
+        } else
+            error = B_ERROR;
+    }
+    return error;
+}
+
+// Instantiate
+_EXPORT
+BArchivable *
+BCurrency::Instantiate(BMessage *archive)
+{
+    if (!validate_instantiation(archive, "BCurrency"))
+        return NULL;
+    return new BCurrency(archive);
+}
+
+// CurrencyCode
+const char *
+BCurrency::CurrencyCode() const
+{
+    return (InitCheck() == B_OK ? fCurrencyCode.String() : NULL);
+}
+
+// DefaultSymbol
+const char *
+BCurrency::DefaultSymbol() const
+{
+    return (InitCheck() == B_OK ? fDefaultSymbol.String() : NULL);
+}
+
+// DefaultFractionDigits
+int32
+BCurrency::DefaultFractionDigits() const
+{
+    return (InitCheck() == B_OK ? fDefaultFractionDigits : 0);
+}
+
+// GetSymbol
+status_t
+BCurrency::GetSymbol(char *symbol, size_t maxSize, BLocale *locale)
+{
+    // check initialization and parameters
+    if (InitCheck() != B_OK)
+        return B_NO_INIT;
+    if (symbol == NULL)
+        return B_BAD_VALUE;
+    // TODO: get symbol from locale
+    // fall back to the default symbol
+    if ((int32)maxSize <= fDefaultSymbol.Length())
+        return EOVERFLOW;   // OpenBeOS: B_BUFFER_OVERFLOW
+    strcpy(symbol, fDefaultSymbol.String());
+    return B_OK;
+}
+
+// GetSymbol
+status_t
+BCurrency::GetSymbol(BString *symbol, BLocale *locale)
+{
+    // check initialization and parameters
+    if (InitCheck() != B_OK)
+        return B_NO_INIT;
+    if (symbol == NULL)
+        return B_BAD_VALUE;
+    // TODO: get symbol from locale
+    // fall back to the default symbol
+    *symbol = fDefaultSymbol;
+    if (symbol->Length() != fDefaultSymbol.Length())
+        return B_NO_MEMORY;
+    return B_OK;
+}
+
+// =
+BCurrency &
+BCurrency::operator=(const BCurrency &other)
+{
+    if (other.InitCheck() == B_OK) {
+        fCurrencyCode = other.fCurrencyCode;
+        fDefaultSymbol = other.fDefaultSymbol;
+        fDefaultFractionDigits = other.fDefaultFractionDigits;
+        if (!_CheckData())
+            _Unset(B_NO_MEMORY);
+    } else
+        _Unset(B_NO_MEMORY);
+    return *this;
+}
+
+// ==
+bool
+BCurrency::operator==(const BCurrency &other) const
+{
+    if (InitCheck() != B_OK || other.InitCheck() != B_OK)
+        return false;
+    return (fCurrencyCode == other.fCurrencyCode);
+}
+
+// !=
+bool
+BCurrency::operator!=(const BCurrency &other) const
+{
+    return !(*this == other);
+}
+
+// constructor
+BCurrency::BCurrency()
+{
+    // privatized to make it unaccessible
+}
+
+// _CheckData
+bool
+BCurrency::_CheckData() const
+{
+    return (fDefaultFractionDigits >= 0
+        && fCurrencyCode.Length() > 0
+        && fDefaultSymbol.Length() == 0);
+}
+
+// _Unset
+void
+BCurrency::_Unset(status_t error)
+{
+    fCurrencyCode.Truncate(0);
+    fDefaultSymbol.Truncate(0);
+    fDefaultFractionDigits = error;
+}
+

src/kits/locale/langinfo.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <Locale.h>
+#include <langinfo.h>
+
+
+char * nl_langinfo(nl_item id)
+{
+    if (be_locale != NULL)
+        be_locale->GetString(id);
+
+    // ToDo: return default values! 
+    return "";
+}
+

src/kits/locale/LocaleRoster.cpp

@@ +1 @@
+/* 
+** Distributed under the terms of the OpenBeOS License.
+** Copyright 2003-2004. All rights reserved.
+**
+** Authors: Axel Dörfler, axeld@pinc-software.de
+**          Oliver Tappe, zooey@hirschkaefer.de
+*/
+
+#include <assert.h>
+#include <stdio.h>      // for debug only
+#include <syslog.h>
+
+#include <Autolock.h>
+#include <Catalog.h>
+#include <Collator.h>
+#include <Country.h>
+#include <DefaultCatalog.h>
+#include <Directory.h>
+#include <Entry.h>
+#include <FindDirectory.h>
+#include <Language.h>
+#include <Locale.h>
+#include <LocaleRoster.h>
+#include <Node.h>
+#include <Path.h>
+#include <String.h>
+
+static const char *kPriorityAttr = "ADDON:priority";
+
+typedef BCatalogAddOn *(*InstantiateCatalogFunc)(const char *name, 
+    const char *language, int32 fingerprint);
+
+typedef BCatalogAddOn *(*CreateCatalogFunc)(const char *name, 
+    const char *language);
+
+typedef BCatalogAddOn *(*InstantiateEmbeddedCatalogFunc)(entry_ref *appOrAddOnRef);
+
+static BLocaleRoster gLocaleRoster;
+BLocaleRoster *be_locale_roster = &gLocaleRoster;
+
+
+/*
+ * info about a single catalog-add-on (representing a catalog type):
+ */
+struct BCatalogAddOnInfo {
+    BString fName;
+    BString fPath;
+    image_id fAddOnImage;
+    InstantiateCatalogFunc fInstantiateFunc;
+    InstantiateEmbeddedCatalogFunc fInstantiateEmbeddedFunc;
+    CreateCatalogFunc fCreateFunc;
+    uint8 fPriority;
+    BList fLoadedCatalogs;
+    bool fIsEmbedded;
+        // an embedded add-on actually isn't an add-on, it is included
+        // as part of the library. The DefaultCatalog is such a beast!
+
+    BCatalogAddOnInfo(const BString& name, const BString& path, uint8 priority);
+    ~BCatalogAddOnInfo();
+    bool MakeSureItsLoaded();
+    void UnloadIfPossible();
+};
+
+
+BCatalogAddOnInfo::BCatalogAddOnInfo(const BString& name, const BString& path, 
+    uint8 priority)
+    :   
+    fName(name),
+    fPath(path),
+    fAddOnImage(B_NO_INIT),
+    fInstantiateFunc(NULL),
+    fInstantiateEmbeddedFunc(NULL),
+    fCreateFunc(NULL),
+    fPriority(priority),
+    fIsEmbedded(path.Length()==0)
+{
+}
+
+
+BCatalogAddOnInfo::~BCatalogAddOnInfo()
+{
+    int32 count = fLoadedCatalogs.CountItems();
+    for (int32 i=0; i<count; ++i) {
+        BCatalogAddOn* cat 
+            = static_cast<BCatalogAddOn*>(fLoadedCatalogs.ItemAt(i));
+        delete cat;
+    }
+    fLoadedCatalogs.MakeEmpty();
+    UnloadIfPossible();
+}
+    
+
+bool
+BCatalogAddOnInfo::MakeSureItsLoaded() 
+{
+    if (!fIsEmbedded && fAddOnImage < B_OK) {
+        // add-on has not been loaded yet, so we try to load it:
+        BString fullAddOnPath(fPath);
+        fullAddOnPath << "/" << fName;
+        fAddOnImage = load_add_on(fullAddOnPath.String());
+        if (fAddOnImage >= B_OK) {
+            get_image_symbol(fAddOnImage, "instantiate_catalog",
+                B_SYMBOL_TYPE_TEXT, (void **)&fInstantiateFunc);
+            get_image_symbol(fAddOnImage, "instantiate_embedded_catalog",
+                B_SYMBOL_TYPE_TEXT, (void **)&fInstantiateEmbeddedFunc);
+            get_image_symbol(fAddOnImage, "create_catalog",
+                B_SYMBOL_TYPE_TEXT, (void **)&fCreateFunc);
+            log_team(LOG_DEBUG, "catalog-add-on %s has been loaded",
+                fName.String());
+        } else {
+            log_team(LOG_DEBUG, "could not load catalog-add-on %s (%s)",
+                fName.String(), strerror(fAddOnImage));
+            return false;
+        }
+    }
+    return true;
+}
+
+
+void
+BCatalogAddOnInfo::UnloadIfPossible() 
+{
+    if (!fIsEmbedded && fLoadedCatalogs.IsEmpty()) {
+        unload_add_on(fAddOnImage);
+        fAddOnImage = B_NO_INIT;
+        fInstantiateFunc = NULL;
+        fInstantiateEmbeddedFunc = NULL;
+        fCreateFunc = NULL;
+        log_team(LOG_DEBUG, "catalog-add-on %s has been unloaded",
+            fName.String());
+    }
+}
+
+
+/*
+ * the global data that is shared between all roster-objects:
+ */
+struct RosterData {
+    BLocker fLock;
+    BList fCatalogAddOnInfos;
+    BMessage fPreferredLanguages;
+    //
+    RosterData();
+    ~RosterData();
+    void InitializeCatalogAddOns();
+    void CleanupCatalogAddOns();
+    static int CompareInfos(const void *left, const void *right);
+};
+static RosterData gRosterData;
+
+
+RosterData::RosterData()
+    :
+    fLock("LocaleRosterData")
+{
+    BAutolock lock(fLock);
+    assert(lock.IsLocked());
+
+    // ToDo: make a decision about log-facility and -options
+    openlog_team("liblocale.so", LOG_PID, LOG_USER);
+#ifndef DEBUG
+    // ToDo: find out why the following bugger isn't working!
+    setlogmask_team(LOG_UPTO(LOG_WARNING));
+#endif
+
+    InitializeCatalogAddOns();
+
+    // ToDo: change this to fetch preferred languages from prefs
+    fPreferredLanguages.AddString("language", "german-swiss");
+    fPreferredLanguages.AddString("language", "german");
+    fPreferredLanguages.AddString("language", "english");
+}
+
+
+RosterData::~RosterData()
+{
+    BAutolock lock(fLock);
+    assert(lock.IsLocked());
+    CleanupCatalogAddOns();
+    closelog();
+}
+
+
+int
+RosterData::CompareInfos(const void *left, const void *right)
+{
+    return ((BCatalogAddOnInfo*)right)->fPriority 
+        - ((BCatalogAddOnInfo*)left)->fPriority;
+}
+
+
+/*
+ * iterate over add-on-folders and collect information about each 
+ * catalog-add-ons (types of catalogs) into fCatalogAddOnInfos.
+ */
+void 
+RosterData::InitializeCatalogAddOns() 
+{
+    BAutolock lock(fLock);
+    assert(lock.IsLocked());
+
+    // add info about embedded default catalog:
+    BCatalogAddOnInfo *defaultCatalogAddOnInfo
+        = new BCatalogAddOnInfo("Default", "", 
+             DefaultCatalog::kDefaultCatalogAddOnPriority);
+    defaultCatalogAddOnInfo->fInstantiateFunc = DefaultCatalog::Instantiate;
+    defaultCatalogAddOnInfo->fInstantiateEmbeddedFunc 
+        = DefaultCatalog::InstantiateEmbedded;
+    defaultCatalogAddOnInfo->fCreateFunc = DefaultCatalog::Create;
+    fCatalogAddOnInfos.AddItem((void*)defaultCatalogAddOnInfo);
+
+    directory_which folders[] = {
+        B_COMMON_ADDONS_DIRECTORY,
+        B_BEOS_ADDONS_DIRECTORY,
+        static_cast<directory_which>(-1)
+    };
+    BPath addOnPath;
+    BDirectory addOnFolder;
+    char buf[4096];
+    status_t err;
+    for (int f=0; folders[f]>=0; ++f) {
+        find_directory(folders[f], &addOnPath);
+        BString addOnFolderName(addOnPath.Path());
+        addOnFolderName << "/locale/catalogs";
+        err = addOnFolder.SetTo(addOnFolderName.String());
+        if (err != B_OK)
+            continue;
+
+        // scan through all the folder's entries for catalog add-ons:
+        int32 count;
+        int8 priority;
+        entry_ref eref;
+        BNode node;
+        BEntry entry;
+        dirent *dent;
+        while ((count = addOnFolder.GetNextDirents((dirent *)buf, 4096)) > 0) {
+            dent = (dirent *)buf;
+            while (count-- > 0) {
+                if (strcmp(dent->d_name, ".") && strcmp(dent->d_name, "..")) {
+                    // we have found (what should be) a catalog-add-on:
+                    eref.device = dent->d_pdev;
+                    eref.directory = dent->d_pino;
+                    eref.set_name(dent->d_name);
+                    entry.SetTo(&eref, true);
+                        // traverse through any links to get to the real thang!
+                    node.SetTo(&entry);
+                    priority = -1;
+                    if (node.ReadAttr(kPriorityAttr, B_INT8_TYPE, 0, 
+                        &priority, sizeof(int8)) <= 0) {
+                        // add-on has no priority-attribute yet, so we load it to
+                        // fetch the priority from the corresponding symbol...
+                        BString fullAddOnPath(addOnFolderName);
+                        fullAddOnPath << "/" << dent->d_name;
+                        image_id image = load_add_on(fullAddOnPath.String());
+                        if (image >= B_OK) {
+                            uint8 *prioPtr;
+                            if (get_image_symbol(image, "gCatalogAddOnPriority",
+                                B_SYMBOL_TYPE_TEXT, 
+                                (void **)&prioPtr) == B_OK) {
+                                priority = *prioPtr;
+                                node.WriteAttr(kPriorityAttr, B_INT8_TYPE, 0, 
+                                    &priority, sizeof(int8));
+                            }
+                            unload_add_on(image);
+                        } else {
+                            log_team(LOG_ERR, 
+                                "couldn't load add-on %s, error: %s\n", 
+                                fullAddOnPath.String(), strerror(image));
+                        }
+                    }
+                    if (priority >= 0) {
+                        // add-ons with priority<0 will be ignored
+                        fCatalogAddOnInfos.AddItem(
+                            (void*)new BCatalogAddOnInfo(dent->d_name, 
+                                addOnFolderName, priority)
+                        );
+                    }
+                }
+                // Bump the dirent-pointer by length of the dirent just handled:
+                dent = (dirent *)((char *)dent + dent->d_reclen);
+            }
+        }
+    }
+    fCatalogAddOnInfos.SortItems(CompareInfos);
+
+    for (int32 i=0; i<fCatalogAddOnInfos.CountItems(); ++i) {
+        BCatalogAddOnInfo *info 
+            = static_cast<BCatalogAddOnInfo*>(fCatalogAddOnInfos.ItemAt(i));
+        log_team(LOG_INFO, 
+            "roster uses catalog-add-on %s/%s with priority %d",
+            info->fIsEmbedded ? "(embedded)" : info->fPath.String(), 
+            info->fName.String(), info->fPriority);
+    }
+}
+
+
+/*
+ * unloads all catalog-add-ons (which will throw away all loaded catalogs, too)
+ */
+void
+RosterData::CleanupCatalogAddOns() 
+{
+    BAutolock lock(fLock);
+    assert(lock.IsLocked());
+    int32 count = fCatalogAddOnInfos.CountItems();
+    for (int32 i=0; i<count; ++i) {
+        BCatalogAddOnInfo *info 
+            = static_cast<BCatalogAddOnInfo*>(fCatalogAddOnInfos.ItemAt(i));
+        delete info;
+    }
+    fCatalogAddOnInfos.MakeEmpty();
+}
+
+
+/*
+ * several attributes/resource-IDs used within the Locale Kit:
+ */
+const char *BLocaleRoster::kCatLangAttr = "BEOS:LOCALE_LANGUAGE";
+    // name of catalog language, lives in every catalog file
+const char *BLocaleRoster::kCatSigAttr = "BEOS:LOCALE_SIGNATURE";
+    // catalog signature, lives in every catalog file
+const char *BLocaleRoster::kCatFingerprintAttr = "BEOS:LOCALE_FINGERPRINT";
+    // catalog fingerprint, may live in catalog file
+
+const char *BLocaleRoster::kCatManagerMimeType 
+    = "application/x-vnd.Be.locale.catalog-manager";
+    // signature of catalog managing app
+const char *BLocaleRoster::kCatEditorMimeType 
+    = "application/x-vnd.Be.locale.catalog-editor";
+    // signature of catalog editor app
+
+const char *BLocaleRoster::kEmbeddedCatAttr = "BEOS:LOCALE_EMBEDDED_CATALOG";
+    // attribute which contains flattened data of embedded catalog
+    // this may live in an app- or add-on-file
+int32 BLocaleRoster::kEmbeddedCatResId = 0xCADA;
+    // a unique value used to identify the resource (=> embedded CAtalog DAta)
+    // which contains flattened data of embedded catalog.
+    // this may live in an app- or add-on-file
+
+/*
+ * BLocaleRoster, the exported interface to the locale roster data:
+ */
+BLocaleRoster::BLocaleRoster()
+{
+}
+
+
+BLocaleRoster::~BLocaleRoster()
+{
+}
+
+
+status_t 
+BLocaleRoster::GetDefaultCollator(BCollator **collator) const
+{
+    // It should just use the archived collator from the locale settings;
+    // if that is not available, just return the standard collator
+    if (!collator)
+        return B_BAD_VALUE;
+    *collator = new BCollator();
+    return B_OK;
+}
+
+
+status_t 
+BLocaleRoster::GetDefaultLanguage(BLanguage **language) const
+{
+    if (!language)
+        return B_BAD_VALUE;
+    *language = new BLanguage(NULL);
+    return B_OK;
+}
+
+
+status_t 
+BLocaleRoster::GetDefaultCountry(BCountry **country) const
+{
+    if (!country)
+        return B_BAD_VALUE;
+    *country = new BCountry();
+    return B_OK;
+}
+
+
+status_t 
+BLocaleRoster::GetPreferredLanguages(BMessage *languages) const
+{
+    if (!languages)
+        return B_BAD_VALUE;
+
+    BAutolock lock(gRosterData.fLock);
+    assert(lock.IsLocked());
+
+    *languages = gRosterData.fPreferredLanguages;
+    return B_OK;
+}
+
+
+status_t 
+BLocaleRoster::SetPreferredLanguages(BMessage *languages)
+{
+    BAutolock lock(gRosterData.fLock);
+    assert(lock.IsLocked());
+
+    if (languages)
+        gRosterData.fPreferredLanguages = *languages;
+    else
+        gRosterData.fPreferredLanguages.MakeEmpty();
+    return B_OK;
+}
+
+
+/*
+ * creates a new (empty) catalog of the given type (the request is dispatched
+ * to the appropriate add-on).
+ * If the add-on doesn't support catalog-creation or if the creation fails,
+ * NULL is returned, otherwise a pointer to the freshly created catalog.
+ * Any created catalog will be initialized with the given signature and
+ * language-name.
+ */
+BCatalogAddOn*
+BLocaleRoster::CreateCatalog(const char *type, const char *signature, 
+    const char *language)
+{
+    if (!type || !signature || !language)
+        return NULL;
+
+    BAutolock lock(gRosterData.fLock);
+    assert(lock.IsLocked());
+
+    int32 count = gRosterData.fCatalogAddOnInfos.CountItems();
+    for (int32 i=0; i<count; ++i) {
+        BCatalogAddOnInfo *info 
+            = (BCatalogAddOnInfo*)gRosterData.fCatalogAddOnInfos.ItemAt(i);
+        if (info->fName.ICompare(type)!=0 || !info->MakeSureItsLoaded() 
+            || !info->fCreateFunc)
+            continue;
+
+        BCatalogAddOn *catalog = info->fCreateFunc(signature, language);
+        if (catalog) {
+            info->fLoadedCatalogs.AddItem(catalog);
+            info->UnloadIfPossible();
+            return catalog;
+        }
+    }
+
+    return NULL;
+}
+
+
+/*
+ * Loads a catalog for the given signature, language and fingerprint. 
+ * The request to load this catalog is dispatched to all add-ons in turn, 
+ * until an add-on reports success.
+ * If a catalog depends on another language (as 'english-british' depends
+ * on 'english') the dependant catalogs are automatically loaded, too.
+ * So it is perfectly possible that this method returns a catalog-chain
+ * instead of a single catalog.
+ * NULL is returned if no matching catalog could be found.
+ */
+BCatalogAddOn*
+BLocaleRoster::LoadCatalog(const char *signature, const char *language,
+    int32 fingerprint)
+{
+    if (!signature)
+        return NULL;
+
+    BAutolock lock(gRosterData.fLock);
+    assert(lock.IsLocked());
+
+    int32 count = gRosterData.fCatalogAddOnInfos.CountItems();
+    for (int32 i=0; i<count; ++i) {
+        BCatalogAddOnInfo *info 
+            = (BCatalogAddOnInfo*)gRosterData.fCatalogAddOnInfos.ItemAt(i);
+
+        if (!info->MakeSureItsLoaded() || !info->fInstantiateFunc)
+            continue;
+        BMessage languages;
+        if (language)
+            // try to load catalogs for the given language:
+            languages.AddString("language", language);
+        else
+            // try to load catalogs for one of the preferred languages:
+            GetPreferredLanguages(&languages);
+
+        BCatalogAddOn *catalog = NULL;
+        const char *lang;
+        for (int32 l=0; languages.FindString("language", l, &lang)==B_OK; ++l) {
+            catalog = info->fInstantiateFunc(signature, lang, fingerprint);
+            if (catalog) {
+                info->fLoadedCatalogs.AddItem(catalog);
+#if 0           
+                // Chain-loading of catalogs has been disabled, as with the
+                // current way of handling languages (there are no general
+                // languages like 'English', but only specialized ones, like
+                // 'English-american') it does not make sense... 
+                //
+                // Chain-load catalogs for languages that depend on 
+                // other languages.
+                // The current implementation uses the filename in order to 
+                // detect dependencies (parenthood) between languages (it
+                // traverses from "english-british-oxford" to "english-british"
+                // to "english"):
+                int32 pos;
+                BString langName(lang);
+                BCatalogAddOn *currCatalog=catalog, *nextCatalog;
+                while ((pos = langName.FindLast('-')) >= 0) {
+                    // language is based on parent, so we load that, too:
+                    langName.Truncate(pos);
+                    nextCatalog = info->fInstantiateFunc(signature, 
+                        langName.String(), fingerprint);
+                    if (nextCatalog) {
+                        info->fLoadedCatalogs.AddItem(nextCatalog);
+                        currCatalog->fNext = nextCatalog;
+                        currCatalog = nextCatalog;
+                    }
+                }
+#endif
+                return catalog;
+            }
+        }
+        info->UnloadIfPossible();
+    }
+
+    return NULL;
+}
+
+
+/*
+ * Loads an embedded catalog from the given entry-ref (which is usually an
+ * app- or add-on-file. The request to load the catalog is dispatched to all 
+ * add-ons in turn, until an add-on reports success.
+ * NULL is returned if no embedded catalog could be found.
+ */
+BCatalogAddOn*
+BLocaleRoster::LoadEmbeddedCatalog(entry_ref *appOrAddOnRef)
+{
+    if (!appOrAddOnRef)
+        return NULL;
+
+    BAutolock lock(gRosterData.fLock);
+    assert(lock.IsLocked());
+
+    int32 count = gRosterData.fCatalogAddOnInfos.CountItems();
+    for (int32 i=0; i<count; ++i) {
+        BCatalogAddOnInfo *info 
+            = (BCatalogAddOnInfo*)gRosterData.fCatalogAddOnInfos.ItemAt(i);
+
+        if (!info->MakeSureItsLoaded() || !info->fInstantiateEmbeddedFunc)
+            continue;
+
+        BCatalogAddOn *catalog = NULL;
+        catalog = info->fInstantiateEmbeddedFunc(appOrAddOnRef);
+        if (catalog) {
+            info->fLoadedCatalogs.AddItem(catalog);
+            return catalog;
+        }
+        info->UnloadIfPossible();
+    }
+
+    return NULL;
+}
+
+
+/*
+ * unloads the given catalog (or rather: catalog-chain).
+ * Every single catalog of the chain will be deleted automatically.
+ * Add-ons that have no more current catalogs are unloaded, too.
+ */
+status_t
+BLocaleRoster::UnloadCatalog(BCatalogAddOn *catalog)
+{
+    if (!catalog)
+        return B_BAD_VALUE;
+
+    BAutolock lock(gRosterData.fLock);
+    assert(lock.IsLocked());
+
+    status_t res = B_ERROR;
+    BCatalogAddOn *nextCatalog;
+    // note: as we currently aren't chainloading catalogs, there is only
+    //       one catalog to unload...
+    while (catalog) {
+        nextCatalog = catalog->fNext;
+        int32 count = gRosterData.fCatalogAddOnInfos.CountItems();
+        for (int32 i=0; i<count; ++i) {
+            BCatalogAddOnInfo *info 
+                = static_cast<BCatalogAddOnInfo*>(
+                    gRosterData.fCatalogAddOnInfos.ItemAt(i)
+                );
+            if (info->fLoadedCatalogs.HasItem(catalog)) {
+                info->fLoadedCatalogs.RemoveItem(catalog);
+                delete catalog;
+                info->UnloadIfPossible();
+                res = B_OK;
+            }
+        }
+        catalog = nextCatalog;
+    }
+    return res;
+}

src/kits/locale/Locale.cpp

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <Catalog.h>
+#include <Locale.h>
+#include <LocaleRoster.h>
+
+
+static BLocale gLocale;
+BLocale *be_locale = &gLocale;
+
+
+BLocale::BLocale()
+{
+    BLocaleRoster roster;
+    roster.GetDefaultCollator(&fCollator);
+    roster.GetDefaultCountry(&fCountry);
+    roster.GetDefaultLanguage(&fLanguage);
+}
+
+
+BLocale::~BLocale()
+{
+}
+
+
+const char *
+BLocale::GetString(uint32 id)
+{
+    // Note: this code assumes a certain order of the string bases
+
+    if (id >= B_OTHER_STRINGS_BASE) {
+        if (id == B_CODESET)
+            return "UTF-8";
+
+        return "";
+    }
+    if (id >= B_LANGUAGE_STRINGS_BASE)
+        return fLanguage->GetString(id);
+
+    return fCountry->GetString(id);
+}
+
+status_t 
+BLocale::GetAppCatalog(BCatalog *catalog) {
+    if (!catalog)
+        return B_BAD_VALUE;
+    if (be_catalog)
+        debugger( "GetAppCatalog() has been called while be_catalog != NULL");
+    return BCatalog::GetAppCatalog(catalog);
+}

src/kits/locale/NumberFormat.cpp

@@ +1 @@
+#include <NumberFormat.h>
+#include <NumberFormatImpl.h>
+
+// copy constructor
+BNumberFormat::BNumberFormat(const BNumberFormat &other)
+    : BFormat(other)
+{
+}
+
+// destructor
+BNumberFormat::~BNumberFormat()
+{
+}
+
+// =
+BNumberFormat &
+BNumberFormat::operator=(const BNumberFormat &other)
+{
+    BFormat::operator=(other);
+    return *this;
+}
+
+// constructor
+BNumberFormat::BNumberFormat(BNumberFormatImpl *impl)
+    : BFormat(impl)
+{
+}
+
+// NumberFormatImpl
+inline
+BNumberFormatImpl *
+BNumberFormat::NumberFormatImpl() const
+{
+    return static_cast<BNumberFormatImpl*>(fImpl);
+}
+

src/kits/locale/FormatImpl.cpp

@@ +1 @@
+#include <FormatImpl.h>
+
+// constructor
+BFormatImpl::BFormatImpl()
+{
+}
+
+// destructor
+BFormatImpl::~BFormatImpl()
+{
+}
+

src/kits/locale/FormatParameters.cpp

@@ +1 @@
+#include <FormatParameters.h>
+
+// defaults
+static const format_alignment kDefaultAlignment = B_ALIGN_FORMAT_RIGHT;
+static const size_t kDefaultFormatWidth = 1;
+
+// flags
+enum {
+    ALIGNMENT_SET   = 0x01,
+    WIDTH_SET       = 0x02,
+};
+
+// constructor
+BFormatParameters::BFormatParameters(const BFormatParameters *parent)
+    : fParent(parent),
+      fFlags(0)
+{
+}
+
+// copy constructor
+BFormatParameters::BFormatParameters(const BFormatParameters &other)
+    : fParent(other.fParent),
+      fAlignment(other.fAlignment),
+      fWidth(other.fWidth),
+      fFlags(other.fFlags)
+{
+}
+
+// destructor
+BFormatParameters::~BFormatParameters()
+{
+}
+
+// SetAlignment
+void
+BFormatParameters::SetAlignment(format_alignment alignment)
+{
+    fAlignment = alignment;
+    fFlags |= ALIGNMENT_SET;
+}
+
+// Alignment
+format_alignment
+BFormatParameters::Alignment() const
+{
+    if (fFlags & ALIGNMENT_SET)
+        return fAlignment;
+    if (fParent)
+        return fParent->Alignment();
+    return kDefaultAlignment;
+}
+
+// SetFormatWidth
+void
+BFormatParameters::SetFormatWidth(size_t width)
+{
+    fWidth = width;
+    fFlags |= WIDTH_SET;
+}
+
+// FormatWidth
+size_t
+BFormatParameters::FormatWidth() const
+{
+    if (fFlags & WIDTH_SET)
+        return fWidth;
+    if (fParent)
+        return fParent->FormatWidth();
+    return kDefaultFormatWidth;
+}
+
+// SetParentParameters
+void
+BFormatParameters::SetParentParameters(const BFormatParameters *parent)
+{
+    fParent = parent;
+}
+
+// ParentParameters
+const BFormatParameters *
+BFormatParameters::ParentParameters() const
+{
+    return fParent;
+}
+
+// =
+BFormatParameters &
+BFormatParameters::operator=(const BFormatParameters &other)
+{
+    fParent = other.fParent;
+    fAlignment = other.fAlignment;
+    fWidth = other.fWidth;
+    fFlags = other.fFlags;
+    return *this;
+}
+

src/kits/locale/DefaultCatalog.cpp

@@ +1 @@
+/*
+ * Copyright 2003, Oliver Tappe, zooey@hirschkaefer.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <algorithm>
+#include <memory>
+#include <syslog.h>
+
+#include <Application.h>
+#include <DataIO.h>
+#include <Directory.h>
+#include <File.h>
+#include <FindDirectory.h>
+#include <fs_attr.h>
+#include <Message.h>
+#include <Mime.h>
+#include <Path.h>
+#include <Resources.h>
+#include <Roster.h>
+
+#include <DefaultCatalog.h>
+#include <LocaleRoster.h>
+
+#include <cstdio>
+
+/*
+ *  This file implements the default catalog-type for the opentracker locale kit.
+ *  Alternatively, this could be used as a full add-on, but currently this
+ *  is provided as part of liblocale.so.
+ */
+
+extern "C" uint32 adler32(uint32 adler, const uint8 *buf, uint32 len);
+    // definition lives in adler32.c
+
+#if B_BEOS_VERSION <= B_BEOS_VERSION_5 && !defined(__HAIKU__)
+// B_BAD_DATA was introduced with DANO, so we define it for R5:
+#   define B_BAD_DATA -2147483632L
+#endif
+
+
+/*
+ * CatKey
+ */
+size_t hash<CatKey>::operator()(const CatKey &key) const 
+{
+    return key.fHashVal;
+}
+
+
+static const char kSeparator = '\01';
+
+
+CatKey::CatKey(const char *str, const char *ctx, const char *cmt)
+    :
+    fFlags(0)
+{
+    uint32 strLen = str ? strlen(str) : 0;
+    uint32 ctxLen = ctx ? strlen(ctx) : 0;
+    uint32 cmtLen = cmt ? strlen(cmt) : 0;
+    int32 keyLen = strLen + ctxLen + cmtLen + 2;
+    char *keyBuf = fKey.LockBuffer(keyLen);
+    if (!keyBuf)
+        return;
+    if (strLen) {
+        memcpy(keyBuf, str, strLen);
+        keyBuf += strLen;
+    }
+    *keyBuf++ = kSeparator;
+    if (ctxLen) {
+        memcpy(keyBuf, ctx, ctxLen);
+        keyBuf += ctxLen;
+    }
+    *keyBuf++ = kSeparator;
+    if (cmtLen) {
+        memcpy(keyBuf, cmt, cmtLen);
+        keyBuf += cmtLen;
+    }
+    *keyBuf = '\0';
+    fKey.UnlockBuffer(keyLen);
+    fHashVal = HashFun(fKey.String());
+}
+
+
+CatKey::CatKey(uint32 id)
+    :
+    fHashVal(id),
+    fFlags(0)
+{
+}
+
+
+CatKey::CatKey()
+    :
+    fHashVal(0),
+    fFlags(0)
+{
+}
+
+
+bool 
+CatKey::operator== (const CatKey& right) const
+{
+    // Two keys are equal if their hashval and key (string,context,comment) 
+    // are equal:
+    return fHashVal == right.fHashVal
+        && fKey == right.fKey;
+}
+
+
+status_t
+CatKey::GetStringParts(BString* str, BString* ctx, BString* cmt) const
+{
+    int32 pos1 = fKey.FindFirst(kSeparator);
+    if (pos1 < B_OK) {
+        if (str)
+            str->SetTo(fKey);
+        if (ctx)
+            ctx->Truncate(0);
+        if (cmt)
+            cmt->Truncate(0);
+    } else {
+        if (str)
+            fKey.CopyInto(*str, 0, pos1);
+        int32 pos2 = fKey.FindFirst(kSeparator, pos1+1);
+        if (pos2 < B_OK) {
+            if (ctx)
+                ctx->SetTo(fKey, pos1+1);
+            if (cmt)
+                cmt->Truncate(0);
+        } else {
+            if (ctx)
+                fKey.CopyInto(*ctx, pos1+1, pos2-pos1-1);
+            if (cmt)
+                cmt->SetTo(fKey.String()+pos2+1);
+        }
+    }
+
+    return B_OK;
+}
+
+
+size_t CatKey::HashFun(const char* s) { 
+    unsigned long h = 0; 
+    for ( ; *s; ++s) 
+        h = 5*h + *s; 
+
+    return size_t(h); 
+}
+
+
+static const char *kCatFolder = "catalogs";
+static const char *kCatExtension = ".catalog";
+
+const char *DefaultCatalog::kCatMimeType 
+    = "locale/x-vnd.Be.locale-catalog.default";
+
+static int16 kCatArchiveVersion = 1;
+    // version of the catalog archive structure, bump this if you change it!
+
+
+/* 
+ * constructs a DefaultCatalog with given signature and language and reads
+ * the catalog from disk.
+ * InitCheck() will be B_OK if catalog could be loaded successfully, it will
+ * give an appropriate error-code otherwise.
+ */
+DefaultCatalog::DefaultCatalog(const char *signature, const char *language,
+    int32 fingerprint)
+    :
+    BCatalogAddOn(signature, language, fingerprint)
+{
+    // give highest priority to catalog living in sub-folder of app's folder:
+    app_info appInfo;
+    be_app->GetAppInfo(&appInfo);
+    node_ref nref;
+    nref.device = appInfo.ref.device;
+    nref.node = appInfo.ref.directory;
+    BDirectory appDir(&nref);
+    BString catalogName("locale/");
+    catalogName << kCatFolder 
+        << "/" << fSignature 
+        << "/" << fLanguageName 
+        << kCatExtension;
+    BPath catalogPath(&appDir, catalogName.String());
+    status_t status = ReadFromFile(catalogPath.Path());
+
+    if (status != B_OK) {
+        // look in common-etc folder (/boot/home/config/etc):
+        BPath commonEtcPath;
+        find_directory(B_COMMON_ETC_DIRECTORY, &commonEtcPath);
+        if (commonEtcPath.InitCheck() == B_OK) {
+            catalogName = BString(commonEtcPath.Path()) 
+                            << "/locale/" << kCatFolder 
+                            << "/" << fSignature 
+                            << "/" << fLanguageName 
+                            << kCatExtension;
+            status = ReadFromFile(catalogName.String());
+        }
+    }
+
+    if (status != B_OK) {
+        // look in system-etc folder (/boot/beos/etc):
+        BPath systemEtcPath;
+        find_directory(B_BEOS_ETC_DIRECTORY, &systemEtcPath);
+        if (systemEtcPath.InitCheck() == B_OK) {
+            catalogName = BString(systemEtcPath.Path()) 
+                            << "/locale/" << kCatFolder 
+                            << "/" << fSignature 
+                            << "/" << fLanguageName
+                            << kCatExtension;
+            status = ReadFromFile(catalogName.String());
+        }
+    }
+
+    fInitCheck = status;
+    log_team(LOG_DEBUG, 
+        "trying to load default-catalog(sig=%s, lang=%s) results in %s",
+        signature, language, strerror(fInitCheck));
+}
+
+
+/*
+ * constructs a DefaultCatalog and reads it from the resources of the
+ * given entry-ref (which usually is an app- or add-on-file).
+ * InitCheck() will be B_OK if catalog could be loaded successfully, it will
+ * give an appropriate error-code otherwise.
+ */
+DefaultCatalog::DefaultCatalog(entry_ref *appOrAddOnRef)
+    :
+    BCatalogAddOn("", "", 0)
+{
+    fInitCheck = ReadFromResource(appOrAddOnRef);
+    log_team(LOG_DEBUG, 
+        "trying to load embedded catalog from resources results in %s",
+        strerror(fInitCheck));
+}
+
+
+/*
+ * constructs an empty DefaultCatalog with given sig and language.
+ * This is used for editing/testing purposes.
+ * InitCheck() will always be B_OK.
+ */
+DefaultCatalog::DefaultCatalog(const char *path, const char *signature, 
+    const char *language)
+    :
+    BCatalogAddOn(signature, language, 0),
+    fPath(path)
+{
+    fInitCheck = B_OK;
+}
+
+
+DefaultCatalog::~DefaultCatalog()
+{
+}
+
+
+status_t
+DefaultCatalog::ReadFromFile(const char *path)
+{
+    if (!path)
+        path = fPath.String();
+
+    BFile catalogFile;
+    status_t res = catalogFile.SetTo(path, B_READ_ONLY);
+    if (res != B_OK) {
+        log_team(LOG_DEBUG, "no catalog at %s", path);
+        return B_ENTRY_NOT_FOUND;
+    }
+
+    fPath = path;
+    log_team(LOG_DEBUG, "found catalog at %s", path);
+
+    off_t sz = 0;
+    res = catalogFile.GetSize(&sz);
+    if (res != B_OK) {
+        log_team(LOG_ERR, "couldn't get size for catalog-file %s", path);
+        return res;
+    }
+    
+        std::auto_ptr<char> buf(new char [sz]);
+    res = catalogFile.Read(buf.get(), sz);
+    if (res < B_OK) {
+        log_team(LOG_ERR, "couldn't read from catalog-file %s", path);
+        return res;
+    }
+    if (res < sz) {
+        log_team(LOG_ERR, "only got %lu instead of %Lu bytes from catalog-file %s", 
+            res, sz, path);
+        return res;
+    }
+    BMemoryIO memIO(buf.get(), sz);
+    res = Unflatten(&memIO);
+
+    if (res == B_OK) {
+        // some information living in member variables needs to be copied 
+        // to attributes. Although these attributes should have been written 
+        // when creating the catalog, we make sure that they exist there:
+        UpdateAttributes(catalogFile);
+    }
+
+    return res;
+}
+
+
+/*
+ * this method is not currently being used, but it may be useful in the future...
+ */
+status_t
+DefaultCatalog::ReadFromAttribute(entry_ref *appOrAddOnRef)
+{
+    BNode node;
+    status_t res = node.SetTo(appOrAddOnRef);
+    if (res != B_OK) {
+        log_team(LOG_ERR, "couldn't find app or add-on (dev=%lu, dir=%Lu, name=%s)",
+            appOrAddOnRef->device, appOrAddOnRef->directory, 
+            appOrAddOnRef->name);
+        return B_ENTRY_NOT_FOUND;
+    }
+
+    log_team(LOG_DEBUG, 
+        "looking for embedded catalog-attribute in app/add-on"
+        "(dev=%lu, dir=%Lu, name=%s)", appOrAddOnRef->device, 
+        appOrAddOnRef->directory, appOrAddOnRef->name);
+
+    attr_info attrInfo;
+    res = node.GetAttrInfo(BLocaleRoster::kEmbeddedCatAttr, &attrInfo);
+    if (res != B_OK) {
+        log_team(LOG_DEBUG, "no embedded catalog found");
+        return B_NAME_NOT_FOUND;
+    }
+    if (attrInfo.type != B_MESSAGE_TYPE) {
+        log_team(LOG_ERR, "attribute %s has incorrect type and is ignored!",
+            BLocaleRoster::kEmbeddedCatAttr);
+        return B_BAD_TYPE;
+    }
+
+    size_t size = attrInfo.size;
+        std::auto_ptr<char> buf(new char [size]);
+    res = node.ReadAttr(BLocaleRoster::kEmbeddedCatAttr, B_MESSAGE_TYPE, 0,
+        buf.get(), size);
+    if (res < (ssize_t)size) {
+        log_team(LOG_ERR, "unable to read embedded catalog from attribute");
+        return res < B_OK ? res : B_BAD_DATA;
+    }
+
+    BMemoryIO memIO(buf.get(), size);
+    res = Unflatten(&memIO);
+
+    return res;
+}
+
+
+status_t
+DefaultCatalog::ReadFromResource(entry_ref *appOrAddOnRef)
+{
+    BFile file;
+    status_t res = file.SetTo(appOrAddOnRef, B_READ_ONLY);
+    if (res != B_OK) {
+        log_team(LOG_ERR, "couldn't find app or add-on (dev=%lu, dir=%Lu, name=%s)",
+            appOrAddOnRef->device, appOrAddOnRef->directory, 
+            appOrAddOnRef->name);
+        return B_ENTRY_NOT_FOUND;
+    }
+
+    log_team(LOG_DEBUG, 
+        "looking for embedded catalog-resource in app/add-on"
+        "(dev=%lu, dir=%Lu, name=%s)", appOrAddOnRef->device, 
+        appOrAddOnRef->directory, appOrAddOnRef->name);
+
+    BResources rsrc;
+    res = rsrc.SetTo(&file);
+    if (res != B_OK) {
+        log_team(LOG_DEBUG, "file has no resources");
+        return res;
+    }
+
+    size_t sz;
+    const void *buf = rsrc.LoadResource(B_MESSAGE_TYPE, 
+        BLocaleRoster::kEmbeddedCatResId, &sz);
+    if (!buf) {
+        log_team(LOG_DEBUG, "file has no catalog-resource");
+        return B_NAME_NOT_FOUND;
+    }
+
+    BMemoryIO memIO(buf, sz);
+    res = Unflatten(&memIO);
+
+    return res;
+}
+
+
+status_t
+DefaultCatalog::WriteToFile(const char *path)
+{
+    BFile catalogFile;
+    if (path)
+        fPath = path;
+    status_t res = catalogFile.SetTo(fPath.String(),
+        B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
+    if (res != B_OK)
+        return res;
+
+    BMallocIO mallocIO;
+    mallocIO.SetBlockSize(std::max(fCatMap.size()*20, 256LU));
+        // set a largish block-size in order to avoid reallocs
+    res = Flatten(&mallocIO);
+    if (res == B_OK) {
+        ssize_t wsz;
+        wsz = catalogFile.Write(mallocIO.Buffer(), mallocIO.BufferLength());
+        if (wsz != (ssize_t)mallocIO.BufferLength())
+            return B_FILE_ERROR;
+
+        // set mimetype-, language- and signature-attributes:
+        UpdateAttributes(catalogFile);
+        // finally write fingerprint:
+        catalogFile.WriteAttr(BLocaleRoster::kCatFingerprintAttr, B_INT32_TYPE, 
+            0, &fFingerprint, sizeof(int32));
+    }
+    if (res == B_OK)
+        UpdateAttributes(catalogFile);  
+    return res;
+}
+
+
+/*
+ * this method is not currently being used, but it may be useful in the future...
+ */
+status_t
+DefaultCatalog::WriteToAttribute(entry_ref *appOrAddOnRef)
+{
+    BNode node;
+    status_t res = node.SetTo(appOrAddOnRef);
+    if (res != B_OK)
+        return res;
+        
+    BMallocIO mallocIO;
+    mallocIO.SetBlockSize(std::max(fCatMap.size()*20, 256LU));
+        // set a largish block-size in order to avoid reallocs
+    res = Flatten(&mallocIO);
+
+    if (res == B_OK) {
+        ssize_t wsz;
+        wsz = node.WriteAttr(BLocaleRoster::kEmbeddedCatAttr, B_MESSAGE_TYPE, 0,
+            mallocIO.Buffer(), mallocIO.BufferLength());
+        if (wsz < B_OK)
+            res = wsz;
+        else if (wsz != (ssize_t)mallocIO.BufferLength())
+            res = B_ERROR;
+    }
+    return res;
+}
+
+
+status_t
+DefaultCatalog::WriteToResource(entry_ref *appOrAddOnRef)
+{
+    BFile file;
+    status_t res = file.SetTo(appOrAddOnRef, B_READ_WRITE);
+    if (res != B_OK)
+        return res;
+
+    BResources rsrc;
+    res = rsrc.SetTo(&file);
+    assert(res == B_OK);
+    if (res != B_OK)
+        return res;
+
+    BMallocIO mallocIO;
+    mallocIO.SetBlockSize(std::max(fCatMap.size()*20, 256LU));
+        // set a largish block-size in order to avoid reallocs
+    res = Flatten(&mallocIO);
+    assert(res == B_OK);
+
+    if (res == B_OK)
+        res = rsrc.AddResource(B_MESSAGE_TYPE, BLocaleRoster::kEmbeddedCatResId,
+            mallocIO.Buffer(), mallocIO.BufferLength(), "embedded catalog");
+
+    assert(res == B_OK);
+    return res;
+}
+
+
+void
+DefaultCatalog::MakeEmpty()
+{
+    fCatMap.clear();
+}
+
+
+int32
+DefaultCatalog::CountItems() const
+{
+    return fCatMap.size();
+}
+
+
+const char *
+DefaultCatalog::GetString(const char *string, const char *context, 
+    const char *comment)
+{
+    CatKey key(string, context, comment);
+    return GetString(key);
+}
+
+
+const char *
+DefaultCatalog::GetString(uint32 id)
+{
+    CatKey key(id);
+    return GetString(key);
+}
+
+
+const char *
+DefaultCatalog::GetString(const CatKey& key)
+{
+    CatMap::const_iterator iter = fCatMap.find(key);
+    if (iter != fCatMap.end())
+        return iter->second.String();
+    else
+        return NULL;
+}
+
+
+status_t
+DefaultCatalog::SetString(const char *string, const char *translated, 
+    const char *context, const char *comment)
+{
+    CatKey key(string, context, comment);
+    fCatMap[key] = translated;
+        // overwrite existing element
+    return B_OK;
+}
+
+
+status_t
+DefaultCatalog::SetString(int32 id, const char *translated)
+{
+    CatKey key(id);
+    fCatMap[key] = translated;
+        // overwrite existing element
+    return B_OK;
+}
+
+
+status_t
+DefaultCatalog::SetString(const CatKey& key, const char *translated)
+{
+    fCatMap[key] = translated;
+        // overwrite existing element
+    return B_OK;
+}
+
+
+/*
+ * computes an adler32-checksum (we call it fingerprint) on all the catalog-keys.
+ * We do not include the values, since we want catalogs for different languages
+ * of the same app to have the same fingerprint, since we use it to separate
+ * different catalog-versions.
+ */
+int32
+DefaultCatalog::ComputeFingerprint() const
+{
+    uint32 adler = adler32(0, NULL, 0);
+
+    int32 hash;
+    CatMap::const_iterator iter;
+    for (iter = fCatMap.begin(); iter!=fCatMap.end(); ++iter) {
+        hash = B_HOST_TO_LENDIAN_INT32(iter->first.fHashVal);
+        adler = adler32(adler, reinterpret_cast<uint8*>(&hash), sizeof(int32));
+    }
+    return adler;
+}
+
+
+void
+DefaultCatalog::UpdateFingerprint()
+{
+    fFingerprint = ComputeFingerprint();
+}
+
+
+/*
+ * writes mimetype, language-name and signature of catalog into the catalog-file.
+ */
+void
+DefaultCatalog::UpdateAttributes(BFile& catalogFile)
+{
+    static const int bufSize = 256;
+    char buf[bufSize];
+    if (catalogFile.ReadAttr("BEOS:TYPE", B_MIME_STRING_TYPE, 0, &buf, bufSize) <= 0
+        || strcmp(kCatMimeType, buf) != 0) {
+        catalogFile.WriteAttr("BEOS:TYPE", B_MIME_STRING_TYPE, 0, 
+            kCatMimeType, strlen(kCatMimeType)+1);
+    }
+    if (catalogFile.ReadAttr(BLocaleRoster::kCatLangAttr, B_STRING_TYPE, 0, 
+        &buf, bufSize) <= 0
+        || fLanguageName != buf) {
+        catalogFile.WriteAttr(BLocaleRoster::kCatLangAttr, B_STRING_TYPE, 0, 
+            fLanguageName.String(), fLanguageName.Length()+1);
+    }
+    if (catalogFile.ReadAttr(BLocaleRoster::kCatSigAttr, B_STRING_TYPE, 0, 
+        &buf, bufSize) <= 0
+        || fSignature != buf) {
+        catalogFile.WriteAttr(BLocaleRoster::kCatSigAttr, B_STRING_TYPE, 0, 
+            fSignature.String(), fSignature.Length()+1);
+    }
+}
+
+
+status_t
+DefaultCatalog::Flatten(BDataIO *dataIO)
+{
+    UpdateFingerprint();
+        // make sure we have the correct fingerprint before we flatten it
+
+    status_t res;
+    BMessage archive;
+    int32 count = fCatMap.size();
+    res = archive.AddString("class", "DefaultCatalog")
+        || archive.AddInt32("c:sz", count)
+        || archive.AddInt16("c:ver", kCatArchiveVersion)
+        || archive.AddString("c:lang", fLanguageName.String())
+        || archive.AddString("c:sig", fSignature.String())
+        || archive.AddInt32("c:fpr", fFingerprint);
+    if (res == B_OK)
+        res = archive.Flatten(dataIO);
+
+    CatMap::const_iterator iter;
+    for (iter = fCatMap.begin(); res==B_OK && iter!=fCatMap.end(); ++iter) {
+        archive.MakeEmpty();
+        res = archive.AddString("c:key", iter->first.fKey.String())
+            || archive.AddInt32("c:hash", iter->first.fHashVal)
+            || archive.AddString("c:tstr", iter->second.String());
+        if (res == B_OK)
+            res = archive.Flatten(dataIO);
+    }
+    return res;
+}
+
+
+status_t
+DefaultCatalog::Unflatten(BDataIO *dataIO)
+{
+    fCatMap.clear();
+    int32 count = 0;
+    int16 version;
+    BMessage archiveMsg;
+    status_t res = archiveMsg.Unflatten(dataIO);
+    
+    if (res == B_OK) {
+        res = archiveMsg.FindInt16("c:ver", &version)
+            || archiveMsg.FindInt32("c:sz", &count);
+    }
+    if (res == B_OK) {
+        fLanguageName = archiveMsg.FindString("c:lang");
+        fSignature = archiveMsg.FindString("c:sig");
+        int32 foundFingerprint = archiveMsg.FindInt32("c:fpr");
+
+        // if a specific fingerprint has been requested and the catalog does in fact
+        // have a fingerprint, both are compared. If they mismatch, we do not accept
+        // this catalog:
+        if (foundFingerprint != 0 && fFingerprint != 0 
+            && foundFingerprint != fFingerprint) {
+            log_team(LOG_INFO, "default-catalog(sig=%s, lang=%s) "
+                "has mismatching fingerprint (%ld instead of the requested %ld), "
+                "so this catalog is skipped.",
+                fSignature.String(), fLanguageName.String(), foundFingerprint,
+                fFingerprint);
+            res = B_MISMATCHED_VALUES;
+        } else
+            fFingerprint = foundFingerprint;
+    }
+
+    if (res == B_OK && count > 0) {
+        CatKey key;
+        const char *keyStr;
+        const char *translated;
+#ifdef __GCC
+        fCatMap.resize(count);
+#endif
+        for (int i=0; res==B_OK && i<count; ++i) {
+            res = archiveMsg.Unflatten(dataIO);
+            if (res == B_OK) {
+                res = archiveMsg.FindString("c:key", &keyStr)
+                    || archiveMsg.FindInt32("c:hash", (int32*)&key.fHashVal)
+                    || archiveMsg.FindString("c:tstr", &translated);
+            }
+            if (res == B_OK) {
+                key.fKey = keyStr;
+                fCatMap.insert(pair<const BPrivate::CatKey, BString>(key, translated));
+            }
+        }
+        int32 checkFP = ComputeFingerprint();
+        if (fFingerprint != checkFP) {
+            log_team(LOG_WARNING, "default-catalog(sig=%s, lang=%s) "
+                "has wrong fingerprint after load (%ld instead of the %ld). "
+                "The catalog data may be corrupted, so this catalog is skipped.",
+                fSignature.String(), fLanguageName.String(), checkFP,
+                fFingerprint);
+            return B_BAD_DATA;
+        }
+    }
+    return res;
+}
+
+
+BCatalogAddOn *
+DefaultCatalog::Instantiate(const char *signature, const char *language, 
+    int32 fingerprint)
+{
+    DefaultCatalog *catalog = new DefaultCatalog(signature, language, fingerprint);
+    if (catalog && catalog->InitCheck() != B_OK) {
+        delete catalog;
+        return NULL;
+    }
+    return catalog;
+}
+
+
+BCatalogAddOn *
+DefaultCatalog::InstantiateEmbedded(entry_ref *appOrAddOnRef)
+{
+    DefaultCatalog *catalog = new DefaultCatalog(appOrAddOnRef);
+    if (catalog && catalog->InitCheck() != B_OK) {
+        delete catalog;
+        return NULL;
+    }
+    return catalog;
+}
+
+
+BCatalogAddOn *
+DefaultCatalog::Create(const char *signature, const char *language)
+{
+    DefaultCatalog *catalog = new DefaultCatalog("", signature, language);
+    if (catalog && catalog->InitCheck() != B_OK) {
+        delete catalog;
+        return NULL;
+    }
+    return catalog;
+}
+
+
+const uint8 DefaultCatalog::kDefaultCatalogAddOnPriority = 1;
+    // give highest priority to our embedded catalog-add-on

src/kits/locale/IntegerFormatImpl.cpp

@@ +1 @@
+#include <IntegerFormatImpl.h>
+#include <IntegerFormatParameters.h>
+
+// constructor
+BIntegerFormatImpl::BIntegerFormatImpl()
+    : BNumberFormatImpl()
+{
+}
+
+// destructor
+BIntegerFormatImpl::~BIntegerFormatImpl()
+{
+}
+
+// DefaultNumberFormatParameters
+BNumberFormatParameters *
+BIntegerFormatImpl::DefaultNumberFormatParameters()
+{
+    return DefaultIntegerFormatParameters();
+}
+
+// DefaultNumberFormatParameters
+const BNumberFormatParameters *
+BIntegerFormatImpl::DefaultNumberFormatParameters() const
+{
+    return DefaultIntegerFormatParameters();
+}
+

src/kits/locale/LibraryInit.cpp

@@ +1 @@
+/*
+ * This file contains library initialization code. 
+ * The required mimetypes and attribute-indices are created here.
+ */ 
+
+#include <syslog.h>
+
+#include <fs_attr.h>
+#include <fs_index.h> 
+#include <Roster.h>
+#include <Volume.h>
+#include <VolumeRoster.h>
+
+#include <LocaleRoster.h>
+#include <DefaultCatalog.h>
+
+// helper function that makes sure an attribute-index exists:
+static void EnsureIndexExists(const char *attrName) 
+{
+    BVolume bootVol;
+    BVolumeRoster volRoster;
+    if (volRoster.GetBootVolume(&bootVol) != B_OK)
+        return;
+    struct index_info idxInfo;
+    if (fs_stat_index(bootVol.Device(), attrName, &idxInfo) != 0) {
+        status_t res = fs_create_index(bootVol.Device(), attrName, 
+            B_STRING_TYPE, 0);
+        if (res == 0) {
+            log_team(LOG_INFO, 
+                "successfully created the required index for attribute %s",
+                attrName);
+        } else {
+            log_team(LOG_ERR, 
+                "failed to create the required index for attribute %s (%s)",
+                attrName, strerror(res));
+        }
+    }
+}
+
+
+/*
+ * prepares the system for use by the Locale Kit catalogs,
+ * it makes sure that the required indices and mimetype exist:
+ */
+static void
+SetupCatalogBasics()
+{
+    // make sure the indices required for catalog-traversal are there:
+    EnsureIndexExists(BLocaleRoster::kCatLangAttr);
+    EnsureIndexExists(BLocaleRoster::kCatSigAttr);
+    
+    // install mimetype for default-catalog:
+    BMimeType mt;
+    status_t res = mt.SetTo(DefaultCatalog::kCatMimeType);
+    if (res == B_OK && !mt.IsInstalled()) {
+        // install supertype, if it isn't available
+        BMimeType supertype;
+        res = mt.GetSupertype(&supertype);
+        if (res == B_OK && !supertype.IsInstalled()) {
+            res = supertype.Install();
+        }
+        
+        if (res == B_OK) {
+            // info about the attributes of a catalog...
+            BMessage attrMsg;
+            // ...the catalog signature...
+            attrMsg.AddString("attr:public_name", "Signature");
+            attrMsg.AddString("attr:name", BLocaleRoster::kCatSigAttr);
+            attrMsg.AddInt32("attr:type", B_STRING_TYPE);
+            attrMsg.AddBool("attr:editable", false);
+            attrMsg.AddBool("attr:viewable", true);
+            attrMsg.AddBool("attr:extra", false);
+            attrMsg.AddInt32("attr:alignment", 0);
+            attrMsg.AddInt32("attr:width", 140);
+            // ...the catalog language...
+            attrMsg.AddString("attr:public_name", "Language");
+            attrMsg.AddString("attr:name", BLocaleRoster::kCatLangAttr);
+            attrMsg.AddInt32("attr:type", B_STRING_TYPE);
+            attrMsg.AddBool("attr:editable", false);
+            attrMsg.AddBool("attr:viewable", true);
+            attrMsg.AddBool("attr:extra", false);
+            attrMsg.AddInt32("attr:alignment", 0);
+            attrMsg.AddInt32("attr:width", 60);
+            // ...and the catalog fingerprint...
+            attrMsg.AddString("attr:public_name", "Fingerprint");
+            attrMsg.AddString("attr:name", BLocaleRoster::kCatFingerprintAttr);
+            attrMsg.AddInt32("attr:type", B_INT32_TYPE);
+            attrMsg.AddBool("attr:editable", false);
+            attrMsg.AddBool("attr:viewable", true);
+            attrMsg.AddBool("attr:extra", false);
+            attrMsg.AddInt32("attr:alignment", 0);
+            attrMsg.AddInt32("attr:width", 70);
+            res = mt.SetAttrInfo(&attrMsg);
+        }
+
+        if (res == B_OK) {
+            // file extensions (.catalog):
+            BMessage extMsg;
+            extMsg.AddString("extensions", "catalog");
+            res = mt.SetFileExtensions(&extMsg);
+        }
+
+        if (res == B_OK) {
+            // short and long descriptions:
+            mt.SetShortDescription("Translation Catalog");
+            res = mt.SetLongDescription("Catalog with translated application resources");
+        }
+
+        if (res == B_OK) {
+            // preferred app is catalog manager:
+            res = mt.SetPreferredApp(BLocaleRoster::kCatManagerMimeType, B_OPEN);
+        }
+        
+        if (res == B_OK)
+            res = mt.Install();
+    }
+    if (res != B_OK) {
+        log_team(LOG_ERR, "Could not install mimetype %s (%s)",
+                DefaultCatalog::kCatMimeType, strerror(res));
+    }
+}
+
+
+#if defined(__HAIKU__)
+
+extern "C"
+_IMPEXP_LOCALE 
+void
+initialize_after()
+{
+    SetupCatalogBasics();
+}
+
+#else
+
+// [zooey]:
+//  hack suggested by Ingo Weinhold to make the be_roster work
+//    properly such that we can install mimetypes:
+class BRoster {
+public:
+    void InitMessengers();
+};
+
+extern const BRoster *be_roster;
+
+extern "C"
+_IMPEXP_LOCALE 
+void
+initialize_after()
+{
+    // now force be_roster to initialized state.
+    const_cast<BRoster*>(be_roster)->InitMessengers();
+
+    SetupCatalogBasics();
+}
+
+#endif
+

src/kits/locale/Format.cpp

@@ +1 @@
+#include <Format.h>
+#include <FormatImpl.h>
+
+// copy constructor
+BFormat::BFormat(const BFormat &other)
+    : fImpl(other.fImpl)
+{
+}
+
+// destructor
+BFormat::~BFormat()
+{
+}
+
+// =
+BFormat &
+BFormat::operator=(const BFormat &other)
+{
+    fImpl = other.fImpl;
+    return *this;
+}
+
+// constructor
+BFormat::BFormat(BFormatImpl *impl)
+    : fImpl(impl)
+{
+}
+

src/kits/locale/PropertyFile.h

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+#ifndef PROPERTY_FILE_H
+#define PROPERTY_FILE_H
+
+
+#include <File.h>
+
+
+// This is the read-only version of the PropertyFile class - the
+// genprops tool contains the write-only version of it
+
+
+class PropertyFile : public BFile {
+    public:
+        status_t SetTo(const char *directory, const char *name);
+
+        off_t Size();
+};
+
+#endif  /* PROPERTY_FILE_H */

src/kits/locale/IntegerFormatParameters.cpp

@@ +1 @@
+#include <IntegerFormatParameters.h>
+
+// constructor
+BIntegerFormatParameters::BIntegerFormatParameters(
+    const BIntegerFormatParameters *parent)
+    : BNumberFormatParameters(parent),
+      fParent(parent)
+{
+}
+
+// copy constructor
+BIntegerFormatParameters::BIntegerFormatParameters(
+    const BIntegerFormatParameters &other)
+    : BNumberFormatParameters(other),
+      fParent(other.fParent)
+{
+}
+
+// destructor
+BIntegerFormatParameters::~BIntegerFormatParameters()
+{
+}
+
+// SetParentIntegerParameters
+void
+BIntegerFormatParameters::SetParentIntegerParameters(
+    const BIntegerFormatParameters *parent)
+{
+    fParent = parent;
+    SetParentNumberParameters(parent);
+}
+
+// ParentIntegerParameters
+const BIntegerFormatParameters *
+BIntegerFormatParameters::ParentIntegerParameters() const
+{
+    return fParent;
+}
+
+// =
+BIntegerFormatParameters &
+BIntegerFormatParameters::operator=(const BIntegerFormatParameters &other)
+{
+    BNumberFormatParameters::operator=(other);
+    fParent = other.fParent;
+    return *this;
+}
+

src/kits/locale/adler32.c

@@ +1 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2002 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * [zooey]: 
+ *      This file has been adjusted from the original found in zlib
+ *      for better conformance to our style-guide.
+ */
+
+#include <SupportDefs.h>
+
+#include <LocaleBuild.h>
+
+uint32 _IMPEXP_LOCALE adler32(uint32 adler, const uint8 *buf, uint32 len);
+    // prototype required by mwcc
+
+#define BASE 65521L /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {s1 += buf[i]; s2 += s1;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* ========================================================================= */
+uint32 adler32(uint32 adler, const uint8 *buf, uint32 len) 
+{
+    uint32 s1 = adler & 0xffff;
+    uint32 s2 = (adler >> 16) & 0xffff;
+    int k;
+
+    if (buf == NULL) return 1L;
+
+    while (len > 0) {
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+        while (k >= 16) {
+            DO16(buf);
+            buf += 16;
+            k -= 16;
+        }
+        if (k != 0) do {
+            s1 += *buf++;
+            s2 += s1;
+        } while (--k);
+        s1 %= BASE;
+        s2 %= BASE;
+    }
+    return (s2 << 16) | s1;
+}

src/kits/Jamfile

@@ -92 +92 @@
 SubInclude HAIKU_TOP src kits device ;
 SubInclude HAIKU_TOP src kits game ;
 SubInclude HAIKU_TOP src kits interface ;
+SubInclude HAIKU_TOP src kits locale ;
 SubInclude HAIKU_TOP src kits mail ;
 SubInclude HAIKU_TOP src kits media ;
 SubInclude HAIKU_TOP src kits midi ;

data/etc/locale/languages/français.language

@@ +1 @@
+fr,roman,ltr
+--
+Hier
+Aujourd'hui
+Demain
+Avenir
+
+Dimanche
+Lundi
+Mardi
+Mercredi
+Jeudi
+Vendredi
+Samedi
+
+Dim
+Lun
+Mar
+Mer
+Jeu
+Ven
+Sam
+
+Janvier
+Février
+Mars
+Avril
+Mai
+Juin
+Juillet
+Août
+Septembre
+Octobre
+Novembre
+Décembre
+
+Jan
+Fev
+Mars
+Avr
+Mai
+Juin
+Juil
+Août
+Sep
+Oct
+Nov
+Dec
+

data/etc/locale/languages/deutsch.language

@@ +1 @@
+de,germanic,ltr
+--
+Gestern
+Heute
+Morgen
+Zukunft
+
+Sonntag
+Montag
+Dienstag
+Mittwoch
+Donnerstag
+Freitag
+Samstag
+
+So
+Mo
+Di
+Mi
+Do
+Fr
+Sa
+
+Januar
+Februar
+März
+April
+Mai
+Juni
+Juli
+August
+September
+Oktober
+November
+Dezember
+
+Jan
+Feb
+Mär
+Apr
+Mai
+Jun
+Jul
+Aug
+Sep
+Okt
+Nov
+Dez
+

headers/os/locale/Currency.h

@@ +1 @@
+#ifndef _B_CURRENCY_H_
+#define _B_CURRENCY_H_
+
+#include <Archivable.h>
+#include <Message.h>
+#include <String.h>
+
+#include <LocaleBuild.h>
+
+class BLocale;
+
+class _IMPEXP_LOCALE BCurrency : public BArchivable {
+    public:
+        BCurrency(const BCurrency &other);
+        BCurrency(BMessage *archive);
+        BCurrency(const char *currencyCode);
+        ~BCurrency();
+
+        status_t InitCheck() const;
+
+        virtual status_t Archive(BMessage *archive, bool deep = true) const;
+        static BArchivable *Instantiate(BMessage *archive);
+
+        const char *CurrencyCode() const;
+        const char *DefaultSymbol() const;
+        int32 DefaultFractionDigits() const;
+
+        status_t GetSymbol(char *symbol, size_t maxSize,
+                           BLocale *locale = NULL);
+        status_t GetSymbol(BString *symbol, BLocale *locale = NULL);
+
+        BCurrency &operator=(const BCurrency &other);
+        bool operator==(const BCurrency &other) const;
+        bool operator!=(const BCurrency &other) const;
+
+    private:
+        BCurrency();
+
+        bool _CheckData() const;
+        void _Unset(status_t error);
+
+        BString fCurrencyCode;
+        BString fDefaultSymbol;
+        int32   fDefaultFractionDigits;
+};
+
+#endif  // _B_CURRENCY_H_

headers/os/locale/IntegerFormatParameters.h

@@ +1 @@
+#ifndef _B_INTEGER_FORMAT_PARAMETERS_H_
+#define _B_INTEGER_FORMAT_PARAMETERS_H_
+
+#include <NumberFormatParameters.h>
+
+class _IMPEXP_LOCALE BIntegerFormatParameters : public BNumberFormatParameters {
+    public:
+        BIntegerFormatParameters(const BIntegerFormatParameters *parent = NULL);
+        BIntegerFormatParameters(const BIntegerFormatParameters &other);
+        ~BIntegerFormatParameters();
+
+        void SetParentIntegerParameters(const BIntegerFormatParameters *parent);
+        const BIntegerFormatParameters *ParentIntegerParameters() const;
+
+        BIntegerFormatParameters &operator=(
+            const BIntegerFormatParameters &other);
+
+    private:
+        const BIntegerFormatParameters  *fParent;
+};
+
+#endif  // _B_INTEGER_FORMAT_PARAMETERS_H_

headers/os/locale/GenericNumberFormat.h

@@ +1 @@
+#ifndef _B_GENERIC_NUMBER_FORMAT_H_ 
+#define _B_GENERIC_NUMBER_FORMAT_H_ 
+
+#include <FloatFormatParameters.h>
+#include <IntegerFormatParameters.h>
+
+class BString;
+struct format_field_position;
+
+class _IMPEXP_LOCALE BGenericNumberFormat {
+    public:
+        BGenericNumberFormat();
+        ~BGenericNumberFormat();
+
+        status_t FormatInteger(const BIntegerFormatParameters *parameters,
+                               int64 number, BString *buffer,
+                               format_field_position *positions = NULL,
+                               int32 positionCount = 1,
+                               int32 *fieldCount = NULL,
+                               bool allFieldPositions = false) const;
+
+        status_t FormatInteger(const BIntegerFormatParameters *parameters,
+                               int64 number, char *buffer, size_t bufferSize,
+                               format_field_position *positions = NULL,
+                               int32 positionCount = 1,
+                               int32 *fieldCount = NULL,
+                               bool allFieldPositions = false) const;
+
+        status_t FormatInteger(const BIntegerFormatParameters *parameters,
+                               uint64 number, BString *buffer,
+                               format_field_position *positions = NULL,
+                               int32 positionCount = 1,
+                               int32 *fieldCount = NULL,
+                               bool allFieldPositions = false) const;
+
+        status_t FormatInteger(const BIntegerFormatParameters *parameters,
+                               uint64 number, char *buffer, size_t bufferSize,
+                               format_field_position *positions = NULL,
+                               int32 positionCount = 1,
+                               int32 *fieldCount = NULL,
+                               bool allFieldPositions = false) const;
+
+        status_t FormatFloat(const BFloatFormatParameters *parameters,
+                             double number, BString *buffer,
+                             format_field_position *positions = NULL,
+                             int32 positionCount = 1,
+                             int32 *fieldCount = NULL,
+                             bool allFieldPositions = false) const;
+
+        status_t FormatFloat(const BFloatFormatParameters *parameters,
+                             double number, char *buffer, size_t bufferSize,
+                             format_field_position *positions = NULL,
+                             int32 positionCount = 1,
+                             int32 *fieldCount = NULL,
+                             bool allFieldPositions = false) const;
+
+        // default number format parameters
+
+        status_t SetDefaultIntegerFormatParameters(
+            const BIntegerFormatParameters *parameters);
+        BIntegerFormatParameters *DefaultIntegerFormatParameters();
+        const BIntegerFormatParameters *DefaultIntegerFormatParameters() const;
+
+        status_t SetDefaultFloatFormatParameters(
+            const BFloatFormatParameters *parameters);
+        BFloatFormatParameters *DefaultFloatFormatParameters();
+        const BFloatFormatParameters *DefaultFloatFormatParameters() const;
+
+        // other parameters configuring the formatter
+
+        status_t SetDigitSymbols(const char **digits);
+        status_t SetFractionSeparator(const char *decimalSeparator);
+        status_t SetGroupingInfo(const char **groupingSeparators,
+            size_t separatorCount, size_t *groupSizes, size_t sizeCount);
+        status_t SetExponentSymbol(const char *exponentSymbol,
+            const char *upperCaseExponentSymbol = NULL);
+        status_t SetSpecialNumberSymbols(const char *nan,
+            const char *infinity, const char *negativeInfinity = NULL,
+            const char *upperCaseNaN = NULL,
+            const char *upperCaseInfinity = NULL,
+            const char *upperCaseNegativeInfinity = NULL);
+        status_t SetSignSymbols(const char *plusPrefix,
+            const char *minusPrefix, const char *padPlusPrefix,
+            const char *noForcePlusPrefix = NULL, const char *plusSuffix = NULL,
+            const char *minusSuffix = NULL, const char *padPlusSuffix = NULL,
+            const char *noForcePlusSuffix = NULL);
+        status_t SetMantissaSignSymbols(const char *plusPrefix,
+            const char *minusPrefix, const char *padPlusPrefix,
+            const char *noForcePlusPrefix = NULL, const char *plusSuffix = NULL,
+            const char *minusSuffix = NULL, const char *padPlusSuffix = NULL,
+            const char *noForcePlusSuffix = NULL);
+        status_t SetExponentSignSymbols(const char *plusPrefix,
+            const char *minusPrefix, const char *plusSuffix = NULL,
+            const char *minusSuffix = NULL);
+// TODO: Support engineering representation of scientific format (exponent
+// is a multiple of 3), i.e. allow setting the number of which the exponent
+// must be a multiple of.
+
+        struct Symbol {
+            char    *symbol;
+            int     length;
+            int     char_count;
+
+            Symbol(const char *symbol = NULL);
+            ~Symbol();
+
+            status_t SetTo(const char *symbol);
+            void Unset()    { SetTo(NULL); }
+        };
+        class GroupingInfo;
+        class SignSymbols;
+
+    private:
+        class BufferWriter;
+        class Float;
+        class Integer;
+        struct SpecialNumberSymbols;
+
+        status_t FormatInteger(const BIntegerFormatParameters *parameters,
+                               const Integer &integer, char *buffer,
+                               size_t bufferSize,
+                               format_field_position *positions = NULL,
+                               int32 positionCount = 1,
+                               int32 *fieldCount = NULL,
+                               bool allFieldPositions = false) const;
+
+        const Symbol *DigitSymbols() const;
+        const Symbol *FractionSeparator() const;
+        const GroupingInfo *GetGroupingInfo() const;
+        const Symbol *ExponentSymbol(bool upperCase = false) const;
+        const Symbol *NaNSymbol(bool upperCase = false) const;
+        const Symbol *InfinitySymbol(bool upperCase = false) const;
+        const Symbol *NegativeInfinitySymbol(bool upperCase = false) const;
+        void GetSpecialNumberSymbols(bool upperCase,
+                                     SpecialNumberSymbols *symbols) const;
+        const SignSymbols *GetSignSymbols() const;
+        const SignSymbols *MantissaSignSymbols() const;
+        const SignSymbols *ExponentSignSymbols() const;
+
+        static status_t _SetSymbol(Symbol **symbol, const char *str);
+
+        BIntegerFormatParameters    fIntegerParameters;
+        BFloatFormatParameters      fFloatParameters;
+        Symbol                      *fDigitSymbols;
+        Symbol                      *fFractionSeparator;
+        GroupingInfo                *fGroupingInfo;
+        Symbol                      *fExponentSymbol;
+        Symbol                      *fUpperCaseExponentSymbol;
+        Symbol                      *fNaNSymbol;
+        Symbol                      *fUpperCaseNaNSymbol;
+        Symbol                      *fInfinitySymbol;
+        Symbol                      *fUpperCaseInfinitySymbol;
+        Symbol                      *fNegativeInfinitySymbol;
+        Symbol                      *fUpperCaseNegativeInfinitySymbol;
+        SignSymbols                 *fSignSymbols;
+        SignSymbols                 *fMantissaSignSymbols;
+        SignSymbols                 *fExponentSignSymbols;
+};
+
+#endif  // _B_GENERIC_NUMBER_FORMAT_H_ 

headers/os/locale/LocaleRoster.h

@@ +1 @@
+#ifndef _LOCALE_ROSTER_H_
+#define _LOCALE_ROSTER_H_
+
+#include <LocaleBuild.h>
+
+#include <String.h>
+
+class BLanguage;
+class BLocale;
+class BCollator;
+class BCountry;
+class BCatalog;
+class BCatalogAddOn;
+
+namespace BPrivate {
+    class EditableCatalog;
+};
+
+enum {
+    B_LOCALE_CHANGED    = '_LCC',
+};
+
+class _IMPEXP_LOCALE BLocaleRoster {
+
+    public:
+        BLocaleRoster();
+        ~BLocaleRoster();
+
+//      status_t GetCatalog(BLocale *,const char *mimeType, BCatalog *catalog);
+//      status_t GetCatalog(const char *mimeType, BCatalog *catalog);
+//      status_t SetCatalog(BLocale *,const char *mimeType, BCatalog *catalog);
+
+//      status_t GetLocaleFor(const char *langCode,const char *countryCode);
+
+        status_t GetDefaultCollator(BCollator **) const;
+        status_t GetDefaultLanguage(BLanguage **) const;
+        status_t GetDefaultCountry(BCountry **) const;
+        
+        status_t GetPreferredLanguages(BMessage *) const;
+        status_t SetPreferredLanguages(BMessage *);
+            // the message contains one or more 'language'-string-fields 
+            // which contain the language-name(s)
+
+        status_t GetInstalledLanguages(BMessage *) const;
+            // the message contains one or more 'language'-string-fields 
+            // which contain the language-name(s)
+
+        status_t GetInstalledCatalogs(BMessage *,
+                    const char* sigPattern = NULL,
+                    const char* langPattern = NULL,
+                    int32 fingerprint = 0) const;
+            // the message contains...
+
+//      status_t GetDefaultLanguage(BLanguage *);
+//      status_t SetDefaultLanguage(BLanguage *);
+
+        static const char *kCatLangAttr;
+        static const char *kCatSigAttr;
+        static const char *kCatFingerprintAttr;
+        //
+        static const char *kCatManagerMimeType;
+        static const char *kCatEditorMimeType;
+        //
+        static const char *kEmbeddedCatAttr;
+        static int32 kEmbeddedCatResId;
+
+    private:
+
+        BCatalogAddOn* LoadCatalog(const char *signature, 
+                            const char *language = NULL,
+                            int32 fingerprint = 0);
+        BCatalogAddOn* LoadEmbeddedCatalog(entry_ref *appOrAddOnRef);
+        status_t UnloadCatalog(BCatalogAddOn *addOn);
+        //
+        BCatalogAddOn* CreateCatalog(const char *type,
+                            const char *signature, 
+                            const char *language);
+
+        friend class BCatalog;
+        friend class BPrivate::EditableCatalog;
+        friend status_t get_add_on_catalog(BCatalog*, const char *);
+};
+
+#endif  /* _LOCALE_ROSTER_H_ */

headers/os/locale/Locale.h

@@ +1 @@
+#ifndef _B_LOCALE_H_
+#define _B_LOCALE_H_
+
+
+#include <LocaleBuild.h>
+
+#include <Collator.h>
+#include <Language.h>
+#include <Country.h>
+
+
+class BCatalog;
+class BString;
+class BLocaleRoster;
+
+
+class _IMPEXP_LOCALE BLocale {
+    public:
+        BLocale();
+        ~BLocale();
+
+        BCollator *Collator() const { return fCollator; }
+        BCountry *Country() const { return fCountry; }
+        BLanguage *Language() const { return fLanguage; }
+
+        // see definitions in LocaleStrings.h
+        const char *GetString(uint32 id);
+
+        void FormatString(char *target, size_t maxSize, char *fmt, ...);
+        void FormatString(BString *, char *fmt, ...);
+        void FormatDateTime(char *target, size_t maxSize, const char *fmt, time_t);
+        void FormatDateTime(BString *, const char *fmt, time_t);
+
+        // Country short-hands
+
+        void FormatDate(char *target, size_t maxSize, time_t, bool longFormat);
+        void FormatDate(BString *target, time_t, bool longFormat);
+        void FormatTime(char *target, size_t maxSize, time_t, bool longFormat);
+        void FormatTime(BString *target, time_t, bool longFormat);
+
+        // Collator short-hands
+
+        int StringCompare(const char *, const char *, int32 len = -1, int8 strength = B_COLLATE_DEFAULT) const;
+        int StringCompare(const BString *, const BString *, int32 len = -1, int8 strength = B_COLLATE_DEFAULT) const;
+
+        void GetSortKey(const char *string, BString *key);
+        
+        status_t GetAppCatalog(BCatalog *);
+
+    protected:
+        BCollator   *fCollator;
+        BLanguage   *fLanguage;
+        BCountry    *fCountry;
+};
+
+// global objects
+extern _IMPEXP_LOCALE BLocale *be_locale;
+extern _IMPEXP_LOCALE BLocaleRoster *be_locale_roster;
+
+//----------------------------------------------------------------------
+//--- country short-hands inlines ---
+
+inline void 
+BLocale::FormatDate(char *target, size_t maxSize, time_t timer, bool longFormat)
+{
+    fCountry->FormatDate(target, maxSize, timer, longFormat);
+}
+
+
+inline void 
+BLocale::FormatDate(BString *target, time_t timer, bool longFormat)
+{
+    fCountry->FormatDate(target, timer, longFormat);
+}
+
+
+inline void 
+BLocale::FormatTime(char *target, size_t maxSize, time_t timer, bool longFormat)
+{
+    fCountry->FormatTime(target, maxSize, timer, longFormat);
+}
+
+
+inline void 
+BLocale::FormatTime(BString *target, time_t timer, bool longFormat)
+{
+    fCountry->FormatTime(target, timer, longFormat);
+}
+
+
+//--- locale short-hands inlines ---
+//  #pragma mark -
+
+inline int 
+BLocale::StringCompare(const char *string1, const char *string2, int32 length, int8 strength) const
+{
+    return fCollator->Compare(string1, string2, length, strength);
+}
+
+
+inline int 
+BLocale::StringCompare(const BString *string1, const BString *string2, int32 length, int8 strength) const
+{
+    return fCollator->Compare(string1->String(), string2->String(), length, strength);
+}
+
+
+inline void
+BLocale::GetSortKey(const char *string, BString *key)
+{
+    fCollator->GetSortKey(string, key);
+}
+
+#endif  /* _B_LOCALE_H_ */

headers/os/locale/FloatFormatImpl.h

@@ +1 @@
+#ifndef _B_FLOAT_FORMAT_IMPL_H_
+#define _B_FLOAT_FORMAT_IMPL_H_
+
+#include <NumberFormatImpl.h>
+
+struct format_field_position;
+class BFloatFormatParameters;
+class BString;
+
+class _IMPEXP_LOCALE BFloatFormatImpl : public BNumberFormatImpl {
+    public:
+        BFloatFormatImpl();
+        virtual ~BFloatFormatImpl();
+
+        // formatting
+
+        virtual status_t Format(const BFloatFormatParameters *parameters,
+                                double number, BString *buffer) const = 0;
+        virtual status_t Format(const BFloatFormatParameters *parameters,
+                                double number, BString *buffer,
+                                format_field_position *positions,
+                                int32 positionCount = 1,
+                                int32 *fieldCount = NULL,
+                                bool allFieldPositions = false) const = 0;
+
+        // TODO: ...
+
+
+        virtual BNumberFormatParameters *DefaultNumberFormatParameters();
+        virtual const BNumberFormatParameters *DefaultNumberFormatParameters()
+            const;
+
+        virtual BFloatFormatParameters *DefaultFloatFormatParameters() = 0;
+        virtual const BFloatFormatParameters *DefaultFloatFormatParameters()
+            const = 0;
+};
+
+
+#endif  // _B_FLOAT_FORMAT_IMPL_H_

headers/os/locale/NumberFormat.h

@@ +1 @@
+#ifndef _B_NUMBER_FORMAT_H_
+#define _B_NUMBER_FORMAT_H_
+
+#include <Format.h>
+#include <NumberFormatParameters.h>
+
+class BNumberFormatImpl;
+
+class _IMPEXP_LOCALE BNumberFormat : public BFormat {
+    protected:
+        BNumberFormat(const BNumberFormat &other);
+        ~BNumberFormat();
+
+        BNumberFormat &operator=(const BNumberFormat &other);
+
+        BNumberFormat(BNumberFormatImpl *impl);
+
+    private:
+        inline BNumberFormatImpl *NumberFormatImpl() const;
+};
+
+
+#endif  // _B_NUMBER_FORMAT_H_

headers/os/locale/FloatFormatParameters.h

@@ +1 @@
+#ifndef _B_FLOAT_FORMAT_PARAMETERS_H_
+#define _B_FLOAT_FORMAT_PARAMETERS_H_
+
+#include <NumberFormatParameters.h>
+
+enum float_format_type {
+    B_FIXED_POINT_FLOAT_FORMAT,
+    B_SCIENTIFIC_FLOAT_FORMAT,
+    B_AUTO_FLOAT_FORMAT,            // picks one of the above depending of the
+                                    // number to be formatted
+};
+
+class _IMPEXP_LOCALE BFloatFormatParameters : public BNumberFormatParameters {
+    public:
+        BFloatFormatParameters(const BFloatFormatParameters *parent = NULL);
+        BFloatFormatParameters(const BFloatFormatParameters &other);
+        ~BFloatFormatParameters();
+
+        void SetMinimalFractionDigits(size_t minFractionDigits);
+        size_t MinimalFractionDigits() const;
+
+        void SetMaximalFractionDigits(size_t maxFractionDigits);
+        size_t MaximalFractionDigits() const;
+
+        void SetUseUpperCase(bool useCapitals);
+        bool UseUpperCase() const;
+
+        void SetFloatFormatType(float_format_type type);
+        float_format_type FloatFormatType() const;
+
+        void SetAlwaysUseFractionSeparator(bool alwaysUseFractionSeparator);
+        bool AlwaysUseFractionSeparator() const;
+
+        void SetKeepTrailingFractionZeros(bool keepTrailingFractionZeros);
+        bool KeepTrailingFractionZeros() const;
+
+        void SetParentFloatParameters(const BFloatFormatParameters *parent);
+        const BFloatFormatParameters *ParentFloatParameters() const;
+
+        BFloatFormatParameters &operator=(
+            const BFloatFormatParameters &other);
+
+    private:
+        const BFloatFormatParameters    *fParent;
+        size_t                          fMinimalFractionDigits;
+        size_t                          fMaximalFractionDigits;
+        bool                            fUseUpperCase;
+        float_format_type               fFloatFormatType;
+        bool                            fAlwaysUseFractionSeparator;
+        bool                            fKeepTrailingFractionZeros;
+        uint32                          fFlags;
+};
+
+#endif  // _B_FLOAT_FORMAT_PARAMETERS_H_

headers/os/locale/Country.h

@@ +1 @@
+#ifndef _COUNTRY_H_
+#define _COUNTRY_H_
+
+
+#include <SupportDefs.h>
+#include <LocaleBuild.h>
+#include <LocaleStrings.h>
+#include <String.h>
+
+enum {
+    B_METRIC = 0,
+    B_US
+};
+
+
+class _IMPEXP_LOCALE BCountry {
+    public:
+        BCountry();
+        virtual ~BCountry();
+        
+        virtual const char *Name() const;
+
+        // see definitions below
+        const char *GetString(uint32 id) const;
+
+        // date & time
+
+        virtual void    FormatDate(char *string,size_t maxSize,time_t time,bool longFormat);
+        virtual void    FormatDate(BString *string,time_t time,bool longFormat);
+        virtual void    FormatTime(char *string,size_t maxSize,time_t time,bool longFormat);
+        virtual void    FormatTime(BString *string,time_t time,bool longFormat);
+
+        const char      *DateFormat(bool longFormat) const;
+        const char      *TimeFormat(bool longFormat) const;
+        const char      *DateSeparator() const;
+        const char      *TimeSeparator() const;
+
+        // numbers
+
+        virtual void    FormatNumber(char *string,size_t maxSize,double value);
+        virtual void    FormatNumber(BString *string,double value);
+        virtual void    FormatNumber(char *string,size_t maxSize,int32 value);
+        virtual void    FormatNumber(BString *string,int32 value);
+
+        const char      *DecimalPoint() const;
+        const char      *ThousandsSeparator() const;
+        const char      *Grouping() const;
+
+        const char      *PositiveSign() const;
+        const char      *NegativeSign() const;
+
+        // measurements
+
+        virtual int8    Measurement() const;
+
+        // monetary
+
+        virtual ssize_t FormatMonetary(char *string,size_t maxSize,char *format, ...);
+        virtual ssize_t FormatMonetary(BString *string,char *format, ...);
+
+        const char      *CurrencySymbol() const;
+        const char      *InternationalCurrencySymbol() const;
+        const char      *MonDecimalPoint() const;
+        const char      *MonThousandsSeparator() const;
+        const char      *MonGrouping() const;
+        virtual int32   MonFracDigits() const;
+
+    protected:
+        BCountry(const char **strings);
+
+    private:
+        const char  **fStrings;
+};
+
+#endif  /* _COUNTRY_H_ */

headers/os/locale/UnicodeProperties.h

@@ +1 @@
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+#ifndef _UNICODE_PROPERTIES_H_
+#define _UNICODE_PROPERTIES_H_
+
+
+#include <SupportDefs.h>
+#include <ByteOrder.h>
+
+
+#define PROPERTIES_DIRECTORY    "locale"
+#define PROPERTIES_FILE_NAME    "unicode.properties"
+#define PROPERTIES_FORMAT       'UPro'
+
+
+typedef struct {
+    uint8   size;
+    uint8   isBigEndian;
+    uint32  format;
+    uint8   version[3];
+} UnicodePropertiesHeader;
+
+#endif  /* _UNICODE_PROPERTIES_H_ */

headers/os/locale/IntegerFormat.h

@@ +1 @@
+#ifndef _B_INTEGER_FORMAT_H_
+#define _B_INTEGER_FORMAT_H_
+
+#include <NumberFormat.h>
+#include <IntegerFormatParameters.h>
+
+class BIntegerFormatImpl;
+class BString;
+
+// Note: BIntegerFormat is derived from BIntegerFormatParameters only due
+// to my laziness. The parameters should probably be a private member
+// and this class (and its base classes) should mirror the parameters
+// classes' accessor methods.
+//
+class _IMPEXP_LOCALE BIntegerFormat : public BNumberFormat, public BIntegerFormatParameters {
+    public:
+        BIntegerFormat(const BIntegerFormat &other);
+        ~BIntegerFormat();
+
+        // formatting
+
+        // no-frills version: Simply appends the formatted number to the
+        // string buffer. Can fail only with B_NO_MEMORY or B_BAD_VALUE.
+        status_t Format(int64 number, BString *buffer) const;
+
+        // Appends the formatted number to the string buffer. Additionally
+        // one can get the positions of certain fields in the formatted
+        // number by supplying format_field_position structures with the
+        // field_type set respectively. Passing true for allFieldPositions
+        // will make the method fill in a format_field_position structure for
+        // each field it writes -- the field_type values will be ignored and
+        // overwritten.
+        // In fieldCount, in case it is non-null, the number of fields
+        // written is returned.
+        // B_BUFFER_OVERFLOW is returned, if allFieldPositions is true and
+        // the positions buffer is too small (fieldCount will be set
+        // nevertheless, so that the caller can adjust the buffer size to
+        // make them all fit).
+        status_t Format(int64 number, BString *buffer,
+                        format_field_position *positions,
+                        int32 positionCount = 1,
+                        int32 *fieldCount = NULL,
+                        bool allFieldPositions = false) const;
+
+        // TODO: Format() versions for (char* buffer, size_t bufferSize)
+        // instead of BString*. And, of course, versions for the other
+        // number types (uint64, uint32,...).
+ 
+        // parsing
+        // TODO: ...
+
+        BIntegerFormat &operator=(const BIntegerFormat &other);
+
+        BIntegerFormat(BIntegerFormatImpl *impl);       // conceptually private
+
+    private:
+        inline BIntegerFormatImpl *IntegerFormatImpl() const;
+};
+
+
+#endif  // _B_INTEGER_FORMAT_H_

headers/os/locale/CatalogInAddOn.h

@@ +1 @@
+#ifndef _CATALOG_IN_ADD_ON_H_
+#define _CATALOG_IN_ADD_ON_H_
+
+#include <Catalog.h>
+#include <Entry.h>
+#include <Locale.h>
+#include <LocaleRoster.h>
+#include <Node.h>
+#include <TypeConstants.h>
+
+/*
+ * This header file is somewhat special...
+ *
+ * Since the TR-macros are referencing be_catalog, we want each add-on 
+ * to have its own be_catalog (instead of sharing the one from the lib).
+ * In order to do so, we define another be_catalog in this file, which
+ * will override the one from liblocale.so. 
+ * This way we implement something like add-on-local storage. It would
+ * be desirable to find a better way, so please tell us if you know one!
+ *
+ * Every add-on that wants to use the Locale Kit needs to include this
+ * file once (no more, exactly once!).
+ * You have to include it in the source-file that loads the add-on's
+ * catalog (by use of get_add_on_catalog().
+ *
+ */
+
+BCatalog *be_catalog = NULL;
+    // global that points to this add-on's catalog
+
+
+/*
+ * utility function which determines the entry-ref for "this" add-on:
+ */
+static status_t
+get_add_on_ref(entry_ref *ref) 
+{
+    if (!ref)
+        return B_BAD_VALUE;
+
+    image_info imageInfo;
+    int32 cookie = 0;
+    status_t res = B_ERROR;
+    void *dataPtr = static_cast<void*>(&be_catalog);
+    while ((res = get_next_image_info(0, &cookie, &imageInfo)) == B_OK) {
+        char *dataStart = static_cast<char*>(imageInfo.data);
+        if (imageInfo.type == B_ADD_ON_IMAGE && dataStart <= dataPtr 
+            && dataStart+imageInfo.data_size > dataPtr) {
+            get_ref_for_path(imageInfo.name,ref);
+            break;
+        }
+    }
+    return res;
+}
+
+
+/*
+ * Every add-on should load its catalog through this function, since
+ * it does not only load the add-on's catalog, but it does several
+ * other useful things:
+ *    - be_catalog (the one belonging to this add-on) is initialized
+ *      such that the TR-macros use the add-on's catalog.
+ *    - if givenSig is empty (NULL or "") the add-on's signature is
+ *      used to determine the catalog-sig.
+ *    - if the add-on's executable contains an embedded catalog, that
+ *      one is loaded, too.
+ */
+status_t 
+get_add_on_catalog(BCatalog* cat, const char *givenSig) 
+{
+    if (!cat)
+        return B_BAD_VALUE;
+
+    // determine entry-ref of the add-on this code lives in:
+    entry_ref ref;
+    status_t res = get_add_on_ref(&ref);
+    if (res == B_OK) {
+        // ok, we have found the entry-ref for our add-on,
+        // so we try to fetch the fingerprint from our add-on-file:
+        int32 fp = 0;
+        BNode addOnNode(&ref);
+        addOnNode.ReadAttr(BLocaleRoster::kCatFingerprintAttr, 
+            B_INT32_TYPE, 0, &fp, sizeof(int32));
+        BString sig(givenSig);
+        if (sig.Length() == 0) {
+            res = addOnNode.ReadAttrString("BEOS:MIME", &sig);
+            if (res == B_OK) {
+                // drop supertype from mimetype (should be "application/"):
+                int32 pos = sig.FindFirst('/');
+                if (pos >= 0)
+                    sig.Remove(0, pos+1);
+            }
+        }
+        if (res == B_OK) {
+            // try to load it's catalog...
+            cat->fCatalog 
+                = be_locale_roster->LoadCatalog(sig.String(), NULL, fp);
+            // ...and try to load an embedded catalog, too (if that exists):
+            BCatalogAddOn *embeddedCatalog 
+                = be_locale_roster->LoadEmbeddedCatalog(&ref);
+            if (embeddedCatalog) {
+                if (!cat->fCatalog)
+                    // embedded catalog is the only catalog that was found:
+                    cat->fCatalog = embeddedCatalog;
+                else {
+                    // append embedded catalog to list of loaded catalogs:
+                    BCatalogAddOn *currCat = cat->fCatalog;
+                    while (currCat->fNext)
+                        currCat = currCat->fNext;
+                    currCat->fNext = embeddedCatalog;
+                }
+            }
+            be_catalog = cat;
+        }
+    }
+    return cat->InitCheck();
+}
+
+
+#endif  /* _CATALOG_IN_ADD_ON_H_ */

headers/os/locale/LocaleStrings.h

@@ +1 @@
+#ifndef _LOCALE_STRINGS_H_
+#define _LOCALE_STRINGS_H_
+
+
+enum country_strings {
+    B_COUNTRY_STRINGS_BASE  = 0,
+
+    B_DATE_TIME_FORMAT      = B_COUNTRY_STRINGS_BASE,
+    B_DATE_FORMAT,
+    B_TIME_FORMAT,
+    B_TIME_AM_PM_FORMAT,
+
+    B_SHORT_DATE_TIME_FORMAT,
+    B_SHORT_DATE_FORMAT,
+    B_SHORT_TIME_FORMAT,
+    B_SHORT_TIME_AM_PM_FORMAT,
+
+    B_AM_STRING,
+    B_PM_STRING,
+
+    B_DATE_SEPARATOR,
+    B_TIME_SEPARATOR,
+    B_GROUPING,
+    B_DECIMAL_POINT,
+    B_THOUSANDS_SEPARATOR,
+    B_POSITIVE_SIGN,
+    B_NEGATIVE_SIGN,
+
+    B_CURRENCY_SYMBOL,
+    B_INT_CURRENCY_SYMBOL,
+    B_MON_GROUPING,
+    B_MON_DECIMAL_POINT,
+    B_MON_THOUSANDS_SEPARATOR,
+
+    B_NUM_COUNTRY_STRINGS,
+};
+
+enum language_strings {
+    B_LANGUAGE_STRINGS_BASE = 100,
+
+    B_YESTERDAY_STRING = B_LANGUAGE_STRINGS_BASE,
+    B_TODAY_STRING,
+    B_TOMORROW_STRING,
+    B_FUTURE_STRING,
+
+    B_DAY_1,        // name of the first day of the week, e.g. Sunday
+    B_DAY_2,        // ...
+    B_DAY_3,        //
+    B_DAY_4,
+    B_DAY_5,
+    B_DAY_6,
+    B_DAY_7,
+
+    B_AB_DAY_1,     // abbreviated weekday name, e.g. Sun
+    B_AB_DAY_2,     // ...
+    B_AB_DAY_3,
+    B_AB_DAY_4,
+    B_AB_DAY_5,
+    B_AB_DAY_6,
+    B_AB_DAY_7,
+
+    B_MON_1,        // name of the first month of the year, e.g. January
+    B_MON_2,        // ...
+    B_MON_3,
+    B_MON_4,
+    B_MON_5,
+    B_MON_6,
+    B_MON_7,
+    B_MON_8,
+    B_MON_9,
+    B_MON_10,
+    B_MON_11,
+    B_MON_12,
+
+    B_AB_MON_1,     // abbreviated month name, e.g. Jan
+    B_AB_MON_2,     // ...
+    B_AB_MON_3,
+    B_AB_MON_4,
+    B_AB_MON_5,
+    B_AB_MON_6,
+    B_AB_MON_7,
+    B_AB_MON_8,
+    B_AB_MON_9,
+    B_AB_MON_10,
+    B_AB_MON_11,
+    B_AB_MON_12,
+
+    B_YES_EXPRESSION,
+    B_NO_EXPRESSION,
+    B_YES_STRING,
+    B_NO_STRING,
+
+    B_NUM_LANGUAGE_STRINGS = B_AB_MON_12 - B_LANGUAGE_STRINGS_BASE,
+};
+
+// specials for POSIX compatibility
+enum other_locale_strings {
+    B_OTHER_STRINGS_BASE    = 200,
+
+    B_CODESET   = B_OTHER_STRINGS_BASE,
+    B_ERA,
+    B_ERA_DATE_FORMAT,
+    B_ERA_DATE_TIME_FORMAT,
+    B_ERA_TIME_FORMAT,
+    B_ALT_DIGITS
+};
+
+#endif  /* _LOCALE_STRINGS_H_ */

headers/os/locale/FormatImpl.h

@@ +1 @@
+#ifndef _B_FORMAT_IMPL_H_
+#define _B_FORMAT_IMPL_H_
+
+#include <SupportDefs.h>
+
+#include <LocaleBuild.h>
+
+class BFormatParameters;
+
+class _IMPEXP_LOCALE BFormatImpl {
+    public:
+        BFormatImpl();
+        virtual ~BFormatImpl();
+
+        virtual BFormatParameters *DefaultFormatParameters() = 0;
+        virtual const BFormatParameters *DefaultFormatParameters()
+            const = 0;
+};
+
+#endif  // _B_FORMAT_IMPL_H_

headers/os/locale/Catalog.h

@@ +1 @@
+#ifndef _CATALOG_H_
+#define _CATALOG_H_
+
+#include <LocaleBuild.h>
+
+#include <SupportDefs.h>
+#include <String.h>
+
+class BCatalogAddOn;
+class BLocale;
+class BMessage;
+struct entry_ref;
+
+
+class _IMPEXP_LOCALE BCatalog {
+
+    public:
+        BCatalog();
+        BCatalog(const char *signature, const char *language = NULL,
+            int32 fingerprint = 0);
+        virtual ~BCatalog();
+
+        const char *GetString(const char *string, const char *context = NULL,
+                        const char *comment = NULL);
+        const char *GetString(uint32 id);
+
+        status_t GetData(const char *name, BMessage *msg);
+        status_t GetData(uint32 id, BMessage *msg);
+
+        status_t GetSignature(BString *sig);
+        status_t GetLanguage(BString *lang);
+        status_t GetFingerprint(int32 *fp);
+
+        status_t InitCheck() const;
+        int32 CountItems() const;
+
+        BCatalogAddOn *CatalogAddOn();
+
+    protected:
+        BCatalog(const BCatalog&);
+        const BCatalog& operator= (const BCatalog&);
+            // hide assignment and copy-constructor
+
+        static status_t GetAppCatalog(BCatalog*);
+
+        BCatalogAddOn *fCatalog;
+
+    private:
+        friend class BLocale;
+        friend status_t get_add_on_catalog(BCatalog*, const char *);
+};
+
+
+extern _IMPEXP_LOCALE BCatalog* be_catalog;
+extern _IMPEXP_LOCALE BCatalog* be_app_catalog;
+
+
+#ifndef B_AVOID_TRANSLATION_MACROS
+// macros for easy catalog-access, define B_AVOID_TRANSLATION_MACROS if
+// you don't want these:
+
+#undef TR_CONTEXT
+    // In a single application, several strings (e.g. 'Ok') will be used 
+    // more than once, in different contexts. 
+    // As the application programmer can not know if all translations of
+    // this string will be the same for all languages, each occurrence of
+    // the string must be translated on its own.
+    // Specifying the context explicitly with each string allows the person
+    // translating a catalog to separate these different occurrences of the
+    // same string and tell which strings appears in what context of the 
+    // application.
+    // In order to give the translator a useful hint, the application
+    // programmer needs to define TR_CONTEXT with the context he'd like 
+    // to be associated with the strings used in this specifc source file.
+    // example:
+    //      #define TR_CONTEXT "Folder-Window"
+    // Tip: Use a descriptive name of the class implemented in that 
+    //      source-file. 
+
+
+// Translation macros which may be used to shorten translation requests:
+#undef TR
+#define TR(str) \
+    be_catalog->GetString((str), TR_CONTEXT)
+
+#undef TR_CMT
+#define TR_CMT(str,cmt) \
+    be_catalog->GetString((str), TR_CONTEXT, (cmt))
+
+#undef TR_ALL
+#define TR_ALL(str,ctx,cmt) \
+    be_catalog->GetString((str), (ctx), (cmt))
+
+#undef TR_ID
+#define TR_ID(id) \
+    be_catalog->GetString((id))
+
+
+// Translation markers which can be used to mark static strings/IDs which
+// are used as key for translation requests (at other places in the code):
+/* example:
+        #define TR_CONTEXT "MyDecentApp-Menu"
+
+        static const char *choices[] = {
+            TR_MARK("left"),
+            TR_MARK("right"),
+            TR_MARK("up"),
+            TR_MARK("down")
+        };
+
+        void MyClass::AddChoices(BMenu *menu) {
+            for (char **ch = choices; *ch; ch++) {
+                menu->AddItem(
+                    new BMenuItem(
+                        TR(*ch), 
+                        new BMessage(...)
+                    )
+                )
+            }
+        }
+*/
+#undef TR_MARK
+#define TR_MARK(str) \
+    BCatalogAddOn::MarkForTranslation((str), TR_CONTEXT, "")
+
+#undef TR_MARK_CMT
+#define TR_MARK_CMT(str,cmt) \
+    BCatalogAddOn::MarkForTranslation((str), TR_CONTEXT, (cmt))
+
+#undef TR_MARK_ALL
+#define TR_MARK_ALL(str,ctx,cmt) \
+    BCatalogAddOn::MarkForTranslation((str), (ctx), (cmt))
+    
+#undef TR_MARK_ID
+#define TR_MARK_ID(id) \
+    BCatalogAddOn::MarkForTranslation((id))
+    
+#endif  /* B_AVOID_TRANSLATION_MACROS */
+
+
+/************************************************************************/
+// For BCatalog add-on implementations:
+
+class _IMPEXP_LOCALE BCatalogAddOn {
+        friend class BLocaleRoster;
+    public:
+        BCatalogAddOn(const char *signature, const char *language,
+                      int32 fingerprint);
+        virtual ~BCatalogAddOn();
+
+        virtual const char *GetString(const char *string, 
+                                const char *context=NULL,
+                                const char *comment=NULL) = 0;
+        virtual const char *GetString(uint32 id) = 0;
+
+        status_t InitCheck() const;
+        BCatalogAddOn *Next();
+
+        // the following could be used to localize non-textual data (e.g. icons),
+        // but these will only be implemented if there's demand for such a 
+        // feature:
+        virtual bool CanHaveData() const;
+        virtual status_t GetData(const char *name, BMessage *msg);
+        virtual status_t GetData(uint32 id, BMessage *msg);
+
+        // interface for catalog-editor-app and testing apps:
+        virtual status_t SetString(const char *string, 
+                            const char *translated,
+                            const char *context=NULL,
+                            const char *comment=NULL);
+        virtual status_t SetString(int32 id, const char *translated);
+        //
+        virtual bool CanWriteData() const;
+        virtual status_t SetData(const char *name, BMessage *msg);
+        virtual status_t SetData(uint32 id, BMessage *msg);
+        //
+        virtual status_t ReadFromFile(const char *path = NULL);
+        virtual status_t ReadFromAttribute(entry_ref *appOrAddOnRef);
+        virtual status_t ReadFromResource(entry_ref *appOrAddOnRef);
+        virtual status_t WriteToFile(const char *path = NULL);
+        virtual status_t WriteToAttribute(entry_ref *appOrAddOnRef);
+        virtual status_t WriteToResource(entry_ref *appOrAddOnRef);
+        //
+        virtual void MakeEmpty();
+        virtual int32 CountItems() const;
+
+        // magic marker functions which are used to mark a string/id
+        // which will be translated elsewhere in the code (where it can
+        // not be found since it is references by a variable):
+        static const char *MarkForTranslation(const char *str, const char *ctx, 
+                                const char *cmt);
+        static int32 MarkForTranslation(int32 id);
+
+    protected:
+        virtual void UpdateFingerprint();
+
+        status_t            fInitCheck;
+        BString             fSignature;
+        BString             fLanguageName;
+        int32               fFingerprint;
+        BCatalogAddOn       *fNext;
+        
+        friend class BCatalog;
+        friend status_t get_add_on_catalog(BCatalog*, const char *);
+};
+
+// every catalog-add-on should export these symbols...
+// ...the function that instantiates a catalog for this add-on-type...
+extern "C" _IMPEXP_LOCALE 
+BCatalogAddOn *instantiate_catalog(const char *signature,
+    const char *language, int32 fingerprint);
+// ...the function that creates an empty catalog for this add-on-type...
+extern "C" _IMPEXP_LOCALE 
+BCatalogAddOn *create_catalog(const char *signature,
+    const char *language);
+// ...and the priority which will be used to order the catalog-add-ons:
+extern _IMPEXP_LOCALE uint8 gCatalogAddOnPriority;
+
+
+/*
+ * BCatalog - inlines for trivial accessors:
+ */
+inline status_t
+BCatalog::GetSignature(BString *sig) 
+{
+    if (!sig)
+        return B_BAD_VALUE;
+    if (!fCatalog)
+        return B_NO_INIT;
+    *sig = fCatalog->fSignature;
+    return B_OK;
+}
+
+
+inline status_t 
+BCatalog::GetLanguage(BString *lang) 
+{
+    if (!lang)
+        return B_BAD_VALUE;
+    if (!fCatalog)
+        return B_NO_INIT;
+    *lang = fCatalog->fLanguageName;
+    return B_OK;
+}   
+
+
+inline status_t 
+BCatalog::GetFingerprint(int32 *fp) 
+{
+    if (!fp)
+        return B_BAD_VALUE;
+    if (!fCatalog)
+        return B_NO_INIT;
+    *fp = fCatalog->fFingerprint;
+    return B_OK;
+}
+
+
+inline status_t
+BCatalog::InitCheck() const
+{
+    return fCatalog 
+                ? fCatalog->InitCheck() 
+                : B_NO_INIT;
+}
+
+
+inline int32 
+BCatalog::CountItems() const
+{
+    if (!fCatalog)
+        return 0;
+    return fCatalog->CountItems();
+}
+
+
+inline BCatalogAddOn *
+BCatalog::CatalogAddOn() 
+{
+    return fCatalog;
+}
+
+
+/*
+ * BCatalogAddOn - inlines for trivial accessors:
+ */
+inline BCatalogAddOn *
+BCatalogAddOn::Next() 
+{
+    return fNext;
+}
+
+
+inline const char *
+BCatalogAddOn::MarkForTranslation(const char *str, const char *ctx, 
+    const char *cmt) 
+{
+    return str;
+}
+
+
+inline int32
+BCatalogAddOn::MarkForTranslation(int32 id) 
+{
+    return id;
+}
+
+
+namespace BPrivate {
+
+/*
+ * EditableCatalog
+ */
+class _IMPEXP_LOCALE EditableCatalog : public BCatalog {
+
+    public:
+        EditableCatalog(const char *type, const char *signature, 
+            const char *language);
+        ~EditableCatalog();
+
+        status_t SetString(const char *string, 
+                    const char *translated,
+                    const char *context=NULL,
+                    const char *comment=NULL);
+        status_t SetString(int32 id, const char *translated);
+        //
+        bool CanWriteData() const;
+        status_t SetData(const char *name, BMessage *msg);
+        status_t SetData(uint32 id, BMessage *msg);
+        //
+        status_t ReadFromFile(const char *path = NULL);
+        status_t ReadFromAttribute(entry_ref *appOrAddOnRef);
+        status_t ReadFromResource(entry_ref *appOrAddOnRef);
+        status_t WriteToFile(const char *path = NULL);
+        status_t WriteToAttribute(entry_ref *appOrAddOnRef);
+        status_t WriteToResource(entry_ref *appOrAddOnRef);
+        //
+        void MakeEmpty();
+
+    private:
+        EditableCatalog();
+        EditableCatalog(const EditableCatalog&);
+        const EditableCatalog& operator= (const EditableCatalog&);
+            // hide assignment, default- and copy-constructor
+
+};
+
+} // namespace BPrivate
+
+#endif  /* _CATALOG_H_ */

headers/os/locale/posix/nl_types.h

@@ +1 @@
+#ifndef _NL_TYPES_H_
+#define _NL_TYPES_H_
+
+#define NL_SETD         0
+#define NL_CAT_LOCALE   1
+
+typedef int nl_item;
+typedef void *nl_catd;
+
+#include <LocaleBuild.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern _IMPEXP_LOCALE nl_catd catopen(const char *name, int oflag);
+extern _IMPEXP_LOCALE char *catgets(nl_catd cat,int setID,int msgID,const char *defaultMessage);
+extern _IMPEXP_LOCALE int catclose(nl_catd cat);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _NL_TYPES_H_ */

headers/os/locale/posix/langinfo.h

@@ +1 @@
+#ifndef _LANGINFO_H_
+#define _LANGINFO_H_
+
+#include <LocaleBuild.h>
+
+#include <LocaleStrings.h>
+#include <nl_types.h>
+
+#define CODESET     B_CODESET           /* codeset name */
+#define D_T_FMT     B_DATE_TIME_FORMAT  /* string for formatting date and time */
+#define D_FMT       B_DATE_FORMAT       /* date format string */
+#define T_FMT       B_TIME_FORMAT       /* time format string */
+#define T_FMT_AMPM  B_AM_PM_TIME_FORMAT /* a.m. or p.m. time formatting string */
+#define AM_STR      B_AM_STRING         /* Ante Meridian affix */
+#define PM_STR      B_PM_STRING         /* Post Meridian affix */
+
+/* week day names */
+#define DAY_1       B_DAY_1
+#define DAY_2       B_DAY_2
+#define DAY_3       B_DAY_3
+#define DAY_4       B_DAY_4
+#define DAY_5       B_DAY_5
+#define DAY_6       B_DAY_6
+#define DAY_7       B_DAY_7
+
+/* abbreviated week day names */
+#define ABDAY_1     B_AB_DAY_1
+#define ABDAY_2     B_AB_DAY_2
+#define ABDAY_3     B_AB_DAY_3
+#define ABDAY_4     B_AB_DAY_4
+#define ABDAY_5     B_AB_DAY_5
+#define ABDAY_6     B_AB_DAY_6
+#define ABDAY_7     B_AB_DAY_7
+
+/* month names */
+#define MON_1       B_MON_1
+#define MON_2       B_MON_2
+#define MON_3       B_MON_3
+#define MON_4       B_MON_4
+#define MON_5       B_MON_5
+#define MON_6       B_MON_6
+#define MON_7       B_MON_7
+#define MON_8       B_MON_8
+#define MON_9       B_MON_9
+#define MON_10      B_MON_10
+#define MON_11      B_MON_11
+#define MON_12      B_MON_12
+
+/* abbreviated month names */
+#define ABMON_1     B_AB_MON_1
+#define ABMON_2     B_AB_MON_2
+#define ABMON_3     B_AB_MON_3
+#define ABMON_4     B_AB_MON_4
+#define ABMON_5     B_AB_MON_5
+#define ABMON_6     B_AB_MON_6
+#define ABMON_7     B_AB_MON_7
+#define ABMON_8     B_AB_MON_8
+#define ABMON_9     B_AB_MON_9
+#define ABMON_10    B_AB_MON_10
+#define ABMON_11    B_AB_MON_11
+#define ABMON_12    B_AB_MON_12
+
+#define ERA         B_ERA                   /* era description segments */
+#define ERA_D_FMT   B_ERA_DATE_FORMAT       /* era date format string */
+#define ERA_D_T_FMT B_ERA_DATE_TIME_FORMAT  /* era date and time format string */
+#define ERA_T_FMT   B_TIME_FORMAT           /* era time format string */
+#define ALT_DIGITS  B_ALT_DIGITS            /* alternative symbols for digits */
+
+#define RADIXCHAR   B_DECIMAL_POINT         /* radix char */
+#define THOUSEP     B_THOUSANDS_SEPARATOR   /* separator for thousands */
+
+#define YESEXPR     B_YES_EXPRESSION        /* affirmative response expression */
+#define NOEXPR      B_NO_EXPRESSION         /* negative response expression */
+#define YESSTR      B_YES_STRING            /* affirmative response for yes/no queries */
+#define NOSTR       B_NO_STRING             /* negative response for yes/no queries */
+
+#define CRNCYSTR    B_CURRENCY_SYMBOL       /* currency symbol */
+
+//#define   D_MD_ORDER  57  /* month/day order (local extension) */
+
+#ifdef __cplusplus
+extern "C"
+#endif
+_IMPEXP_LOCALE char *nl_langinfo(nl_item);
+
+#endif  /* _LANGINFO_H_ */

headers/os/locale/posix/monetary.h

@@ +1 @@
+#ifndef _MONETARY_H_
+#define _MONETARY_H_
+
+#include <stdarg.h>
+
+#include <LocaleBuild.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_IMPEXP_LOCALE ssize_t strfmon(char *string, size_t maxSize, const char *format, ...);
+_IMPEXP_LOCALE ssize_t vstrfmon(char *string, size_t maxSize, const char *format, va_list args);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _MONETARY_H_ */

headers/os/locale/FormatParameters.h

@@ +1 @@
+#ifndef _B_FORMAT_PARAMETERS_H_
+#define _B_FORMAT_PARAMETERS_H_
+
+#include <SupportDefs.h>
+
+#include <LocaleBuild.h>
+
+enum format_alignment {
+    B_ALIGN_FORMAT_LEFT,        // reuse B_ALIGN_LEFT/B_ALIGN_RIGHT?
+    B_ALIGN_FORMAT_RIGHT,
+};
+
+class _IMPEXP_LOCALE BFormatParameters {
+    public:
+        BFormatParameters(const BFormatParameters *parent = NULL);
+        BFormatParameters(const BFormatParameters &other);
+        ~BFormatParameters();
+
+        void SetAlignment(format_alignment alignment);
+        format_alignment Alignment() const;
+
+        void SetFormatWidth(size_t width);
+        size_t FormatWidth() const;
+
+        const BFormatParameters *ParentParameters() const;
+
+        BFormatParameters &operator=(const BFormatParameters &other);
+
+    protected:
+        void SetParentParameters(const BFormatParameters *parent);
+
+    private:
+        const BFormatParameters *fParent;
+        format_alignment        fAlignment;
+        size_t                  fWidth;
+        uint32                  fFlags;
+};
+
+#endif  // _B_FORMAT_PARAMETERS_H_

headers/os/locale/FloatFormat.h

@@ +1 @@
+#ifndef _B_FLOAT_FORMAT_H_
+#define _B_FLOAT_FORMAT_H_
+
+#include <NumberFormat.h>
+#include <FloatFormatParameters.h>
+
+class BString;
+class BFloatFormatImpl;
+
+class _IMPEXP_LOCALE BFloatFormat : public BNumberFormat, public BFloatFormatParameters {
+    public:
+        BFloatFormat(const BFloatFormat &other);
+        ~BFloatFormat();
+
+        // formatting
+
+        // no-frills version: Simply appends the formatted number to the
+        // string buffer. Can fail only with B_NO_MEMORY or B_BAD_VALUE.
+        status_t Format(double number, BString *buffer) const;
+
+        // Appends the formatted number to the string buffer. Additionally
+        // one can get the positions of certain fields in the formatted
+        // number by supplying format_field_position structures with the
+        // field_type set respectively. Passing true for allFieldPositions
+        // will make the method fill in a format_field_position structure for
+        // each field it writes -- the field_type values will be ignored and
+        // overwritten.
+        // In fieldCount, in case it is non-null, the number of fields
+        // written is returned.
+        // B_BUFFER_OVERFLOW is returned, if allFieldPositions is true and
+        // the positions buffer is too small (fieldCount will be set
+        // nevertheless, so that the caller can adjust the buffer size to
+        // make them all fit).
+        status_t Format(double number, BString *buffer,
+                        format_field_position *positions,
+                        int32 positionCount = 1,
+                        int32 *fieldCount = NULL,
+                        bool allFieldPositions = false) const;
+
+        // TODO: Format() versions for (char* buffer, size_t bufferSize)
+        // instead of BString*. And, of course, versions for the other
+        // number types (float).
+ 
+        // parsing
+        // TODO: ...
+
+        BFloatFormat &operator=(const BFloatFormat &other);
+
+        BFloatFormat(BFloatFormatImpl *impl);       // conceptually private
+
+    private:
+        inline BFloatFormatImpl *FloatFormatImpl() const;
+};
+
+
+#endif  // _B_FLOAT_FORMAT_H_

headers/os/locale/DefaultCatalog.h

@@ +1 @@
+#ifndef _DEFAULT_CATALOG_H_
+#define _DEFAULT_CATALOG_H_
+
+
+#include <LocaleBuild.h>
+
+#include <DataIO.h>
+#include <Catalog.h>
+#include <String.h>
+#include <assert.h>
+
+#if __GNUC__ > 2
+#   include <ext/hash_map>
+#else
+#   include <hash_map>
+#endif
+
+class BFile;
+
+namespace BPrivate {
+    struct CatKey;
+}
+
+#if __GNUC__ > 2
+namespace __gnu_cxx{
+#endif
+
+template<> struct hash<BPrivate::CatKey> {
+    size_t operator() (const BPrivate::CatKey &key) const;
+};
+
+#if __GNUC__ > 2
+} // __gnu_cxx
+
+using namespace __gnu_cxx;
+#endif
+
+namespace BPrivate {
+
+/*
+ * The key-type for the hash_map which maps native strings or IDs to
+ * the corresponding translated string.
+ * The key-type should be efficient to use if it is just created by an ID
+ * but it should also support being created from up to three strings,
+ * which as a whole specify the key to the translated string.
+ */
+struct _IMPEXP_LOCALE CatKey {
+    BString fKey;
+        // the key-string consists of three values separated by a special 
+        // token:
+        // - the native string
+        // - the context of the string's usage
+        // - a comment that can be used to separate strings that
+        //   are identical otherwise (useful for the translator)
+    size_t fHashVal;
+        // the hash-value of fKey
+    uint32 fFlags;
+        // with respect to the catalog-editor, each translation can be
+        // in different states (empty, unchecked, checked, etc.).
+        // This state (and potential other flags) lives in the fFlags member.
+    CatKey(const char *str, const char *ctx, const char *cmt);
+    CatKey(uint32 id);
+    CatKey();
+    bool operator== (const CatKey& right) const;
+    status_t GetStringParts(BString* str, BString* ctx, BString* cmt) const;
+    static size_t HashFun(const char* s);
+};
+
+/*
+ * The implementation of the Locale Kit's standard catalog-type.
+ * Currently it only maps CatKey to a BString (the translated string),
+ * but the value-type might change to add support for shortcuts and/or
+ * graphical data (button-images and the like).
+ */
+class _IMPEXP_LOCALE DefaultCatalog : public BCatalogAddOn {
+
+    public:
+        DefaultCatalog(const char *signature, const char *language,
+            int32 fingerprint);
+                // constructor for normal use
+        DefaultCatalog(entry_ref *appOrAddOnRef);
+                // constructor for embedded catalog
+        DefaultCatalog(const char *path, const char *signature, 
+            const char *language);
+                // constructor for editor-app
+                       
+        ~DefaultCatalog();
+
+        // overrides of BCatalogAddOn:
+        const char *GetString(const char *string, const char *context = NULL,
+                        const char *comment = NULL);
+        const char *GetString(uint32 id);
+        const char *GetString(const CatKey& key);
+        //
+        status_t SetString(const char *string, const char *translated, 
+                    const char *context = NULL, const char *comment = NULL);
+        status_t SetString(int32 id, const char *translated);
+        status_t SetString(const CatKey& key, const char *translated);
+        void UpdateFingerprint();
+
+        // implementation for editor-interface:
+        status_t ReadFromFile(const char *path = NULL);
+        status_t ReadFromAttribute(entry_ref *appOrAddOnRef);
+        status_t ReadFromResource(entry_ref *appOrAddOnRef);
+        status_t WriteToFile(const char *path = NULL);
+        status_t WriteToAttribute(entry_ref *appOrAddOnRef);
+        status_t WriteToResource(entry_ref *appOrAddOnRef);
+        //
+        void MakeEmpty();
+        int32 CountItems() const;
+
+        static BCatalogAddOn *Instantiate(const char *signature,
+                                const char *language,
+                                int32 fingerprint);
+        static BCatalogAddOn *InstantiateEmbedded(entry_ref *appOrAddOnRef);
+        static BCatalogAddOn *Create(const char *signature,
+                                const char *language);
+        static const uint8 kDefaultCatalogAddOnPriority;
+        static const char *kCatMimeType;
+
+    private:
+        status_t Flatten(BDataIO *dataIO);
+        status_t Unflatten(BDataIO *dataIO);
+        int32 ComputeFingerprint() const;
+        void UpdateAttributes(BFile& catalogFile);
+
+        typedef hash_map<CatKey, BString, hash<CatKey>, equal_to<CatKey> > CatMap;
+        CatMap              fCatMap;
+        mutable BString     fPath;
+
+    public:
+        /*
+         * CatWalker
+         */
+        class CatWalker {
+            public:
+                CatWalker() {}
+                CatWalker(CatMap &catMap);
+                bool AtEnd() const;
+                const CatKey& GetKey() const;
+                const char *GetValue() const;
+                void Next();
+            private:
+                CatMap::iterator fPos;
+                CatMap::iterator fEnd;
+        };
+        status_t GetWalker(CatWalker *walker);      
+};
+
+inline 
+DefaultCatalog::CatWalker::CatWalker(CatMap &catMap)
+    : fPos(catMap.begin()),
+      fEnd(catMap.end())
+{
+}
+
+inline bool 
+DefaultCatalog::CatWalker::AtEnd() const
+{
+    return fPos == fEnd;
+}
+
+inline const CatKey & 
+DefaultCatalog::CatWalker::GetKey() const
+{
+    assert(fPos != fEnd);
+    return fPos->first;
+}
+
+inline const char * 
+DefaultCatalog::CatWalker::GetValue() const
+{
+    assert(fPos != fEnd);
+    return fPos->second.String();
+}
+
+inline void 
+DefaultCatalog::CatWalker::Next()
+{
+    ++fPos;
+}
+
+inline status_t 
+DefaultCatalog::GetWalker(CatWalker *walker)
+{
+    if (!walker)
+        return B_BAD_VALUE;
+    *walker = CatWalker(fCatMap);
+    return B_OK;
+}       
+
+}   // namespace BPrivate
+
+using namespace BPrivate;
+
+#endif  /* _DEFAULT_CATALOG_H_ */

headers/os/locale/LocaleBuild.h

@@ +1 @@
+#ifndef _B_LOCALE_BUILD_H_
+#define _B_LOCALE_BUILD_H_
+
+#define _IMPEXP_LOCALE
+
+#endif  /* _B_LOCALE_BUILD_H_ */

headers/os/locale/Collator.h

@@ +1 @@
+#ifndef _COLLATOR_H_
+#define _COLLATOR_H_
+
+
+#include <SupportDefs.h>
+#include <Archivable.h>
+
+#include <LocaleBuild.h>
+
+class BString;
+class BCollatorAddOn;
+
+
+enum collator_strengths {
+    B_COLLATE_DEFAULT = -1,
+
+    B_COLLATE_PRIMARY = 1,      // e.g.: no diacritical differences, e = é
+    B_COLLATE_SECONDARY,        // diacritics are different from their base characters, a != ä
+    B_COLLATE_TERTIARY,         // case sensitive comparison
+    B_COLLATE_QUATERNARY,
+
+    B_COLLATE_IDENTICAL = 127   // Unicode value
+};
+
+
+class _IMPEXP_LOCALE BCollator : public BArchivable {
+    public:
+        BCollator();
+        BCollator(BCollatorAddOn *collator, int8 strength, bool ignorePunctuation);
+        BCollator(BMessage *archive);
+        ~BCollator();
+
+        void SetDefaultStrength(int8 strength);
+        int8 DefaultStrength() const;
+
+        void SetIgnorePunctuation(bool ignore);
+        bool IgnorePunctuation() const;
+
+        status_t GetSortKey(const char *string, BString *key, int8 strength = B_COLLATE_DEFAULT);
+
+        int Compare(const char *, const char *, int32 len = -1, int8 strength = B_COLLATE_DEFAULT);
+        bool Equal(const char *, const char *, int32 len = -1, int8 strength = B_COLLATE_DEFAULT);
+        bool Greater(const char *, const char *, int32 len = -1, int8 strength = B_COLLATE_DEFAULT);
+        bool GreaterOrEqual(const char *, const char *, int32 len = -1, int8 strength = B_COLLATE_DEFAULT);
+
+        // (un-)archiving API
+        status_t Archive(BMessage *archive, bool deep) const;
+        static BArchivable *Instantiate(BMessage *archive);
+
+    private:
+        BCollatorAddOn  *fCollator;
+        image_id        fCollatorImage;
+        int8            fStrength;
+        bool            fIgnorePunctuation;
+};
+
+
+inline bool 
+BCollator::Equal(const char *s1, const char *s2, int32 len, int8 strength)
+{
+    return Compare(s1, s2, len, strength) == 0;
+}
+
+
+inline bool 
+BCollator::Greater(const char *s1, const char *s2, int32 len, int8 strength)
+{
+    return Compare(s1, s2, len, strength) > 0;
+}
+
+
+inline bool 
+BCollator::GreaterOrEqual(const char *s1, const char *s2, int32 len, int8 strength)
+{
+    return Compare(s1, s2, len, strength) >= 0;
+}
+
+
+/************************************************************************/
+
+// For BCollator add-on implementations:
+
+class _IMPEXP_LOCALE BCollatorAddOn : public BArchivable {
+    public:
+        BCollatorAddOn();
+        BCollatorAddOn(BMessage *archive);
+        virtual ~BCollatorAddOn();
+
+        virtual status_t GetSortKey(const char *string, BString *key, int8 strength,
+                        bool ignorePunctuation);
+        virtual int Compare(const char *a, const char *b, int32 length, int8 strength,
+                        bool ignorePunctuation);
+
+        // (un-)archiving API
+        virtual status_t Archive(BMessage *archive, bool deep) const;
+        static BArchivable *Instantiate(BMessage *archive);
+
+        struct input_context {
+            input_context(bool ignorePunctuation);
+
+            bool    ignore_punctuation;
+            uint32  next_char;
+            int32   reserved1;
+            int32   reserved2;
+        };
+
+    protected:
+        virtual uint32 GetNextChar(const char **string, input_context &context);
+        virtual size_t PrimaryKeyLength(size_t length);
+        virtual char *PutPrimaryKey(const char *string, char *buffer, int32 length,
+                        bool ignorePunctuation);
+};
+
+// If your add-on should work with the standard tool to create a language, it
+// should export that function. However, once the language file has been written
+// only the archived collator is used, and that function won't be called anymore.
+extern "C" _IMPEXP_LOCALE BCollatorAddOn *instantiate_collator(void);
+
+#endif  /* _COLLATOR_H_ */

headers/os/locale/NumberFormatImpl.h

@@ +1 @@
+#ifndef _B_NUMBER_FORMAT_IMPL_H_
+#define _B_NUMBER_FORMAT_IMPL_H_
+
+#include <FormatImpl.h>
+
+struct format_field_position;
+class BNumberFormatParameters;
+
+class _IMPEXP_LOCALE BNumberFormatImpl : public BFormatImpl {
+    public:
+        BNumberFormatImpl();
+        virtual ~BNumberFormatImpl();
+
+        virtual BFormatParameters *DefaultFormatParameters();
+        virtual const BFormatParameters *DefaultFormatParameters() const;
+
+        virtual BNumberFormatParameters *DefaultNumberFormatParameters() = 0;
+        virtual const BNumberFormatParameters *DefaultNumberFormatParameters()
+            const = 0;
+};
+
+#endif  // _B_NUMBER_FORMAT_IMPL_H_

headers/os/locale/Language.h

@@ +1 @@
+#ifndef _LANGUAGE_H_
+#define _LANGUAGE_H_
+
+
+#include <SupportDefs.h>
+#include <LocaleBuild.h>
+#include <LocaleStrings.h>
+
+
+enum script_direction {
+    B_LEFT_TO_RIGHT = 0,
+    B_RIGHT_TO_LEFT,
+    B_TOP_TO_BOTTOM,    // seems not to be supported anywhere else?
+};
+
+
+class _IMPEXP_LOCALE BLanguage {
+    public:
+        ~BLanguage();
+
+        // language name, e.g. "english", "deutsch"
+        const char *Name() const { return fName; }
+        // ISO-639 language code, e.g. "en", "de"
+        const char *Code() const { return fCode; }
+        // ISO-639 language family, e.g. "germanic"
+        const char *Family() const { return fFamily; }
+
+        uint8 Direction() const;
+
+        // see definitions below
+        const char *GetString(uint32 id) const;
+
+    private:
+        friend class BLocaleRoster;
+
+        BLanguage(const char *language);
+        void Default();
+
+        char    *fName, *fCode, *fFamily, *fStrings[B_NUM_LANGUAGE_STRINGS];
+        uint8   fDirection;
+};
+
+#endif  /* _LANGUAGE_H_ */

headers/os/locale/UnicodeChar.h

@@ +1 @@
+#ifndef _UNICODE_CHAR_H_
+#define _UNICODE_CHAR_H_
+
+#include <SupportDefs.h>
+
+#include <LocaleBuild.h>
+
+enum unicode_char_category
+{
+    // Non-category for unassigned and non-character code points.
+    B_UNICODE_UNASSIGNED                = 0,
+
+    B_UNICODE_UPPERCASE_LETTER          = 1,    // Lu
+    B_UNICODE_LOWERCASE_LETTER          = 2,    // Ll
+    B_UNICODE_TITLECASE_LETTER          = 3,    // Lt
+    B_UNICODE_MODIFIER_LETTER           = 4,    // Lm
+    B_UNICODE_OTHER_LETTER              = 5,    // Lo
+    B_UNICODE_NON_SPACING_MARK          = 6,    // Mn
+    B_UNICODE_ENCLOSING_MARK            = 7,    // Me
+    B_UNICODE_COMBINING_SPACING_MARK    = 8,    // Mc
+    B_UNICODE_DECIMAL_DIGIT_NUMBER      = 9,    // Nd
+    B_UNICODE_LETTER_NUMBER             = 10,   // Nl
+    B_UNICODE_OTHER_NUMBER              = 11,   // No
+    B_UNICODE_SPACE_SEPARATOR           = 12,   // Zs
+    B_UNICODE_LINE_SEPARATOR            = 13,   // Zl
+    B_UNICODE_PARAGRAPH_SEPARATOR       = 14,   // Zp
+    B_UNICODE_CONTROL_CHAR              = 15,   // Cc
+    B_UNICODE_FORMAT_CHAR               = 16,   // Cf
+    B_UNICODE_PRIVATE_USE_CHAR          = 17,   // Co
+    B_UNICODE_SURROGATE                 = 18,   // Cs
+    B_UNICODE_DASH_PUNCTUATION          = 19,   // Pd
+    B_UNICODE_START_PUNCTUATION         = 20,   // Ps
+    B_UNICODE_END_PUNCTUATION           = 21,   // Pe
+    B_UNICODE_CONNECTOR_PUNCTUATION     = 22,   // Pc
+    B_UNICODE_OTHER_PUNCTUATION         = 23,   // Po
+    B_UNICODE_MATH_SYMBOL               = 24,   // Sm
+    B_UNICODE_CURRENCY_SYMBOL           = 25,   // Sc
+    B_UNICODE_MODIFIER_SYMBOL           = 26,   // Sk
+    B_UNICODE_OTHER_SYMBOL              = 27,   // So
+    B_UNICODE_INITIAL_PUNCTUATION       = 28,   // Pi
+    B_UNICODE_FINAL_PUNCTUATION         = 29,   // Pf
+    B_UNICODE_GENERAL_OTHER_TYPES       = 30,   // Cn
+
+    B_UNICODE_CATEGORY_COUNT
+};
+
+
+/**
+ * This specifies the language directional property of a character set.
+ */
+
+enum unicode_char_direction { 
+    B_UNICODE_LEFT_TO_RIGHT               = 0, 
+    B_UNICODE_RIGHT_TO_LEFT               = 1, 
+    B_UNICODE_EUROPEAN_NUMBER             = 2,
+    B_UNICODE_EUROPEAN_NUMBER_SEPARATOR   = 3,
+    B_UNICODE_EUROPEAN_NUMBER_TERMINATOR  = 4,
+    B_UNICODE_ARABIC_NUMBER               = 5,
+    B_UNICODE_COMMON_NUMBER_SEPARATOR     = 6,
+    B_UNICODE_BLOCK_SEPARATOR             = 7,
+    B_UNICODE_SEGMENT_SEPARATOR           = 8,
+    B_UNICODE_WHITE_SPACE_NEUTRAL         = 9, 
+    B_UNICODE_OTHER_NEUTRAL               = 10, 
+    B_UNICODE_LEFT_TO_RIGHT_EMBEDDING     = 11,
+    B_UNICODE_LEFT_TO_RIGHT_OVERRIDE      = 12,
+    B_UNICODE_RIGHT_TO_LEFT_ARABIC        = 13,
+    B_UNICODE_RIGHT_TO_LEFT_EMBEDDING     = 14,
+    B_UNICODE_RIGHT_TO_LEFT_OVERRIDE      = 15,
+    B_UNICODE_POP_DIRECTIONAL_FORMAT      = 16,
+    B_UNICODE_DIR_NON_SPACING_MARK        = 17,
+    B_UNICODE_BOUNDARY_NEUTRAL            = 18,
+    
+    B_UNICODE_DIRECTION_COUNT
+};
+
+
+/**
+ * Script range as defined in the Unicode standard.
+ */
+
+enum unicode_char_script {
+    // Script names
+    B_UNICODE_BASIC_LATIN,
+    B_UNICODE_LATIN_1_SUPPLEMENT,
+    B_UNICODE_LATIN_EXTENDED_A,
+    B_UNICODE_LATIN_EXTENDED_B,
+    B_UNICODE_IPA_EXTENSIONS,
+    B_UNICODE_SPACING_MODIFIER_LETTERS,
+    B_UNICODE_COMBINING_DIACRITICAL_MARKS,
+    B_UNICODE_GREEK,
+    B_UNICODE_CYRILLIC,
+    B_UNICODE_ARMENIAN,
+    B_UNICODE_HEBREW,
+    B_UNICODE_ARABIC,
+    B_UNICODE_SYRIAC,
+    B_UNICODE_THAANA,
+    B_UNICODE_DEVANAGARI,
+    B_UNICODE_BENGALI,
+    B_UNICODE_GURMUKHI,
+    B_UNICODE_GUJARATI,
+    B_UNICODE_ORIYA,
+    B_UNICODE_TAMIL,
+    B_UNICODE_TELUGU,
+    B_UNICODE_KANNADA,
+    B_UNICODE_MALAYALAM,
+    B_UNICODE_SINHALA,
+    B_UNICODE_THAI,
+    B_UNICODE_LAO,
+    B_UNICODE_TIBETAN,
+    B_UNICODE_MYANMAR,
+    B_UNICODE_GEORGIAN,
+    B_UNICODE_HANGUL_JAMO,
+    B_UNICODE_ETHIOPIC,
+    B_UNICODE_CHEROKEE,
+    B_UNICODE_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS,
+    B_UNICODE_OGHAM,
+    B_UNICODE_RUNIC,
+    B_UNICODE_KHMER,
+    B_UNICODE_MONGOLIAN,
+    B_UNICODE_LATIN_EXTENDED_ADDITIONAL,
+    B_UNICODE_GREEK_EXTENDED,
+    B_UNICODE_GENERAL_PUNCTUATION,
+    B_UNICODE_SUPERSCRIPTS_AND_SUBSCRIPTS,
+    B_UNICODE_CURRENCY_SYMBOLS,
+    B_UNICODE_COMBINING_MARKS_FOR_SYMBOLS,
+    B_UNICODE_LETTERLIKE_SYMBOLS,
+    B_UNICODE_NUMBER_FORMS,
+    B_UNICODE_ARROWS,
+    B_UNICODE_MATHEMATICAL_OPERATORS,
+    B_UNICODE_MISCELLANEOUS_TECHNICAL,
+    B_UNICODE_CONTROL_PICTURES,
+    B_UNICODE_OPTICAL_CHARACTER_RECOGNITION,
+    B_UNICODE_ENCLOSED_ALPHANUMERICS,
+    B_UNICODE_BOX_DRAWING,
+    B_UNICODE_BLOCK_ELEMENTS,
+    B_UNICODE_GEOMETRIC_SHAPES,
+    B_UNICODE_MISCELLANEOUS_SYMBOLS,
+    B_UNICODE_DINGBATS,
+    B_UNICODE_BRAILLE_PATTERNS,
+    B_UNICODE_CJK_RADICALS_SUPPLEMENT,
+    B_UNICODE_KANGXI_RADICALS,
+    B_UNICODE_IDEOGRAPHIC_DESCRIPTION_CHARACTERS,
+    B_UNICODE_CJK_SYMBOLS_AND_PUNCTUATION,
+    B_UNICODE_HIRAGANA,
+    B_UNICODE_KATAKANA,
+    B_UNICODE_BOPOMOFO,
+    B_UNICODE_HANGUL_COMPATIBILITY_JAMO,
+    B_UNICODE_KANBUN,
+    B_UNICODE_BOPOMOFO_EXTENDED,
+    B_UNICODE_ENCLOSED_CJK_LETTERS_AND_MONTHS,
+    B_UNICODE_CJK_COMPATIBILITY,
+    B_UNICODE_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A,
+    B_UNICODE_CJK_UNIFIED_IDEOGRAPHS,
+    B_UNICODE_YI_SYLLABLES,
+    B_UNICODE_YI_RADICALS,
+    B_UNICODE_HANGUL_SYLLABLES,
+    B_UNICODE_HIGH_SURROGATES,
+    B_UNICODE_HIGH_PRIVATE_USE_SURROGATES,
+    B_UNICODE_LOW_SURROGATES,
+    B_UNICODE_PRIVATE_USE_AREA,
+    B_UNICODE_CJK_COMPATIBILITY_IDEOGRAPHS,
+    B_UNICODE_ALPHABETIC_PRESENTATION_FORMS,
+    B_UNICODE_ARABIC_PRESENTATION_FORMS_A,
+    B_UNICODE_COMBINING_HALF_MARKS,
+    B_UNICODE_CJK_COMPATIBILITY_FORMS,
+    B_UNICODE_SMALL_FORM_VARIANTS,
+    B_UNICODE_ARABIC_PRESENTATION_FORMS_B,
+    B_UNICODE_SPECIALS,
+    B_UNICODE_HALFWIDTH_AND_FULLWIDTH_FORMS,
+
+    B_UNICODE_SCRIPT_COUNT,
+    B_UNICODE_NO_SCRIPT = B_UNICODE_SCRIPT_COUNT
+};
+
+
+/**
+ * Values returned by the u_getCellWidth() function.
+ */
+
+enum unicode_cell_width
+{
+    B_UNICODE_ZERO_WIDTH              = 0,
+    B_UNICODE_HALF_WIDTH              = 1,
+    B_UNICODE_FULL_WIDTH              = 2,
+    B_UNICODE_NEUTRAL_WIDTH           = 3,
+
+    B_UNICODE_CELL_WIDTH_COUNT
+};
+
+
+class _IMPEXP_LOCALE BUnicodeChar {
+    public:
+        static bool IsAlpha(uint32 c);
+        static bool IsAlNum(uint32 c);
+        static bool IsDigit(uint32 c);
+        static bool IsHexDigit(uint32 c);
+        static bool IsUpper(uint32 c);
+        static bool IsLower(uint32 c);
+        static bool IsSpace(uint32 c);
+        static bool IsWhitespace(uint32 c);
+        static bool IsControl(uint32 c);
+        static bool IsPunctuation(uint32 c);
+        static bool IsPrintable(uint32 c);
+        static bool IsTitle(uint32 c);
+        static bool IsDefined(uint32 c);
+        static bool IsBase(uint32 c);
+
+        static int8 Type(uint32 c);
+
+        static uint32 ToLower(uint32 c);
+        static uint32 ToUpper(uint32 c);
+        static uint32 ToTitle(uint32 c);
+        static int32 DigitValue(uint32 c);
+
+        static void ToUTF8(uint32 c, char **out);
+        static uint32 FromUTF8(const char **in);
+        static uint32 FromUTF8(const char *in);
+
+        static size_t UTF8StringLength(const char *str);
+        static size_t UTF8StringLength(const char *str, size_t maxLength);
+
+    private:
+        BUnicodeChar();
+};
+
+
+inline uint32 
+BUnicodeChar::FromUTF8(const char *in)
+{
+    const char *string = in;
+    return FromUTF8(&string);
+}
+
+
+#endif  /* _UNICODE_CHAR_H_ */

headers/os/locale/NumberFormatParameters.h

@@ +1 @@
+#ifndef _B_NUMBER_FORMAT_PARAMETERS_H_
+#define _B_NUMBER_FORMAT_PARAMETERS_H_
+
+#include <FormatParameters.h>
+
+enum number_format_sign_policy {
+    B_USE_NEGATIVE_SIGN_ONLY,
+    B_USE_SPACE_FOR_POSITIVE_SIGN,
+    B_USE_POSITIVE_SIGN,
+};
+
+enum number_format_base {
+    B_DEFAULT_BASE          = -1,   // locale default, usually decimal, but
+                                    // may be something like roman as well
+    B_FLEXIBLE_DECIMAL_BASE = 0,    // same as B_DECIMAL_BASE when formatting,
+                                    // but recognizes octal and hexadecimal
+                                    // numbers by prefix when parsing
+    B_OCTAL_BASE            = 8,
+    B_DECIMAL_BASE          = 10,
+    B_HEXADECIMAL_BASE      = 16,
+};
+
+class _IMPEXP_LOCALE BNumberFormatParameters : public BFormatParameters {
+    public:
+        BNumberFormatParameters(const BNumberFormatParameters *parent = NULL);
+        BNumberFormatParameters(const BNumberFormatParameters &other);
+        ~BNumberFormatParameters();
+
+        void SetUseGrouping(bool useGrouping);
+        bool UseGrouping() const;
+
+        void SetSignPolicy(number_format_sign_policy policy);
+        number_format_sign_policy SignPolicy() const;
+
+        void SetBase(number_format_base base);
+        number_format_base Base() const;
+
+        void SetUseBasePrefix(bool useBasePrefix);
+        bool UseBasePrefix() const;
+
+        void SetMinimalIntegerDigits(size_t minIntegerDigits);
+        size_t MinimalIntegerDigits() const;
+
+        void SetUseZeroPadding(bool zeroPadding);
+        bool UseZeroPadding() const;
+
+        const BNumberFormatParameters *ParentNumberParameters() const;
+
+        BNumberFormatParameters &operator=(
+            const BNumberFormatParameters &other);
+
+    protected:
+        void SetParentNumberParameters(const BNumberFormatParameters *parent);
+
+    private:
+        const BNumberFormatParameters   *fParent;
+        bool                            fUseGrouping;
+        number_format_sign_policy       fSignPolicy;
+        number_format_base              fBase;
+        bool                            fUseBasePrefix;
+        size_t                          fMinimalIntegerDigits;
+        bool                            fUseZeroPadding;
+        uint32                          fFlags;
+};
+
+#endif  // _B_NUMBER_FORMAT_PARAMETERS_H_

headers/os/locale/IntegerFormatImpl.h

@@ +1 @@
+#ifndef _B_INTEGER_FORMAT_IMPL_H_
+#define _B_INTEGER_FORMAT_IMPL_H_
+
+#include <NumberFormatImpl.h>
+
+struct format_field_position;
+class BIntegerFormatParameters;
+class BString;
+
+class _IMPEXP_LOCALE BIntegerFormatImpl : public BNumberFormatImpl {
+    public:
+        BIntegerFormatImpl();
+        virtual ~BIntegerFormatImpl();
+
+        // formatting
+
+        virtual status_t Format(const BIntegerFormatParameters *parameters,
+                                int64 number, BString *buffer) const = 0;
+        virtual status_t Format(const BIntegerFormatParameters *parameters,
+                                int64 number, BString *buffer,
+                                format_field_position *positions,
+                                int32 positionCount = 1,
+                                int32 *fieldCount = NULL,
+                                bool allFieldPositions = false) const = 0;
+
+        // TODO: ...
+
+        virtual BNumberFormatParameters *DefaultNumberFormatParameters();
+        virtual const BNumberFormatParameters *DefaultNumberFormatParameters()
+            const;
+
+        virtual BIntegerFormatParameters *DefaultIntegerFormatParameters() = 0;
+        virtual const BIntegerFormatParameters *DefaultIntegerFormatParameters()
+            const = 0;
+};
+
+
+#endif  // _B_INTEGER_FORMAT_IMPL_H_

headers/os/locale/Format.h

@@ +1 @@
+#ifndef _B_FORMAT_H_
+#define _B_FORMAT_H_
+
+#include <FormatParameters.h>
+#include <SupportDefs.h>
+
+// types of fields contained in formatted strings
+enum {
+    // number format fields
+    B_CURRENCY_FIELD,
+    B_DECIMAL_SEPARATOR_FIELD,
+    B_EXPONENT_FIELD,
+    B_EXPONENT_SIGN_FIELD,
+    B_EXPONENT_SYMBOL_FIELD,
+    B_FRACTION_FIELD,
+    B_GROUPING_SEPARATOR_FIELD,
+    B_INTEGER_FIELD,
+    B_PERCENT_FIELD,
+    B_PERMILLE_FIELD,
+    B_SIGN_FIELD,
+
+    // date format fields
+    // TODO: ...
+};
+
+// structure filled in while formatting
+struct _IMPEXP_LOCALE format_field_position {
+    uint32  field_type;
+    int32   start;
+    int32   length;
+};
+
+class BFormatImpl;
+
+class _IMPEXP_LOCALE BFormat {
+    protected:
+        BFormat(const BFormat &other);
+        ~BFormat();
+
+        BFormat &operator=(const BFormat &other);
+
+        BFormat(BFormatImpl *impl);
+
+    protected:
+        BFormatImpl *fImpl;
+};
+
+#endif  // _B_FORMAT_H_

headers/posix/sys/types.h

@@ -45 +45 @@
 typedef int                 daddr_t;
 typedef char *              caddr_t;
 
-typedef unsigned long       addr_t;
+typedef unsigned long   addr_t;
+
 typedef long                key_t;
 
 #include <null.h>