Converting Strings


	BEA Home \| Events \| Solutions \| Partners \| Products \| Services \| Download \| Developer Center \| WebSUPPORT
	http://www.oracle.com/technology/documentation/index.html \| Site Map \| Search \| PDF Files \| Contact \| Glossary

Tuxedo Documentation \| Programming BEA Tuxedo ATMI Applications Using FML \| Local Topics \| Previous Topic \| Next Topic \| Contents

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 ATMI 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 ATMI 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:
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	-

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