Culture-Specific Data Handling

Culture-specific data handling may be part of a program, and such a program may supply different data for different locales. In addition, a program may use different algorithms to process character data based on the language and culture. For example, recognition of the start and end of a word and the method of hyphenation of a word across two lines varies depending on the locale. Programs that deal with such functionality need access to these tables or algorithms based on the current locale setting at run time. You can handle such programs in the following ways:

• Compile all the algorithms and tables, and load them with the program.

  This method makes it difficult to add or modify the algorithms and tables. Whenever a new algorithm or table is added, the entire program must be relinked.

• Keep the locale-specific algorithms and tables in a file, and load them at run time, depending on the current locale setting.

  This method makes it easier to modify and add algorithms and tables. However, there is no standard defined way to load algorithms. In AIX, you can achieve this using the load subroutine, but programs that use the load subroutine might not be portable to other systems.

Culture-Specific Tables

If the culture-specific data can be processed by accessing tables based on the current locale setting, then this can be accomplished by using the standard file I/O subroutines (fopen, fread, open, read, and so on). Such tables must be provided in the directory defined in /usr/lpp/Name where Name is the name of the particular application under the appropriate locale name.

Standard path prefix

/usr/lpp/Name (AIX-specific pathname)

Culture-specific directory

Obtain the current locale for the appropriate category that describes the tables. Concatenate it to the above prefix.

Access

Use standard file access subroutines (fopen, fread, and so on) as appropriate.

Culture-Specific Algorithms

The culture-specific algorithms reside in the /usr/lpp/Name/%L directory. Here %L represents the current locale setting for the appropriate category.

Use the load subroutine to access program-specific algorithms from an object module.

Standard path prefix

/usr/lpp/Name

Culture-specific directory

Obtain the current locale for the appropriate category. Concatenate it to the above prefix.

Method

Concatenate the method name to it.

Example of Loading a Culture-Specific Module for Arabic Text for an Application

Header File

The methods.h include file has one structure as follows:

struct Methods {
        int     version;
        char    *(*hyphen)();
        char    *(*wordbegin)();
        char    *(*wordend)();
} ;

Main Program

In this example, the program name is textpr.

The main program determines the module to load and invokes it. Note that the textpr.h include file is used to specify the path name of the load object. This way, the path name, which is system-specific, can be changed easily.

#include    <stdio.h>
#include    <errno.h>
#include    "methods.h"
#include    "textpr.h"    /* contains the pathname where
                             the load object can be found */

extern     int   errno;

main()
{
     char libpath[PATH_MAX];   /* stores the full pathname of the
                                  load object */
      char *prefix_path=PREFIX_PATH;        /* from textpr.h */
      char *method=METHOD;                  /* from textpr.h */
      int (*func)();
      char *path;
      /* Methods */
      int   ver;
      char  *p;
      struct Methods *md;
      
  
      setlocale(LC_ALL, "");

      path = setlocale(LC_CTYPE, 0);    /* obtain the locale 
                                         for LC_CTYPE category */
      /* Construct the full pathname for the */
      /* object to be loaded                 */
      strcpy(libpath, prefix_path);
      strcat(libpath, path);
      strcat(libpath, "/");
      strcat(libpath, method);
   
      func = load(conv, 1, libpath);        /* load the object */
      if(func==NULL){
            strerror(errno);
            exit(1);
      }
      /* invoke the loaded module ");
      md =(struct Methods *) func();       /* Obtain the methods
                                              structure */
      ver = md->version;
      /* Invoke the methods as needed */
      p = (md->hyphen)();
      p = (md->wordbegin)();
      p = (md->wordend)();
}

Methods

This module contains culture-specific algorithms. In this example, it provides the Arabic method. The method.c program follows:

#include "methods.h"

char *Arabic_hyphen(char *);
char *Arabic_wordbegin(char *);
char *Arabic_wordend(char *);

static struct Methods ArabicMethods= {
        1,
        Arabic_hyphen,
        Arabic_wordbegin,
        Arabic_wordend
} ;

struct Methods *start_methods()
{
        /* startup methods */
        return ( &ArabicMethods);
}

char *Arabic_hyphen(char *string)
{
        /* Arabic hyphen */
        return( string );
}
char *Arabic_wordbegin(char *string)
{
        /*Arabic word begin */);
        return( string );
}
char *Arabic_wordend(char *string)
{
        /* Arabic word end */;
        return( string);
}

Include File

The textpr include file contains the path name of the module to be loaded.

#define PREFIX_PATH "/usr/lpp/textpr"   
                    /* This is an AIX-specific pathname */