Converting Strings


	Corporate Info \| News \| Solutions \| Products \| Partners \| Services \| Events \| Download \| How To Buy
	http://www.oracle.com/technology/documentation/index.html \| Site Map \| Search \| PDF Files \| Contact \| Glossary

Tuxedo Doc Home \| Programming \| Topic List \| Previous \| Next \| Contents

Programming a BEA Tuxedo Application Using FML

Converting Strings

The following set of functions is provided to handle the case of conversion to and from a user type of FLD_STRING:

These functions call their non-string-function counterparts, providing a type of FLD_STRING, and a len of 0. Note that the duration of the validity of the pointer returned by Ffinds is the same as that described for CFfind.

For descriptions of these functions, see the BEA Tuxedo FML Function Reference.

Ftypcvt

The functions CFadd, CFchg, CFget, CFgetalloc, and CFfind use the function Ftypcvt to perform the appropriate data conversion. The Ftypcvt32 function fails for the FLD_PTR, FLD_FML32, and FLD_VIEW32 field types. The synopsis of Ftypcvt usage is as follows (it does not follow the parameter order conventions).

char *
Ftypcvt(FLDLEN *tolen, int totype, char *fromval, int fromtype, FLDLEN fromlen)

Here:

tolen is a pointer to the length of the converted value.
totype is the type to which to convert.
fromval is a pointer to the value from which to convert.
fromtype is the type from which to convert.
fromlen is the length of the from value if the from type is FLD_CARRAY.

Ftypcvt converts from the value *fromval, which has type fromtype, and length fromlen if fromtype is type FLD_CARRAY (otherwise fromlen is inferred from fromtype), to a value of type totype. Ftypcvt returns a pointer to the converted value, and sets *tolen to the converted length, upon success. Upon failure, Ftypcvt returns NULL. Consider the following example, in which the CFchg function is used.

CFchg(fbfr,fieldid,oc,value,len,type)
FBFR *fbfr;             /* fielded buffer */
FLDID fieldid;          /* field to be changed */
FLDOCC oc;              /* occurrence of field to be changed */
char *value;            /* location of new value */
FLDLEN len;             /* length of new value */
int type;               /* type of new value */
{
 char *convloc;         /* location of post-conversion value */
 FLDLEN convlen;        /* length of post-conversion value */
 extern char *Ftypcvt;
 
         /* convert value to fielded buffer type */
  if((convloc = Ftypcvt(&convlen,FLDTYPE(fieldid),value,type,len)) == NULL)
                return(-1);
 
  if(Fchg(fbfr,fieldid,oc,convloc,convlen) < 0)
                return(-1);
  return(1);
}

The user may call Ftypcvt directly to do field value conversion without adding or modifying a fielded buffer.

For more information, refer to Ftypcvt, Ftypcvt32(3fml) in the BEA Tuxedo FML Function Reference.

Conversion Rules

In the following list of conversion rules, oldval represents a pointer to the data item being converted, and newval, a pointer to the post-conversion value.

When both types are identical, *newval is identical to *oldval.
When both types are numeric, that is, if they are long, short, float, or double, the conversion is done by the C assignment operator, with proper type casting. For example, a short is converted to a float through the following code.
```
*((float *)newval) = *((short *) oldval)
```
When a numeric is being converted to a string, an appropriate sprintf is used. For example, a short is converted to a string through the following code.
```
sprintf(newval,"%d",*((short *)oldval))
```
When a string is being converted to a numeric, the appropriate function (for example, atof, atol) is used, with the result assigned to a typecasted receiving location, as shown in the following example.
```
*((float *)newval) = atof(oldval)
```
When a type char is being converted to any numeric type, or when a numeric type is being converted to a char, the char is considered to be a "shorter short." For example, to convert a char to a float, use the method shown in the following code.
```
*((float *)newval) = *((char *)oldval)
```
To convert a short to a char, use the method shown in the next example.
```
*((char *)newval) = *((short *)oldval)
```
A char is converted to a string by appending a NULL character. In this regard, a char is not a "shorter short." If it were, assignment would be done by converting it to a short, and then converting the short to a string via sprintf. In the same sense, a string is converted to a char by assigning the first character of the string to the character.
The carray type is used to store an arbitrary sequence of bytes. In this sense, it can encode any user data type. Nevertheless, the following conversions are specified for carray types:
- A carray is converted to a string by appending the NULL byte to the carray. In this sense, a carray can be used to store a string, less the overhead of the trailing NULL. (This approach does not always save space, since fields are aligned on short boundaries within a fielded buffer.) A string is converted to a carray by removing its terminating NULL byte.
- When a carray is converted to any numeric, it is first converted to a string, and the string is then converted to a numeric. Likewise, a numeric is converted to a carray, by first being converted to a string, and then the string is converted to a carray.
- A carray is converted to a char by assigning the first character of the array to the char. Likewise, a char is converted to a carray by assigning it as the first byte of the array, and setting the length of the array to 1.
  Note that a carray of length 1 and a char have the following differences:
- A char has only the overhead of its associated fieldid, while a carray contains a length code, in addition to the associated fieldid.
- A carray is converted to a numeric by first becoming a string, and then undergoing an atoi call; a char becomes a numeric by typecasting. For example, a char with value ASCII `1' (decimal 49) converts to a short of value 49; a carray of length 1, with the single byte an ASCII `1' converts to a short of value 1. Likewise a char `a' (decimal 97) converts to a short of value 97; the carray `a' converts to a short of value 0 (since atoi ("a") produces a 0 result).
When converting to or from a dec_t type, the associated conversion function as described in decimal(3) is used (_gp_deccvasc, _gp_deccvdbl, _gp_deccvflt, _gp_deccvint, _gp_deccvlong, _gp_dectoasc, _gp_dectodbl, _gp_dectoflt, _gp_dectoint, and _gp_dectolong).

The following table summarizes the conversion rules presented in this section.

Summary of Conversion Rules

src type
dest type

-

char

short

long

float

double

string

carray

dec_t

char

-

cast

cast

cast

cast

st[0]=c

array[0]=c

d

short

cast

-

cast

cast

cast

sprintf

sprintf

d

long

cast

cast

-

cast

cast

sprintf

sprintf

d

float

cast

cast

cast

-

cast

sprintf

sprintf

d

double

cast

cast

cast

cast

-

sprintf

sprintf

d

string

c=st[0]

atoi

atol

atof

atof

-

drop 0

d

carray

c=array[0]

atoi

atol

atof

atof

add 0

-

d

dec_t

d

d

d

d

d

d

d

-

src type	dest type
-	char	short	long	float	double	string	carray	dec_t
char	-	cast	cast	cast	cast	st[0]=c	array[0]=c	d
short	cast	-	cast	cast	cast	sprintf	sprintf	d
long	cast	cast	-	cast	cast	sprintf	sprintf	d
float	cast	cast	cast	-	cast	sprintf	sprintf	d
double	cast	cast	cast	cast	-	sprintf	sprintf	d
string	c=st[0]	atoi	atol	atof	atof	-	drop 0	d
carray	c=array[0]	atoi	atol	atof	atof	add 0	-	d
dec_t	d	d	d	d	d	d	d	-

The following table defines the entries listed in the previous table.

Meanings of Entries in the Summary of Conversion Rules

Entry
Meaning

-

src and dest are the same type; no conversion required

cast

Conversion done using C assignment with type casting

sprintf

Conversion done using sprintf function

atoi

Conversion done using atoi function

atof

Conversion done using atof function

atol

Conversion done using atol function

add 0

Conversion done by concatenating NULL byte

drop 0

Conversion done by dropping terminating NULL byte

c=array[0]

Character set to first byte of array

array[0]=c

First byte of array is set to character

c=st[0]

Character set to first byte of string

st[0]=c

First byte of string set to c

d

decimal(3c) conversion function

Entry	Meaning
-	src and dest are the same type; no conversion required
cast	Conversion done using C assignment with type casting
sprintf	Conversion done using sprintf function
atoi	Conversion done using atoi function
atof	Conversion done using atof function
atol	Conversion done using atol function
add 0	Conversion done by concatenating NULL byte
drop 0	Conversion done by dropping terminating NULL byte
c=array[0]	Character set to first byte of array
array[0]=c	First byte of array is set to character
c=st[0]	Character set to first byte of string
st[0]=c	First byte of string set to c
d	decimal(3c) conversion function