/* * $Header: oals.h 05-feb-2001.15:08:01 dthakuri Exp $ */ /* Copyright (c) 1991 by Oracle Corporation */ /* NAME oals.h - Office Automation Language Support DESCRIPTION NLS support functions. These functions fill some of the holes in functionality in the NLS runtime library. PUBLIC FUNCTION(S) oalstol - OA Language String TO Long oalsubx - OA Language SUBstring eXtract oalsstr - OA Language Search for subSTRing oalsceq - OA Language String Compare for EQuality oalscfc - OA Language String Compare Future Character oalsbgc - OA Language Single-Byte Get Character oalschq - OA Language Support CHaracter eQuals oalsadv - OA Language Support ADVance PRIVATE FUNCTION(S) RETURNS NOTES Because these functions often call the more-specific NLSRTL functions, your code may be more efficient if you used those functions instead of these. MODIFIED (MM/DD/YY) dthakuri 02/05/01 - Olint error fix. ewinner 10/07/96 - core3 upgrade tkukulsk 04/13/94 - fix synatax error, add macro to header tkukulsk 04/11/94 - add some useful macros tkukulsk 04/11/94 - add OALS_NONE to public constants tkukulsk 03/17/94 - add prototype for oalsadv tkukulsk 02/22/94 - Creation */ #ifndef OALS #define OALS # ifndef S # include # endif # ifndef LX # include # endif /* LX */ /* PUBLIC TYPES AND CONSTANTS */ /* the following bit patterns are used to indicate options to NLS functions */ /* no special equivalence is to be used */ #define OALS_NONE 0 /* single-byte and multi-byte are equivalent */ #define OALS_SM 1 /* comparison should be done case-insensitive */ #define OALS_UL 2 /* copy to single-byte */ #define OALS_SB 4 /* copy to multibyte */ #define OALS_MB 8 /* copy to uppercase */ #define OALS_UC 16 /* copy to lowercase */ #define OALS_LC 32 /* the following two function's definition is nowhere to be found neither has it been invoked anywhere. That's why, commenting it out in order to take care of Olint errors. */ #ifdef NEVER uword oalstol (/*_ listp *, sb4 *, lxglo * _*/); #endif /* * NAME * * oalstol - OA Language String TO Long * * * USE * * uword oalstol ( listp *reader, slong *result, lxglo *glo ); * * * DESCRIPTION * * This reads an integer value (Base 10) from an open string. * * Leading whitespace, and the number itself will be consumed, if a * value is returned. * * * PARAMETERS * * listp *reader - (IN/OUT) Handle to a string opened for reading. * * slong *result - (OUT) Pointer to a signed long integer. If a value is * succesfully read, it will be placed here. * * lxglo *glo - (IN/OUT) Pointer to NLSRTL global scratch. * * uword - Number of characters (not neccisarily bytes) consumed. * * * NOTES * * A minus-sign may be placed before the first digit in order to input * a negative number. * * This does not distinguish between single-byte and multibyte text * * If no number is read, or if the value overflows, and * remain unchanged, and zero is returned * * If the number exceeds SB4MAXVAL, the entire number is consumed, and * SB4MAXVAL is returned. (The negative case also holds) * */ size_t oalsubx(/*_ text *dest, text *source, uword start, uword len, uword flags, lx_langid lid, lxglo *glo _*/); /* * NAME * * oalsubx - OA Language SUBstring eXtract * * * USE * * size_t oalsubx ( text *dest, text *source, uword start, uword len, * uword flags, lx_langid lid, lxglo *glo ); * * * DESCRIPTION * * This copies a substring from to . * * The initial characters of are skipped, and then * additional characters are copied, providing that end-of-string * is not encountered. is then NULL-terminated. * * The number of bytes written to DEST (including NULL-termination) * is returned. * * * PARAMETERS * * text *dest - (OUT) Pointer to destination buffer. * * text *source - (IN) Pointer to source buffer. * * uword start - Number of characters to skip before copying. * * uword len - Maximum number of characters to copy. * * uword flags - how should this substring be copied? * -- OALS_SB convert to single-byte * -- OALS_MB convert to multi-byte * -- OALS_UC convert to upper-case * -- OALS_LC convert to lower-case * - ( X-byte flags may be combined with X-case * flags, but performance will be reduced) * * lx_langid lid - language ID for use by NLSRTL * * lxglo *glo - (IN/OUT) Pointer to NLSRTL global scratch. * * size_t - Number of bytes requred to store output string. * * * NOTES * * If you already have a handle to the beginning of the substring, it * will be slightly more efficient to use inline code top copy the substring. * * If you specify that you want to convert both the CASE and the * SM-byte-ness of a string, performance will be greatly reduced. * INSTEAD, if you have an extra buffer, do one conversion and then * the other. */ /* the following two function's definition is nowhere to be found neither has it been invoked anywhere. That's why, commenting it out in order to take care of Olint errors. */ #ifdef NEVER sword oalsstr (/*_ listp *reader, text *pat, uword flags, lxglo *glo _*/); #endif /* * NAME * * oalsstr - OA Language Search for subSTRing * * * USE * * sword oalsstr ( listp *reader, text *pat, uword flags, lxglo *glo ); * * DESCRIPTION * * Finds first occurence of within , advances * to the beginning of the matching string, and returns the * number of characters skipped. If no match is found, will be * unchanged, and a value of -1 will be returned. * * is used to indicate various types of equivalency (see parameters) * * PARAMETERS * * listp *reader - (IN/OUT) Handle to a string opened for reading. * * text *pat - (IN) Pointer to the string to be searched for in * * uword flags - Bit field, specifying equvalency. * -- OALS_SM accept "" as equivalent to "A" * -- OALS_UL accept "a" as equivalent to "A" * modes may be OR-ed together * * lxglo *glo - (IN/OUT) Pointer to NLSRTL global scratch. * * uword - Number of characters (not neccisarily bytes) consumed. * * * NOTES * * performance may drop off quickly when uppercase/lowercase equivalency * is turned on, because of the increased number of function calls * */ /* the following two function's definition is nowhere to be found neither has it been invoked anywhere. That's why, commenting it out in order to take care of Olint errors. */ #ifdef NEVER uword oalschq (/*_ listp *a, listp *b, uword flags, lxglo *glo _*/); #endif /* * NAME * * oalschq - OA Language Support CHaracter eQuals * * * USE * * uword oalschq ( listp *a, listp *b, uword flags, lxglo *glo ); * * DESCRIPTION * * returns TRUE if the current characters of and are equivalent * * is used to indicate various types of equivalency (see parameters) * * PARAMETERS * * listp *a - (IN) Handle to a string opened for reading. * * listp *b - (IN) Handle to a string opened for reading. * * uword flags - Bit field, specifying equvalency. * -- OALS_SM accept "" as equivalent to "A" * -- OALS_UL accept "a" as equivalent to "A" * modes may be OR-ed together * * lxglo *glo - (IN/OUT) Pointer to NLSRTL global scratch. * * uword - Number of characters (not neccisarily bytes) consumed. * * * NOTES * * Performance may drop off quickly when doing uppercase/lowercase * equivalence, due to the increased number of function calls required. * */ uword oalsceq (/*_ text *a,text *b, uword flags, lx_langid lid,lxglo *glo_*/); /* * NAME * * oalsceq - OA Language String Compare for EQuality * * * USE * * uword oalsceq ( text *a,text *b,uword flags, lx_langid lid, lxglo *glo ); * * DESCRIPTION * * Finds first occurence of within , advances * to the beginning of the matching string, and returns the * number of characters skipped. If no match is found, will be * unchanged, and a value of -1 will be returned. * * is used to indicate various types of equivalency (see parameters) * * PARAMETERS * * text *a - (IN) Pointer to a closed native string * * text *b - (IN) Pointer to a closed native string * * uword flags - Bit field, specifying equvalency desired * -- OALS_SM accept "" as equivalent to "A" * -- OALS_UL accept "a" as equivalent to "A" * modes may be OR-ed together * * lx_langid lid - language ID for use by NLSRTL * * lxglo *glo - (IN/OUT) Pointer to NLSRTL global scratch. * * uword - TRUE if and are equivalent as specified * in * * NOTES * * This function checks for equivalence. It does not compare strings. * Because of this, it cannot be used for sorting, but may be faster * than string comparison. * * */ /* the following two function's definition is nowhere to be found neither has it been invoked anywhere. That's why, commenting it out in order to take care of Olint errors. */ #ifdef NEVER uword oalscfc (/*_ listp *reader, uword nchars , text c , uword flags, lxglo *glo _*/); #endif /* * NAME * * oalscfc - OA Language String Compare Future Character * * * USE * * uword oalscfc ( listp *reader, uword nchars , text c , uword flags, * lx_langid lid, lxglo *glo ); * * DESCRIPTION * * Skips ahead within and compares that character * with . The comparison is specified by . This is merely a * comparison for equality. This cannot be used for sorting. * * is used to indicate various types of equivalency (see parameters) * * PARAMETERS * * listp *reader - (IN) String handle opened for reading * * uword nchars - number of characters to skip before comparison * * text c - Single-byte character to be compared against * the future character in * * uword flags - Bit field, specifying equvalency desired * -- OALS_SM accept "" as equivalent to "A" * -- OALS_UL accept "a" as equivalent to "A" * modes may be OR-ed together * * lx_langid lid - language ID for use by NLSRTL * * lxglo *glo - (IN/OUT) Pointer to NLSRTL global scratch. * * uword - TRUE if and are equivalent as specified * in * * NOTES * * This function checks for equivalence. It does not compare strings. * Because of this, it cannot be used for sorting. * */ /* the following two function's definition is nowhere to be found neither has it been invoked anywhere. That's why, commenting it out in order to take care of Olint errors. */ #ifdef NEVER text oalsbgc (/*_ listp *reader, uword flags, lxglo *glo _*/); #endif /* * NAME * * oalsbgc - OA Language Single-Byte Get Character * * * USE * * text oalsbgc ( listp *reader, uword flags, lxglo *glo ); * * DESCRIPTION * * returns ascii value of character, if listp is pointing to an ascii * character. If listp is pointing to a multi-byte equivalent, the * return value also depends upon * * is used to indicate various types of equivalency (see parameters) * * PARAMETERS * * listp *reader - (IN) String handle opened for reading * * uword flags - Bit field, specifying equvalency desired * -- OALS_SM accept "" as equivalent to "A" * -- (if OALS_SM isn't set will return 0 for ) * * lxglo *glo - (IN/OUT) Pointer to NLSRTL global scratch. * * text - 0 if character was not ascii * ascii index of character, if ascii character * * NOTES * * because this function returns '\0' for non-ascii characters, it * cannot be used to check for end-of-string * * instead of calling this with OALS_SM, I suggest calling limtos */ /* the following two function's definition is nowhere to be found neither has it been invoked anywhere. That's why, commenting it out in order to take care of Olint errors. */ #ifdef NEVER uword oalsadv (/*_ listp *reader, uword nchars, lxglo *lig _*/); #endif /* * NAME * * oalsadv - OA Language Support ADVance * * * USE * * uword oalsadv ( listp *reader, uword nchars ); * * DESCRIPTION * * Skips ahead within , if possible. * Returns the number of characters skipped. * * * PARAMETERS * * listp *reader - (IN/OUT) String handle opened for reading * * uword nchars - number of characters to skip * * uword - number of characters actually skipped * * NOTES * */ /*====================================================================== * * NAME * * OALSCPR - CoPy Remaining characters * * USE * * void oalscpr ( listp *writer, listp *readerr, lxglo *glo ); * * listp *reader - (IN/OUT) null-terminated string handle opened for reading * * listp *writer - (IN/OUT) string handle opened for writing * * lxglo *glo - (IN/OUT) LI global scratch memory * * * DESCRIPTION * * the remaining characters of are copied to * * #define oalscpr(w,r,glo) * do { * while (!limnull(r)) * { * DISCARD limcpc(w, r, glo); * } * } while (FALSE) * * * the do {...} while (FALSE) construct is a way of ensuring true * function-like behavior to the macro. *======================================================================*/ /* the following two function's definition is nowhere to be found neither has it been invoked anywhere. That's why, commenting it out in order to take care of Olint errors. */ #ifdef NEVER void OALSCPR( listp *writer, listp*reader, lxglo *glo); #endif #define OALSCPR(writer,reader,glo) do { while (!lxmnull((reader), glo)) { \ DISCARD lxmcpc((writer),(reader),(glo)); } } while (FALSE) #endif /* OALS */