Method and system for implementing user-defined codeset conversions in a computer system

Abstract

A method and system for performing user-defined code conversions in a computer system. A utility accepts a text file from a user program. This text file contains a series of conditional rules that define a protocol for converting character data between codesets. The utility parses this file and converts it to a binary table format that is then stored in a code conversion table database. The user program then invokes functions contained in the operating system to convert data in accordance with the stored binary table.

Claims

What is claimed is:

1. A computer system, comprising:

an operating system;

an operating system memory;

a code conversion definition text file that is contained within the operating system memory and that is composed of a plurality of operation-based code conversion definition elements, wherein an operation-based code conversion definition element can be a direction conversion definition element, a condition conversion definition element, an operation conversion definition element, or a mapping conversion definition element; and

a code-generating operating system utility that is contained within the operating system memory and can be invoked when the text file is received, the code-generating operating system operating to:

parse the at least one operation-based code conversion definition element when the code-generating operating system utility is invoked;

generate, based on the parsing of the at least one operation-based code conversion definition element, a representation of the text file;

store in the operating system the representation of the received text file in a code conversion database for use in subsequent codeset conversions; and

a binary file contained in the memory, the binary file specifying rules for converting character data from a first codeset to a second codeset, the binary file having been produced, by the code generating operating system utility, from the code conversion definition text file which is composed of a plurality of operation-based code conversion definition elements.

2. The computer system of claim 1, wherein the operation-based code conversion definition elements that form the code conversion definition text file comprise a plurality of operation elements.

3. The computer system of claim 2 wherein at least one of the operation elements comprises an IF-THEN operation.

4. The computer system of claim 2 wherein at least one of the operation elements comprises an OUTPUT operation.

5. The computer system of claim 2 wherein at least one of the operation elements comprises a CONTROL operation.

6. The computer system of claim 1 wherein the operation-based code conversion definition elements that form the code conversion definition text file comprise a plurality of direction elements, where each direction element is comprised of a condition-action pair, where a condition component of the pair identifies a conditional test and where an action component of the pair specifies an action that is to be taken when the conditional test is satisfied.

7. The computer system of claim 1 wherein the operation-based code conversion definition elements that form the code conversion definition text file comprise a plurality of condition elements, where each condition element is comprised of a condition and an expression.

8. The computer system of claim 7 wherein at least one of the condition elements comprises a BETWEEN condition.

9. The computer system of claim 7 wherein at least one of the condition elements comprises an ESCAPE SEQUENCE.

10. The computer system of claim 1 wherein the operation-based code conversion definition elements that form the code conversion definition text file comprise a plurality of mapping elements.

11. The computer system of claim 10 wherein at least one of the mapping elements defines a default mapping.

12. The computer system of claim 11 wherein at least one of the mapping elements defines a range mapping.

13. A method for facilitating codeset conversions in a computer system, the method comprising the steps of:

receiving, in an operating system utility that is implemented in an operating system of the computer system, and that is also specifically designed to facilitate codeset conversions, a text file that specifies operational rules for converting character data from a first codeset to a second codeset, wherein the operational rules are composed of at least one operation-based code conversion definition element, and wherein the at least one operation-based code conversion definition element is a direction conversion definition element, a condition conversion definition element, an operation conversion definition element, or a mapping conversion definition element;

invoking a code-generating operating system utility when the text file is received; parsing, by code-generating operating system utility, the at least one operation-based code conversion definition element when the code-generating operating system utility is invoked;

generating, by the code-generating operating system utility, based on the parsing of the at least one operation-based code conversion definition element, a representation of the text file; and

storing, by the code-generating operating utility, operating system the representation of the text file in a code conversion database for use in subsequent codeset conversions.

14. The method of claim 13, further comprising the steps of:

upon receipt of the text file, converting it to a binary file; and

identifying the binary file as the representation of the received text file to be stored in the database.

15. The method of claim 13, further comprising the steps of:

receiving data that is requested to be converted in accordance with the received text file;

retrieving the representation of the received text file from the data base; and

using the retrieved representation to convert the data from the first codeset to the second codeset.

16. The method of claim 13, further comprising the steps of:

receiving data that is requested to be converted in accordance with the received text file;

retrieving the received text file from the database;

converting the received text file to a binary file; and

using the binary file to convert the character data from the first codeset to the second codeset.

17. A method as recited in claim 13, wherein the method further comprises: converting character data from a first codeset to a second codeset, by the one or more other operating system utilities, based on the representation generated by the code-generating operating system utility which is provided as input to the one or more other operating system utilities.

18. A method as recited in claim 13, wherein the method further comprises:

providing one or more other operating system utilities that can collectively search the code conversion database, establish a shared interface, and use the shared interface to access the representation of the received text file, which is stored in the code conversion database, to perform the codeset conversion in accordance with the at least one operation-based code conversion definition element.

19. A method as recited in claim 18, wherein the method further comprises:

receiving a request to perform a codeset conversion;

invoking a first operating system utility of the one or more other operating system utilities when the request if received;

searching the code conversion database, by the first operating system utility, to determine whether the code conversation information needed to perform the conversion is in the code conversion database;

instantiating, by the first operating system utility, a shared object when it is determined that the code conversation information needed to perform the conversion is in the code conversion database; and

invoking a second operating system utility of the one or more other operating system utilities, wherein the second operating utility interfaces with the shared object, and wherein the shared objects performs the codeset conversion by accessing the representation of the received text file which is stored code conversion database.

20. A method as recited in claim 19, wherein the method further comprises:

releasing the shared object by a third operating system utility.

21. A computer readable medium including computer program code for facilitating codeset conversions in a computer system, said computer readable medium comprising:

computer program code for receiving, in an operating system utility that is implemented in an operating system of the computer system, and that is also specifically designed to facilitate codeset conversions, a text file that specifies operational rules for converting character data from a first codeset to a second codeset, wherein the operational rules are composed of at least one operation-based code conversion definition element, and wherein the at least one operation-based code conversion definition element is a direction conversion definition element, a condition conversion definition element, an operation conversion definition element, or a mapping conversion definition element; computer program code for invoking a code-generating operating system utility when the text file is received;

computer program code for parsing, by code-generating operating system utility, the at least one operation-based code conversion definition element when the code-generating operating system utility is invoked;

computer program code for generating, by the code-generating operating system utility, based on the parsing of the at least one operation-based code conversion definition element, a representation of the text file; and

computer program code for storing, by the code-generating operating utility, in the operating system the representation of the received text file in a code conversion database for use in subsequent codeset conversions.

22. A computer program medium as recited in claim 21, wherein the computer readable medium further comprises:

computer program code for providing one or more other operating system utilities that can collectively search the code conversion database, establish a shared interface, and use the shared interface to access the representation of the received text file, which is stored in the code conversion database, to perform the codeset conversion in accordance with the at least one operation-based code conversion definition element.

23. A computer program medium as recited in claim 22, wherein the computer readable medium further comprises:

computer readable code for receiving a request to perform a codeset conversion;

computer readable code for invoking a first operating system utility of the one or more other operating system utilities when the request if received;

computer readable code for searching the code conversion database, by the first operating system utility, to determine whether the code conversation information needed to perform the conversion is in the code conversion database;

computer readable code for instantiating, by the first operating system utility, a shared object when it is determined that the code conversation information needed to perform the conversion is in the code conversion database; and

computer readable code for invoking a second operating system utility of the one or more other operating system utilities, wherein the second operating utility interfaces with the shared object, and wherein the shared objects performs the codeset conversion by accessing the representation of the received text file which is stored code conversion database.

24. A computer program medium as recited in claim 23, wherein the computer readable medium further comprises:

computer program code for releasing the shared object by a third operating system utility.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates generally to computer systems, and more specifically to user-defined codeset conversions, including operation-based code conversions.

2. Related Art

Computer systems communicate on many different computing platforms. The popularity of the Internet has led to an increased need to transfer documents between these platforms. Difficulties can arise, however, because differing platforms represent character data differently. An overview of character sets and codesets is helpful to understand these difficulties.

A character set is a collection of predefined characters based on the needs of a particular language or use environment. The character set can be composed of alphabetic, numeric, or other characters. Characters may be grouped in a set because they are needed to communicate in a given language or in a given specialized environment. Examples of character sets of the latter type include the symbols necessary to communicate mathematical or chemical formulas.

Once a character set is chosen, a remaining issue is how to represent that character set in a computer system. Collectively, the representation of all the characters of the character set is referred to as a codeset. The codeset defines a set of unambiguous rules that establish a one-to-one relationship between each character of the character set and that character's bit representation. This bit representation can be considered as a graphical image of the character. It is this image that is displayed on the computer screen and the printed page.

The codeset's representation can be dependent on the number of bytes used to represent each character, as well as the computer system's communication protocol. For example, a computer system using a 7-bit communication protocol often represents the same set of characters differently than a computer system using an 8-bit protocol. Thus, the choice of which codeset to use frequently depends on the user's data processing requirements.

For these reasons, two computer systems may employ different codesets even when working in the same language. Consider for example, the Japanese Industrial Standard character set. This character set can be encoded in a variety of codesets, including (1) standardized codesets such as eucJP, or ISO-2022-JP, (2) a user-defined subset of a standardized codeset, or (3) any other non-standard user-defined codeset. There will come a time, however, when these two computer systems need to exchange data. When this occurs, the data must be converted to the receiving computer's native character set. In the past, this has been done by using two approaches: one highly primitive and one highly complex.

The first conversion technique required the user to request a conversion by defining a series of simple one-to-one mappings. These mapping requests were then converted to a binary table. This technique was onerous because it required every mapping to be listed individually. And for multi-byte codesets, this technique was particularly problematic: The conversions often could not be expressed in terms of one-to-one mappings. And even if that was not the case, the resulting table sizes were too large for practical use.

The second conversion technique required the user to write algorithmic converters to a defined application program interface. These converters were typically written in the C programming language, or some other compiled language. As such, a compiler, linker, and debugger was needed to test and verify such converters. This complicated system often led to lengthy development cycles. This invention provides a valuable alternative.

INVENTION SUMMARY

Embodiments of the present invention provide methods and systems that facilitate codeset conversions. In a preferred embodiment, a user-defined text file assigns conversion rules between differing codesets. This text file is composed of one or more conditional, or operation-based, conversion elements. A utility evaluates the rules represented by these elements and produces a table that memorializes the rules in a binary file format. This binary file is then used to transform character data of a first codeset to character data of a second codeset. In this manner, the preferred embodiment converts data between differing codesets in an efficient manner. In fact, the preferred embodiment can convert data between differing multi-byte codesets and between multi- and single-byte codesets. The preferred embodiment does not require the writing of complex algorithmic converter functions and is not limited to primitive one-to-one mapping requests. Nor is the user required to compile the text file, as it is passed to the utility as a text file.

BRIEF DRAWING DESCRIPTIONS

The accompanying drawings illustrate embodiments of the invention that will enable those skilled in the art to make and utilize the invention. In fact, these drawings, when considered with the written disclosure, will enable those skilled in the art to modify these embodiments in a manner that does not depart from the spirit and scope of the invention.

FIG. 1 depicts a computer system that provides for user-defined code conversions in accordance with an embodiment of the present invention.

FIG. 2 provides an overview of logical steps employed in an embodiment of the present invention.

FIG. 3 is a flowchart illustrating steps used in an embodiment of the present invention to store a user-defined code conversion in a database.

FIG. 4 is a flowchart detailing steps used in an embodiment of the present invention to convert codeset data in accordance with the user-defined code conversion.

DETAILED DESCRIPTION

Embodiments of the invention will now be described with reference to the accompanying drawings. It is understood that the invention is not limited to these embodiments, as the teachings contained herein will enable others to modify these embodiments without departing from the spirit and scope of the invention. Accordingly, the invention encompasses all such modifications that are described by the appended claims and their equivalents.

Overview of the Detailed Description

The structure of this disclosure is as follows: A computer system embodying a preferred embodiment of the present invention is described. See FIG. 1. The description then includes a discussion of the syntax and the usefulness of a code conversion definition text file. Included in this discussion are examples of operation-based code conversion definition elements. A logical overview of a preferred embodiment is then described. This overview shows the steps of converting the user-defined code conversion definition file to a binary table that is later used to perform codeset conversions. See FIG. 2. The disclosure continues with more detailed explanations of the definition and conversion processes. See FIGS. 3 and 4. Appendix A provides a detailed version of the text file syntax in Backus-Naur form. Appendix B provides detailed examples of code conversion text files. Each appendix is incorporated into the detailed description by reference.

FIG. 1

The Computer System

A computer system that provides for user-defined code conversions in accordance with an embodiment of the present invention is illustrated in FIG. 1. This system 100 includes an array of components: a central processing unit 102; a user interface 104, which typically consists of a keyboard, a mouse, and a monitor; a primary memory 106, such as a random access memory, for program execution; and a secondary memory 108, such as a disk, for storing programs and data that are not immediately needed for execution. Contained within memories 106, 108 are an operating system 110 that contains instructions and data for managing the computer's resources and a user program 112, that interacts with the operating system to convert data between codesets. In a preferred embodiment, the operating system 110 is based on the UNIX standard. Those skilled in the art will realize, however, that the present invention can be employed in any operating system.

The conversion process begins with the production of a user-defined code conversion definition text file 114, which is composed of a number of operation-based code definition elements 116. These elements 116 are conditional constructs that define the desired codeset conversion. By using these elements 116, codeset conversions can be defined using a text file that does not require individual mappings of each desired conversion. Nor is it necessary to write and debug complicated algorithmic converters. And since the text file 114 is passed to the operating system 110 as a flat text file, it does not have to be compiled by the user. All of these facets result in faster development cycles.

The user program 112 has two functional components: a conversion definer 118 and a conversion requester 120. The conversion definer 118 forwards the text file 114 to a utility of the operating system 110, the geniconvtbl( ) utility 122. In a preferred embodiment, this utility 122 is specifically designed to facilitate code conversions. It does this by accepting the text file 114 and converting it to a binary data file 124. The conversion definer 118 then stores that binary data file 124 in a code conversion table database 126 contained within the operating system 110. The user program's conversion requester 120 then interfaces with three operating system functions, which can be collectively referred to as the iconv subsystem, or individually referred to as iconv_open 128, iconv( ) 130, and iconv_close 132. These functions 128,130,132 perform the codeset conversion according to the rules circumscribed by the text file 114. They do this by instantiating a shared object 134 in RAM 106. In turn, this object 134 interfaces with the binary data file 124 to perform the conversion. To understand how the preferred embodiment accomplishes conversion, it is advantageous to examine the syntax and structure of the text file.

The Code Conversion Definition Text File

In a preferred embodiment, the conversion definition text file 114 is named by listing the "convert from" and "convert to" codesets separated by a percentage sign. Thus, the name for a text file defining the conversion rules for converting codeset data from US-ASCII to ISO8859-1 would be US-ASCII%ISO8859-1. The file 114 is composed of a number of the operation-based code conversion definition elements 116. As pictured, these elements can include directions, conditions, operations, and mappings.

Direction Conversion Definition Elements

In a preferred embodiment, direction elements represent the pinnacle of the code conversion definition element hierarchy. This is so because they are composed of one or more condition-action pairs. Each condition-action pair contains a condition element and an action element. If the predefined condition is met, the corresponding action will be executed. The condition can be (1) a predefined condition element, (2) a name to a predefined condition element, or (3) a condition literal value, true, which will always result in the corresponding action being executed. The action component of the element can be another direction element, an operation element, or a map element. Operation and map elements will be explained below. Condition elements will be explained now.

Condition Conversion Definition Elements

Condition conversion elements specify one or more condition expression elements in a preferred embodiment of the present invention. These condition expression elements can take three forms in this embodiment: (1) BETWEEN condition expression elements; (2) ESCAPE SEQUENCE condition expression elements, and (3) mathematical and logical condition expression elements, which are generically referred to as EXPRESSION elements.

The BETWEEN condition expression element is used to define conversion rules for codeset data contained within one or more comma-separated ranges. For example, the following defines a conversion rule using a direction that is composed of a condition-action pair that uses a BETWEEN condition expression element to apply a predefined operation to all codeset data in the ranges of 0.times.64 and 0.times.7f:

    direction   {
        condition   {
            between 0.times.64...0.times.7f;
        }   operation predefined_operation
    }

    if (remaining_output_buffer < minimum) {
        error E2BIG
    } else {
        output = input[current_character] & 0.times.7f
    }

    operation reset {
        // Emit state reset sequence
        output = predefined_reset_sequence
    }

    // map with a hash mapping table, using hash factor of 10
    map  maptype = hash:10;
    // multiple or range mapping
    // convert hexadecimal range of (0.times.0 to 0.times.10) to (0.times.10 to
     0.times.8f)
    0.times.0...0.times.7f 0.times.10;
    // convert hex value of 0.times.a to 0.times.b
    0.times.a       0.times.b
    // convert undefined input codeset values to 0.times.20
    default         0.times.20;
    // return error is input buffer contains 0.times.80
    0.times.80      error;

    Conversion Definition, e.g., US-ASCII%IS08859-1
        Conversion Definition Elements
            Direction
                Condition: Action Pairs
                    Condition
                       Between
                       Escape Sequence
                       Expression
                    Action
                       Direction
                       Operation
                       Map
            Condition
            Operation
                Operation: Expression Elements
                If-Else Operation Expression
                Output Operation Expression
                Control Operation Expression
            Mapping
                Map Attributes
                    index
                    hash
                    binary
                    dense
                Map Pairs
                    Single Mapping
                    Multiple Mapping
                    Default Mapping

                            APPENDIX A
         BACKUS-NAUR FORM FOR CODE CONVERSION DEFINITION
                            TEXT FILE
    iconv_conversion_definition
        :CONVERSION_NAME`{`definition_element_list`}`
        ;
    definition_element_list
        :definition_element`;`
        .vertline.definition_element_list definition_element`;`
        ;
    definition_element
        :direction
        .vertline.condition
        .vertline.operation
        .vertline.map
        ;
    direction
        :`direction`NAME`{`direction_unit_list`}`
        .vertline.`direction``{`direction_unit_list`}`
        ;
    direction_unit_list
        :direction_unit
        .vertline.direction_unit_list direction_unit
        ;
    direction_unit
        :condition action`;`
        .vertline.condition NAME`;`
        .vertline.NAME action`;`
        .vertline.NAME NAME`;`
        .vertline.`true` action`;`
        .vertline.`true` NAME`;`
        ;
    action
        :direction
        .vertline.map
        .vertline.operation
        ;
    condition
        :`condition`NAME`{`condition list``}`
        .vertline.condition_list condition_expr`;`
        ;
    condition_list
        :condition_expr`;`
        .vertline.condition_list condition_expr`;`
        ;
    condition_expr
        :`between`range_list
        .vertline.expr
        .vertline.`escapeseq`escseq_list`;`
        ;
    range_list
        :range_pair
        .vertline.range_list`,`range_pair
        ;
    range_pair
        :HEXADECIMAL`...`HEXADECIMAL
        ;
    escseq_list
        :escseq
        .vertline.escseq_list`,`escseq
        ;
    escseq
        :HEXADECIMAL
        ;
    map
        :`map`NAME`{`map_list`}`
        .vertline.`map``{`map_list`}`
        .vertline.`map`NAME map_attribute`{`map_list`}`
        .vertline.`map`map_attribute`{`map_list`}`
        ;
    map_attribute
        :map_type`,``output_byte_length``=`DECIMAL
        .vertline.map_type
        .vertline.`output_byte_length``=`DECIMAL`,`map_type
        .vertline.`output_byte_length``=`DECIMAL
        ;
    map_type
        :`maptype``=`map_type_name:DECIMAL
        .vertline.`maptype``=`map_type_name
        ;
    map_type_name
        :`automatic`
        .vertline.`index`
        .vertline.`hash`
        .vertline.`binary`
        .vertline.`dense`
        ;
    map_list
        :map_pair
        .vertline.map_list map_pair
        ;
    map_pair
        :HEXADECIMAL HEXADECIMAL
        .vertline.HEXADECIMAL`...`HEXADECIMAL
        .vertline.`default`HEXADECIMAL
        .vertline.`default``no_change_copy`
        .vertline.HEXADECIMAL`error`
        ;
    operation
        :`operation`NAME`{`op_list`}`
        .vertline.`operation``{`op_list`}`
        .vertline.`operation``init``{`op_list`}`
        .vertline.`operation``reset``{`op_list`}`
        ;
    op_list
        :op_unit
        .vertline.op_list op_unit
        ;
    op_unit
        :`;`
        .vertline.expr`;`
        .vertline.`error``;`
        .vertline.`error`expr`;`
        .vertline.`discard``;`
        .vertline.`discard`expr`;`
        .vertline.`output``=`expr`;`
        .vertline.`direction`NAME`;`
        .vertline.`operation`NAME`;`
        .vertline.`operation``init``;`
        .vertline.`operation``reset``;`
        .vertline.`map`NAME`;`
        .vertline.`map`NAME expr`;`
        .vertline.op_if_else`;`
        .vertline.`return``;`
        .vertline.`printch`expr`;`
        .vertline.`printhd`expr`;`
        .vertline.`printint`expr`;`
        ;
    op_if_else
        :`if``(`expr`)``{`op_list`}`
        .vertline.`if``(`expr`)``{`op_list`}``else`op_if_else
        .vertline.`if``(`expr`)``{`op_list`}``else``{`op_list`}`
        ;
    expr
        :`(`expr`)`
        .vertline.NAME
        .vertline.HEXADECIMAL
        .vertline.DECIMAL
        .vertline.`input``[`expr`]`
        .vertline.`outputsize`
        .vertline.`inputsize`
        .vertline.`true`
        .vertline.`false`
        .vertline.`input```==`expr
        .vertline.`expr```==``input`
        .vertline.`!`expr // false expression
        .vertline.`.about.`expr // bitwise complement expression
        .vertline.`-`expr // unary minus expression
        .vertline.expr`+`expr
        .vertline.expr`-`expr
        .vertline.expr`*`expr // multiplication expression
        .vertline.expr`/`expr
        .vertline.expr`%`expr // remainder expression
        .vertline.expr`<<`expr // left-shift expression
        .vertline.expr`>>`expr // right-shift expression
        .vertline.expr`.vertline.`expr // bitwise OR expression
        .vertline.expr` `expr // exclusive OR expression
        .vertline.expr`&`expr // bitwise AND expression
        .vertline.expr`==`expr // equal-to expression
        .vertline.expr`!=`expr // inequality expression
        .vertline.expr`>`expr
        .vertline.expr`>=`expr
        .vertline.expr`<`expr
        .vertline.expr`<=`expr
        .vertline.NAME`=`expr
        .vertline.expr`.vertline..vertline.`expr // logical OR
        .vertline.expr`&&`expr // logical AND
        ;
                            APPENDIX B
          CODE CONVERSION DEFINITION TEXT FILE EXAMPLES
    Example 1: Code Conversion from ISO 8859-1 to ISO 646
        // lconv code conversion from ISO 8859-1 to ISO 646
        ISO8859-1% ISO646
        {
            // Use dense-encoded internal data structure
            map maptype = dense
            {
                default 0.times.3f;
                0.times.0...0.times.7f 0.times.0;
            };
        }
    Example 2: Code Conversion from eucJP to ISO-2022-JP
        // lconv code conversion from eucJP to ISO-2022-JP
        # include <sys/errno.h>
        euJP%ISO-2022-JP   {
            operation init     {
                // set codesubset to ASCII
                codesubset=1
            };
            operation reset {
                If (codesubset != 0) {
                    // Emit state reset sequence, ESC (J for ISO-2202-JP)
                    output = 0.times.1b284a;
                }
                operation init;
            };
                direction   {
                    condition       {     //JIS .times. 0201 Latin (ASCII)
                       between 0.times.00...0.times.7f;
                    }operation      {
                       if (codesubset != 0)   {
                           // we will emit four bytes
                           If (outputsize <=3) {
                               error E2BIG
                           }
                           // Emit state reset sequence, ESC (J.
                           output = 0.times.1b284a
                           // set codesubset to ASCII
                           codesubset = 0;
                       } else {
                           if outputsize <=0)
                               error E2BIG
                           }
                       }
                       output = input [0];
                       // Move input buffer pointer one byte.
                       discard;
                    };
                    condition   {       // JIS .times. 0208
                       between 0.times.a1a1...0.times.fefe;
                    }operation  {
                       if (codesubset != 1) {
                           if (outputsize <=4) {
                               error E2BIG
                           }
                           // Emit JIS .times. 0208 sequence, ESC $ B.
                           output = 0.times.1b2442
                           codesubset = 1
                       } else {
                           if outputsize <=1)
                               error E2BIG
                           }
                       }
                       output = input [0] & 0.times.7f;
                       output = input [1] & 0.times.7f;
                       // Move input buffer pointer two bytes.
                       discard 2;
                    };
                    condition       {     // JIS .times. 0201 Kana
                       between 0.times.8ea1...0.times.8edf;
                    }operation      {
                       if (codesubset != 2)   {
                           if (outputsize <=3) {
                               error E2BIG
                           }
                           // Emit JIS .times. 0201 Kana sequence, ESC (I.
                           output = 0.times.1b2849
                           codesubset = 2
                       } else {
                           if outputsize <=0)
                               error E2BIG
                           }
                       }
                       output = input [1] & 127;
                       // Move input buffer pointer two bytes.
                       discard 2;
                    };
                    condition   {   //JIS .times. 0212
                       between 0.times.8fa1a1...0.times.8ffefe;
                    } operation     {
                       if (codesubset != 3)   {
                           if (outputsize <=5) {
                               error E2BIG
                           }
                           // Emit JIS .times. 0212 sequence, ESC $ (D.
                           output = 0.times.1b242844
                           codesubset = 3



                       } else {
                           if outputsize <=1)
                               error E2BIG
                           }
                       }
                       output = input [1] & 127;
                       output = input [2] & 127;
                       // Move input buffer pointer three bytes.
                       discard 3;
                };
                true        operation { // error
                           error EILSEQ
                };
            };
        }

• Inventors
  Sung, Ienup; Mtwa, Thembile; Kazunori, Ashizawa;
• Assignee
  Sun Microsystems, Inc. (Santa Clara, CA)
• Published
  Mar-16-2004
• Current US Classes:
  715/531
  717/140
• Application #
  371616
• International Classes
  G06F 017/21
• Field of Search
  707/531 341/90 341/106 345/467 345/469 717/140 715/531
• Examiner
  Shah; Sanjiv
• Agent
  Beyer Weaver & Thomas, LLP
• US Patent References:
  5389924
  5699524
  5831560
  5898874
  5936636