Standard C

assert.h

complex.h

ctype.h

fenv.h

float.h

locale.h

math.h

setjmp.h

signal.h

stdarg.h

stddef.h

stdio.h

stdlib.h

string.h

time.h

Standard C++

IOstream

new

Win32

gc.h

DOS, DOS32, Win16

bios.h

cerror.h

disp.h

dos.h

dos.h part 2

emm.h

handle.h

int.h

msmouse.h

sound.h

swap.h

tsr.h

winio.h

Other C

bitops.h

conio.h

controlc.h

direct.h

fltpnt.h

io.h

page.h

process.h

search.h

sys\stat.h

tabsize.h

trace.h

utime.h

unmangle.h

util.h

Other C++

regexp.h

class complex

Gadgets powered by Google

string.h

memchr, _fmemchr

memcmp, _fmemcmp

_memccpy, _fmemccpy

memcpy, _fmemcpy

_memicmp, _fmemicmp

memmove, _fmemmove

memset, _fmemset, setmem

_movedata

movmem

_strdup, _fstrdup

_stricmp, _fstricmp

_strlwr, _fstrlwr

strncmpi, strncmpl, _strnicmp, _fstrnicmp

_strnset _fstrnset

_strrev, _fstrrev

_strset, _fstrset

_strtime

_strupr, _fstrupr

_swab

stpcpy

strcat, _fstrcat

strchr, _fstrchr

strcmp Functions

strcoll

strcpy, _fstrcpy

strcspn, _fstrcspn

strerror

strlen, _fstrlen

strncat, _fstrncat

strncmp, _fstrncmp

strncmpi, strncmpl, _strnicmp, _fstrnicmp

strncpy, _fstrncpy

strpbrk, _fstrpbrk

strrchr, _fstrrchr

strspn, _fstrspn

strstr, _fstrstr

strtok, _fstrtok

strxfrm

_sys_errlist

_sys_nerr

memchr, _fmemchr

Header string.h

memory.h

Prototype void *memchr(const void *buf1, int c, size_t count);

void __far *__far _fmemchr(const void __far *buf1, int c, size_t

count);

Description

memchr searches in the buffer, buf, for a byte with the value of c. The search continues

for count bytes or until a value of c is encountered. _fmemchr is a model-independent

(large-model) form of the memchr function.

Synonym

Function: fmemchr

Return Value

memchr and _fmemchr return a pointer (or a far pointer) to the first location of c in buf.

Otherwise, these functions return NULL.

Compatibility memchr: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fmemchr: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also memcpy

memcmp

memset

strcmp Functions

strcat

_strset

strrchr

Example /* Example for memchr */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

char test[] = "Test String";

void main ()

{

char search = 'S', *result;

printf (" The test string is \"% s\"\n", test);

printf (" memchr() looking for 'S'\n");

result = memchr(test, search, 12);

if (result != NULL)

printf (" Character 'S' found at (% d)\n",

result -test + 1);

else

printf (" Character 'S' was not found in

search string\n");

}

Output The test string is "Test String"

memchr() looking for 'S'

Character 'S' found at (6)

memcmp, _fmemcmp

Header string.h

memory.h

Prototype int memcmp(const void *buf1, const void *buf2, size_t count); int __far

_fmemcmp(const void __far *buf1, const void __far *buf2, size_t count);

Description memcmp compares each successive byte pointed to by pointer buf1 with the

corresponding byte pointed to by buf2 until they do not have the same value or until the

number of bytes specified in count have been compared. memcmp returns an integer less

than, equal to, or greater than zero, depending on whether the last byte compared in the

buffer pointed to by buf1 is less than, equal to, or greater than the corresponding byte

pointed to by buf2.

_fmemcmp is a model-independent (large-model) form of the memcmp function.

Synonym

Function: fmemcmp

Return Value

Both functions return the following types of values: less than 0 (if buf1 is less than buf2),

0 (if buf1 equals buf2), or greater than 0 (if buf1 is greater than buf2.)

Compatibility memcmp: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

_fmemcmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also

memset

_memicmp

memchr

strcat

strrchr

strcmp Functions

Example /* Example for memcmp */

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char test1[] = "This is test string 1";

char test2[] = "This is test string 2";

void main ()

{

int result;

printf (" Test string 1 is \"% s\"\n", test1);

printf (" Test string 2 is \"% s\"\n", test2);

printf ("\nComparing 1 and 2 for 20 bytes\n");

result = memcmp(test1, test2, 20);

if (! result)

printf (" 1 and 2 are");

else

printf (" 1 and 2 are not");

printf (" the same for 20 bytes\n");

printf ("\nComparing 1 and 2 for 21 bytes\n");

result = memcmp(test1, test2, 21);

if (! result)

printf (" 1 and 2 are");

else

printf (" 1 and 2 are not");

printf (" the same for 21 bytes\n");

}

Output Test string 1 is "This is test string 1"

Test string 2 is "This is test string 2"

Comparing 1 and 2 for 20 bytes

1 and 2 are the same for 20 bytes

Comparing 1 and 2 for 21 bytes

1 and 2 are not the same for 21 bytes

_memccpy, _fmemccpy

Header string.h

memory.h

Prototype void *_memccpy(void *dest, void *src, int c, unsigned int count);

void __far *__far _fmemccpy(void __far *dest, void __far *src, int c,

unsigned int count);

Description

These functions copy a block of memory from src to dest. The copy operation stops when

either the character c has been copied, or count bytes have been copied.

The _fmemccpy function is a model-independent (large-model) form of the _memccpy y

function.

Synonym

Functions: memccpy, fmemccpy

Return Value

If the character c is copied, these functions return a pointer to the byte in dest

immediately following the byte that contains c. If c is not copied, these functions return

NULL.

Compatibility

_memccpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fmemccpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also memchr

memcpy

memset

Example /* Example of _memccpy */

#include <stdio.h>

#include <string.h>

char string[60] = "Now is the time for all good

men";

void main ()

{

char buf[61];

char *dest;

dest = _memccpy (buf, string, 'l', 60);

if (dest != NULL)

*dest = '\0';

printf (" Should have copied to the first

\" l\" or until the end, ");

printf (" which evercame first.

Result is:\n% s\n", buf);

}

Output Should have copied to the first "l" or until the end, which evercame

first. Result is:

Now is the time for al

memcpy, _fmemcpy

Header string.h

memory.h

Prototype void *memcpy(void *buf1, const void *buf2, size_t count);

void __far *__far _fmemcpy(void __far *buf1, const void __far *buf2,

size_t count);

Description

memcpy copies the number of characters specified in count from buf2 to buf1. buf1 is

returned. Although memcpy is faster than memmove, memcpy does not ensure that the

source bytes in the overlapping region are copied before being overwritten. In this

situation, use memmove.

Synonym Function: fmemcpy

Return Value Both functions return buf1.

Compatibility _memcpy: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

_fmemcpy: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

See Also

memcmp

memset

memcmp

memmove

strcmp Functions

strcat

_strset

strrchr

Example /* Example for memcpy */

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char test1[] = "Sample String.";

char test2[15];

void main ()

{

printf (" Copying test1 to test2\n");

memcpy (test2, test1, 15);

printf (" Result is \"% s\"\n", test2);

}

Output Copying test1 to test2

Result is "Sample String."

_memicmp, _fmemicmp

Header

string.h

memory.h

Prototype int _memicmp(const void *buf1, const void *buf2, size_t count);

int __far _fmemicmp(const void __far *buf1, const void __far *buf2,

size_t count);

Description These functions compare the first count characters from buf1 with those in buf2 on a byte

for byte basis, without reference to the case of the letters being compared. Uppercase and

lowercase letters are considered to be equivalent. All uppercase (capital) letters in both

buf1 and buf2 are converted to lowercase before the comparison is done. This function is

identical to memcmp except it ignores case.

Function _fmemicmp is a model-independent (large-model) form of the _memicmp

function.

Synonym

Function: fmemicmp

Return Value

These functions return an integer value which depends on the relationship of buf1 to

buf2, as follows:

Returns a value. . ./if. . .

<0

buf1 less than buf2

=0

buf1 identical to buf2

>0

buf1 greater than buf2

Compatibility _memicmp: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

_fmemicmp: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

See Also

memchr

memcpy

memcmp

memset

Example /* Example of _memicmp */

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char test1[] = "this is test string 1";

char test2[] = "THIS IS TEST STRING 2";

void main ()

{

int result;

printf (" Test string 1 is \"% s\"\n", test1);

printf (" Test string 2 is \"% s\"\n", test2);

printf ("\nComparing 1 and 2 for 20 bytes\n");

result = _memicmp(test1, test2, 20);

if (! result)

printf (" 1 and 2 are");

else

printf (" 1 and 2 are not");

printf (" the same for 20 bytes\n");

printf ("\nComparing 1 and 2 for 21 bytes\n");

result = _memicmp(test1, test2, 21);

if (! result)

printf (" 1 and 2 are");

else

printf (" 1 and 2 are not");

printf (" the same for 21 bytes\n");

}

Output Test string 1 is "this is test string 1"

Test string 2 is "THIS IS TEST STRING 2"

Comparing 1 and 2 for 20 bytes

1 and 2 are the same for 20 bytes

Comparing 1 and 2 for 21 bytes

1 and 2 are not the same for 21 bytes

memmove, _fmemmove

Header string.h

Prototype void *memmove(void *buf1, const void *buf2, size_t count);

void __far *__far _fmemmove(void __far *buf1, const void __far *buf2,

size_t count);

Description memmove copies the number of characters specified in count from buf2 to buf1.

memmove, slower than memcpy, can handle overlapping moves.

_fmemmove is a model-independent (large-model) form memmove.

Synonym

Function: fmemmove

Return Value

buf1 is returned.

Compatibility

memmove: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

_fmemmove: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also memcpy

Example /* Example for memmove */

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char test1[] = "Sample String.";

char test2[15];

void main ()

{

printf (" Copying test1 to test2\n");

memmove (test2, test1, 15);

printf (" Result is \"% s\"\n", test2); }

Output Copying test1 to test2

Result is "Sample String."

memset, _fmemset, setmem

Header string.h

memory.h

Prototype void *memset(void *buf, int val, size_t count);

void __far *__far _fmemset(void __far *buf, int val, size_t count);

void setmem(void *buf, size_t count, int val);

Description

memset sets the first count characters pointed to by buf to the value specified by val. It

returns buf. Function_fmemset is a model-independent (large-model) form memset.

setmem is just a macro for memset, reversing the second and third parameters.

Synonym

Function: fmemset

Return Value

Both functions return buf.

Compatibility

memset: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

_fmemset: DOS, Windows 3. x, Phar Lap/ DOSX, Win32

See Also strcat

_strset

strrchr

strcmp Functions

Example /* Example for memset */

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char buffer[20];

void main ()

{

printf (" buffer before memset: \"% s\"\n", buffer);

memset (buffer, 'x', 6);

printf (" buffer after memset: \"% s\"\n",

buffer);

}

Output buffer before memset:

"" buffer after memset: "xxxxxx"

_movedata

Header

string.h

Prototype void _movedata(unsigned srcseg, unsigned srcoff, unsigned dstseg,

unsigned dstoff, size_t numbytes);

Description

The _movedata function moves numbytes bytes from the source address specified by

segment srcseg and offsets srcoff to the destination address specified by segment dstseg

and offset dstoff.

Use _movedata to move data between segments. For normal intra-segment movement of

data, use memcpy or memmove instead. _movedata does not handle overlapping moves

correctly.

Synonym

Function: movedata

Return Value

None

Compatibility

DOS Windows 3.x Phar Lap DOSX Win32

See Also

_FP Functions

memcpy

memmove

Example /* Example of _movedat */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <dos.h>

void main ()

{

char __far *src = "this is a test";

char __far *dest;

if ((dest = malloc (80)) != NULL)

{

_movedata (_FP_SEG(src), _FP_OFF(src),

_FP_SEG(dest), _FP_OFF(dest),

strlen(src) + 1);

printf (" The source is %p and contains

\"% s\"\n", src, src);

printf (" The destination is %p and contains

\"% s\"\n", dest, dest);

free(dest);

}

}

Output The source is 207B: 0042 and contains "this is a test"

The destination is 307C: 01CA and contains "this is a test"

movmem

Header memory.h

Prototype void movmem(const void *src, void *dest, size_t length);

Description

The movmem function moves a block of data from src to dest. The length argument

indicates the number of bytes to copy. This function moves the data correctly, even if the

blocks overlap.

Return Value

None

Compatibility

DOS Windows 3.x Phar Lap DOSX Win32

See Also

_movedata

Example /* Example for movmem */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <mem.h>

void main ()

{

char *src = "This is a test";

char *dest;

int len;

len = strlen (src) + 1;

dest = malloc (len);

movmem(src, dest, len);

printf(" The source string is \"% s\".\nThe

destination string is \"% s\"\n", src, dest);

}

Output The source string is "This is a test".

The destination string is "This is a test"

_strdup, _fstrdup

Header string.h

Prototype char *_strdup(const char *string);

char __far *__far _fstrdup(

const char __far *string);

Description The _strdup and _fstrdup functions allocate memory with a call to malloc, copy the string

into this memory, and return a pointer to the memory containing the string. The functions

return NULL if memory cannot be allocated.

The _fstrdup function provides additional control over the heap used for string

duplication. The function returns a far pointer to a copy of the string allocated from the

far heap.

Synonym Functions: strdup, fstrdup

Return Value All functions return a pointer to the allocated memory containing the string. NULL is

returned if memory cannot be allocated.

Compatibility

strdup: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrdup: DOS Windows 3.x Phar Lap/ DOSX Win32

Example /* Example of _strdup */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main ()

{

char *str1 = "This is a test string";

char *str2;

printf ("The original string: \"% s\"\n", str1);

str2 = _strdup (str1);

printf ("The string from _strdup(): \"% s\"\n", str2);

}

Output The original string: "This is a test string"

The string from _strdup(): "This is a test string"

_stricmp, _fstricmp

Header string.h

Prototype int _stricmp(const char *string1, const char *string2);

int __far _fstricmp(const char __far *string1, const char __far

*string2);

Description The _stricmp function compares the lowercase versions of the strings specified in string1

and string 2. The comparison begins with the first character of each string and continues

until corresponding characters differ or until the ends of the strings are reached.

The _fstricmp function is a model-independent (large model) form of _stricmp. The

functions are identical, except that the _fstricmp arguments are far pointers.

Synonym

Function: stricmp, fstricmp

Return Value

Returns... if...

< 0 string1 is less than string2

= 0 string1 is equal to string2

> 0 string1 is greater than string2

Compatibility

stricmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstricmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also strcat

strcpy

strncat

strncmp

strncpy

strncmpi

strncmpl

_strnicmp

Example See strcmp

_strlwr, _fstrlwr

Header string.h

Prototype char *_strlwr(char *string);

char __far *__far _fstrlwr(char __far *string);

Description The _strlwr function converts upper case characters in the string argument to lower case.

The _fstrlwr function is a model-independent (large model) form of _strlwr. They are

identical, except that the _fstrlwr argument and return values are far pointers.

Synonym Function: strlwr, fstrlwr

Return Value Return a pointer to the converted string.

Compatibility strlwr: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrlwr: DOS Windows 3.x Phar Lap/ DOSX Win32

Example /* Example of _strlwr */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "Mixed Case String";

printf (" The original string: \"% s\"\n", str);

_strlwr (str);

printf (" The string after _strlwr:

\"% s\"\n", str);

}

Output The original string: "Mixed Case String"

The string after _strlwr: "mixed case string"

strncmpi, strncmpl, _strnicmp, _fstrnicmp

Header string.h

Prototype int strncmpi(const char *str1, const char *str2, size_t n);

int strncmpl(char *str1, char *str2, int n);

int _strnicmp(const char *str1, const char *str2, size_t n);

int __far _fstrnicmp(const char __far *str1, const char __far *str2,

size_t n);

Description These functions are case-insensitive versions of strncmp. The first n characters of each

string are compared. If either is less than n characters long, the comparison terminates;

the return value is the result of the comparison up until the termination. The returned

value is zero for a successful match; a positive or negative number represents the

difference in the mismatched characters.

The _fstrnicmp function is a model-independent (large model) form of _strnicmp. They

are identical, except that the _fstrnicmp arguments and return values are far.

Synonym Function: strnicmp

Return Value

Returns... /if...

< 0

string1 is less than string2

= 0

string1 is equal to string2

> 0

string1 is greater than string2

Compatibility _strn*/ strn*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstrnicmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also

strncmp

strcmp Functions

_strnset _fstrnset

Header string.h

Prototype char *_strnset(char *string, int ch, size_t n);

char __far *__far _fstrnset(char __far *string, int ch, size_t n);

Description These functions set, at most, n characters of string to ch (converted to char) and return a

pointer to the altered string. If n is greater than the length of string, the length of string is

used in place of n. The _fstrnset function is a model-independent (large model) form of

_strnset. They are identical, except that the _fstrnset arguments and return values are far.

Synonym

Functions: strnset, fstrnset

Return Value

These functions return a pointer to a string.

Compatibility

_strnset: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrnset: DOS Windows 3.x Phar Lap/ DOSX Win32

See Also _strset

Example /* Example for _strnset */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main ()

{

char *str = "_strnset Example string";

printf (" This is the string: \"% s\"\n", str);

printf (" After _strnset(str, 'x', 10):

\"% s\"\n", _strnset(str, 'x', 10));

printf (" After _strnset(str, 'x', 100):

\"% s\"\n", _strnset(str, 'x', 100));

}

Output This is the string: "_strnset Example string"

After _strnset(str, 'x', 10)

: "xxxxxxxxxxxample

string"

After _strnset(str, 'x', 100):

"xxxxxxxxxxxxxxxxxxxxxxx"

_strrev, _fstrrev

Header

string.h

Prototype char *_strrev(char *string);

char __far *__far _fstrrev(char __far* string);

Description

These functions reverse the order of characters in string, leaving a terminating '\0' at the

end.

The _fstrrev function is a model-independent (large model) form of strrev. These

functions are identical, except that the _fstrrev argument and return value are far pointers.

Synonym

Function: strrev, fstrrev

Return Value

Both functions return a pointer to the altered string.

Compatibility

_strrev: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrrev: DOS Windows 3.x Phar

Lap/ DOSX Win32

Example /* Example for _strrev */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main()

{

char str[80];

printf (" Enter a string: ");

gets(str);

printf ("\nThe results of _strrev are:\n

\"% s\"\n", _strrev(str));

}

Output Enter a string: So much time, so little to do

The results of _strrev are:

"od ot elttil os ,emit hcum oS"

_strset, _fstrset

Header string.h

Prototype char *_strset(char *string, int ch);

char __far *__far _fstrset(char __far *string, int ch);

Description These functions set all the characters in string to ch except the terminating null character.

The _fstrset function is a model-independent (large model) form of _strset. These

functions are identical, except that the _fstrset pointer arguments and return value are far

pointers.

Synonym Function: strset, fstrset

Return Value These functions return a pointer to the altered string.

Compatibility _strset: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrset: DOS Windows 3.x Phar

Lap/ DOSX Win32

Example /*

Example for _strset

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main ()

{

char *str = "_strset Example string";

printf (" This is the string: \"% s\"\n", str);

printf (" After _strset(str, 'x'): \"% s\"\n",

_strset(str, 'x'));

}

Output This is the string: "_strset Example string"

After _strset(str, 'x'): "xxxxxxxxxxxxxxxxxxxxxx"

_strtime

Header time.h

Prototype char *_strtime(char *timestr);

Description

The _strtime function copies the current time to the buffer pointed to by the timestr

argument.

The time string has the following format:

hh: mm: ss

where hh represents the hour in 24-hour notation, mm represents the minutes past the

hour, and ss represents the seconds.

The buffer must be at least 9 bytes long.

Return Value A pointer to the text string.

Compatibility DOS Windows 3.x Phar Lap DOSX Win32

See Also asctime

ctime

localtime

Example See _strdate

_strupr, _fstrupr

Header

string.h

Prototype char *_strupr(char *string);

char __far *__far _fstrupr(char *string);

Description

These functions convert lowercase characters in string to uppercase.

The _fstrupr function is a model-independent (large model) form of _strupr. They are

identical, except that the _fstrupr argument and the return value are far pointers.

Synonym Functions: strupr, fstrupr

Return Value Returns string.

Compatibility strupr: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrupr: DOS Windows 3.x Phar

Lap/ DOSX Win32

See Also

_strlwr

_tolower

_toupper

Example /* Example of _strupr */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "Mixed Case String";

printf (" The original string: \"% s\"\n", str);

_strupr (str);

printf (" The string after _strupr:

\"% s\"\n", str);

}

Output The original string: "Mixed Case String"

The string after _strupr: "MIXED CASE STRING"

_swab

Header stdlib.h

Prototype void _swab(char *source, char *destination, int n);

Description

The _swab function copies n bytes from source, swapping each pair of adjacent bytes.

destination stores the converted string. The integer n should be even as pairs of characters

are swapped.

Synonym

Function: swab

Return Value

None

Compatibility

DOS Windows 3.x Phar Lap DOSX Win32

Example /* Example for _swab */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main()

{

char str[80];

char dst[80];

int len;

printf (" Enter a string: ");

gets (str);

strcpy (dst, str);

len = (strlen (str));

len -= len % 2;

_swab (str, dst, len);

printf ("\nThe results of _swab are:\n

\"% s\"\n", dst);

}

Output Enter a string: It's a Push-me-pull-you

The results of _swab are:

"tIs'a P su-hemp-lu-loyu"

stpcpy

Header

string.h

Prototype char *stpcpy(char *s1, const char *s2);

Description The stpcpy function copies the string pointed to by s2 into the buffer pointed to by s1. It

is similar to the normal library strcpy function except that it returns a pointer to the end of

the copied string. This is useful when concatenating strings.

Return Value A pointer to the end of the copied string.

Compatibility DOS Windows 3.x Phar Lap DOSX Win32

See Also strcpy

Example /* Example for stpcpy */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main ()

{

char s1[8], *s2 = "Eu", *s3 = "re",

*s4 = "ka";

stpcpy (stpcpy (stpcpy (stpcpy (s1, s2),

s3), s4), "!");

printf ("This is the string from stpcpy

\"% s\"\n", s1);

}

Output This is the string from stpcopy "Eureka!"

strcat, _fstrcat

Header

string.h

Prototype char *strcat(char *string1, const char *string2);

char __far *__far _fstrcat(char __far *string1, const char __far

*string2);

Description The strcat function appends a copy of string2 onto the end of string1 and terminates the

resulting string with a null character. The application code is responsible for ensuring that

there is enough space in the string to hold the result.

The _fstrcat function is a model-independent (large model) form of strcat. These

functions are identical, except that the _fstrcat arguments and return values are far

pointers.

Synonym Function: fstrcat

Return Value Both functions return a pointer to string1.

Compatibility strcat: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrcat: DOS Windows 3.x Phar Lap/

DOSX Win32

Example /* Example of strcat */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char str1[50] = "This is string 1...";

char str2[50] = "And this is string 2.";

printf (" String 1: \"% s\"\nString 2:

\"% s\"\n", str1, str2);

printf (" Result of strcat: \"% s\"\n",

strcat(str1, str2));

}

Output String 1: "This is string 1..."

String 2: "And this is string 2."

Result of strcat: "This is string 1... And this is string 2."

strchr, _fstrchr

Header string.h

Prototype char *strchr(const char *string, int ch);

char __far *__far _fstrchr(const char __far *string, int ch);

Description The strchr function finds the first occurrence of the character ch in string and returns a

pointer to this character. strchr is identical to the function index (which is no longer in

this library).

The _fstrchr function is a model-independent (large model) form of strchr. These

functions are identical, except that the _fstrchr arguments and return values are far.

Synonym Function: fstrchr

Return Value Pointer to character ch. A NULL pointer is returned if not found.

Compatibility strchr: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrch: DOS Windows 3.x Phar Lap/ DOSX Win32

See Also memchr

Example /* Example of strchr */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "string example";

char *res;

printf (" Looking for 'x' in

string \"% s\"\n", str);

res = strchr(str, 'x');

if (! res)

printf (" 'x' was not found in

the search string\n");

else

printf (" 'x' was found in the search

string at offset %d\n", res -str);

}

Output Looking for 'x' in string "string example"

'x' was found in the search string at offset 8

strcmp Functions

Header

string.h

Prototype int strcmp(const char *string1, const char *string2);

int __far _fstrcmp(const char __far *string1, const char __far

*string2);

int _strcmpi(const char *string1, const char *string2);

int strcmpl(const char *string1, const char *string2);

int __far _fstrcmpl(const char __far *string1, const char __far

*string2);

Description

strcmp, _strcmpi, and strcmpl compare two strings, character by character. strcmp is case

sensitive whereas strcmpi and strcmpl are not.

The _fstrcmp and _fstrcmpl functions are model-independent (large model) form of

strcmp and strcmpl. These functions are identical, except that the _fstrcmp and _fstrcmpl

arguments are far pointers.

Synonym

Functions: fstrcmp, strcmpi

Return Value

Return.../if ... <0

stiring1 is less than string2

=0

string1 is equal to string2

>0

string1 greater than string2

Compatibility strcmp*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstrcmp*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also

memcmp

Example /* Example of strcmp

Also demonstrates _stricmp

*/

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char test1[] = "this is a test string";

char test2[] = "THIS IS A TEST STRING";

void main ()

{

int result;

printf (" Test string 1 is \"% s\"\n", test1);

printf (" Test string 2 is \"% s\"\n", test2);

printf ("\nComparing 1 and 2 using strcmp\n");

result = strcmp(test1, test2);

if (! result)

printf (" string 1 is equal to string 2\n");

else if (result < 0)

printf (" string 1 is less than

string 2\n");

else

printf (" string 1 is greater than

string 2\n");

printf ("\nComparing 1 and 2 using

_stricmp\n");

result = _stricmp(test1, test2);

if (! result)

printf (" string 1 is equal to string 2\n");

else if (result < 0)

printf (" string 1 is less than string 2\n");

else

printf (" string 1 is greater than

string 2\n");

}

Output Test string 1 is "this is a test string"

Test string 2 is "THIS IS A TEST STRING"

Comparing 1 and 2 using strcmp

string 1 is greater than string 2

Comparing 1 and 2 using _stricmp

string 1 is equal to string 2

strcoll

Header string.h

Prototype

int strcoll(const char *string1, const char *string2);

Description

The strcoll function compares the two strings specified in the string1 and string2

arguments, using the collating sequence specified by the setlocale function. Then, the

function returns a value indicating the relationship between the strings.

Return Value

The following values are returned:

Returns.../if ...

<0

string1 is less than string2

0

string1 is equal to string2

>0

string1 is greater than string2

Compatibility DOS Windows 3.x Phar Lap DOSX Win32

See Also setlocale

strcmp Functions

strcpy, _fstrcpy

Header string.h

Prototype char *strcpy(char *string1, const char *string2);

char __far *__far _fstrcpy(char __far *string1, const __far char

*string2);

Description strcpy copies string2, including the terminating null character, into the object pointed to

by string1. The _fstrcpy function is a model-independent (large model) form of strcpy.

Synonym

Function: fstrcpy

Return Value

Returns the new string pointed to by string1.

Compatibility

strcpy: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrcpy: DOS Windows 3.x Phar Lap/ DOSX Win32

See Also stpcpy

Example /* Example of strcpy */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char str1[50] = "This is the first string";

char str2[50] = "This is the second string";

printf (" str1 = \"% s\"\n", str1);

printf (" str2 = \"% s\"\n", str2);

strcpy (str1, str2);

printf ("\nAfter strcpy(str1, str2)...\n\n");

printf (" str1 = \"% s\"\n", str1);

printf (" str2 = \"% s\"\n", str2);

{

Output str1 = "This is the first string"

str2 = "This is the second string"

After strcpy(str1, str2)...

str1 = "This is the second string"

str2 = "This is the second string"

strcspn, _fstrcspn

Header string.h

Prototype size_t strcspn(const char *string1, const char string2);

size_t __far _fstrscpn(const char __far *string1, const char __far

*string2);

Description strcspn searches string1 for the first occurrence of a character belonging to the set of

characters in string2 and returns the index of this character. This value is equivalent to the

length of the initial substring of string1 consisting entirely of charcters not in string2.

The _fstrcspn function is a model-independent (large model) form of strcspn. These

functions are identical, except that the _fstrcspn arguments and return values are far.

Synonym Function: fstrcspn

Return Value Both functions return the length of the initial segment of string1 that consists of

characters not found in string2. If string1 begins with a character from string2, strcspn

returns 0. If no character in string2 appears in string1, then the total length of string1, not

counting the null character terminator, is returned.

Compatibility

strcspn: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstrcspn: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

Example /* Example of strcspn */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "The quick brown fox jumped

over the lazy dog";

char srch[80];

unsigned res;

printf (" The search string is:

\n \"% s\"\n\n", str);

printf (" Enter the set of characters

for strcspn(): ");

gets (srch);

res = strcspn (str, srch);

if (res == strlen (str))

printf ("\nSorry but none of those

characters where found.\n");

else

printf ("\nMatching character found

at offset %d\n", res);

}

Output The search string is:

"The quick brown fox jumped over the lazy dog"

Enter the set of characters for strcspn(): qzy

Matching character found at offset 4

strerror

Header string.h

Prototype char *strerror(int errornum);

Description The strerror function gets a system error message asociated with an error number. It maps

errornum to an error message string and returns a pointer to that string.

strerror does not print the error message. To print the message returned to stderr, use a

print statement such as fprintf:

if ((_access("datafile", 2 )) == -1)

fprintf(stderr, _strerror(NULL));

Return Value

Returns a pointer to the error message string.

Compatibility

DOS Windows 3.x Phar Lap DOSX Win32

See Also

_strerror

clearerr

ferror

perror

Example /* Example of strerror */

#include <stdlib.h>

#include <stdio.h>

#include <io.h>

#include <string.h>

#include <fcntl.h>

void main ()

{

int f;

if ((f = _open (" nofile. xxx", _O_RDONLY)) < 0)

printf (" Error opening file

\" nofile. xxx\": %s\n", strerror (errno));

else

{

printf (" The file is open");

_close (f);

}

}

Output Error opening file "nofile. xxx": No such file or directory

strlen, _fstrlen

Header

string.h

Prototype size_t strlen(const char *string);

size_t __far _fstrlen(const char __far *string);

Description The strlen function returns the length of the string in the string argument, excluding the

terminating '\0'.

The _fstrlen function is a model-independent (large model) form of strlen. These

functions are identical, except that the _fstrlen argument is a far pointer.

Synonym

Function: fstrlen

Return Value

Both functions return the length of the string.

Compatibility

strlen: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrlen: DOS Windows 3.x Phar

Lap/ DOSX Win32

Example /* Example of strlen */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char str[80];

printf (" Enter a string: ");

gets (str);

printf (" There are %d characters in the

string \"% s\"\n", strlen (str), str);

}

Output Enter a string: The quick brown fox...

There are 22 characters in the string "The quick

brown fox..."

strncat, _fstrncat

Header string.h

Prototype char *strncat(char *string1, const char *string2, size_t n);

char __far *__far _fstrncat(char __far *string1, const char __far

*string2, size_t n);

Description This function appends the lesser of n or strlen(string2) characters of string2 onto the end

of string1 and adds a terminating NULL character. It is the user's responsibility to ensure

there is enough space in string1 to hold the result.

The _fstrncat function is a model-independent (large model) form of strncat. These

functions are identical, except that the _fstrncat pointer arguments and return values are

far pointers.

Synonym Function: fstrncat

Return Value Both functions return a pointer to the concatenated string.

Compatibility strncat: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrncat: DOS Windows 3.x Phar Lap/ DOSX Win32

See Also

strcat

Example /* Example of strncat */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char str1[25] = "This is string 1...";

char str2[25] = "And this is string 2.";

int len;

len = 25 -strlen (str1);

printf (" String 1: \"% s\"\nString 2:

\"% s\"\n", str1, str2);

printf (" Result of strncat(str1, str2, %d):

\"% s\"\n", len, strncat(str1, str2, len));

}

Output String 1: "This is string 1..."

String 2: "And this is string 2."

Result of strncat(str1, str2, 6): "This is

string 1... And th"

strncmp, _fstrncmp

Header string.h

Prototype int strncmp(const char *string1, const char *string2, size_t n);

int __far _fstrncmp(const char __far *string1, const char __far

*string2, size_t n);

Description Compares n characters of string2 to string1. The comparison stops after n characters or

the end of string1. The _fstrncmp function is a model-independent (large model) form of

strncmp. These functions are identical, except that the _fstrncmp arguments and return

values are far.

Synonym

Function: fstrncmp

Return Value

Return... /if... < 0

string1 is less than string2

= 0

string1 is equal to string2

> 0

string1 is greater than string2

Compatibility

strncmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstrncmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also strcmp Functions

Example /* Example of strncmp

Also demonstrates _strnicmp

*/

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char test1[] = "this is a test string XXXXX";

char test2[] = "THIS IS A TEST STRING zzzzz";

void main ()

{

int result;

printf (" Test string 1 is \"% s\"\n", test1);

printf (" Test string 2 is \"% s\"\n", test2);

printf ("\nComparing 1 and 2 using

strncmp(str1, str2, 21)\n");

result = strncmp (test1, test2, 21);

if (! result)

printf (" string 1 is equal to string 2\n");

else if (result < 0)

printf (" string 1 is less than string 2\n");

else

printf (" string 1 is greater than string

2\n");

printf ("\nComparing 1 and 2 using

_strnicmp(str1, str2, 21)\n");

result = _strnicmp (test1, test2, 21);

if (! result)

printf (" string 1 is equal to string 2\n");

else if (result < 0)

printf (" string 1 is less than string

2\n");

else

printf (" string 1 is greater than string

2\n");

printf ("\nComparing 1 and 2 using _strnicmp(str1, str2, 100)\n");

result = _strnicmp (test1, test2, 100);

if (! result)

printf (" string 1 is equal to string 2\n");

else if (result < 0)

printf (" string 1 is less than string 2\n");

else

printf (" string 1 is greater than string 2\n");

}

Output Test string 1 is "this is a test string XXXXX"

Test string 2 is "THIS IS A TEST STRING zzzzz"

Comparing 1 and 2 using strncmp(str1, str2, 21)

string 1 is greater than string 2

Comparing 1 and 2 using _strnicmp(str1, str2, 21)

string 1 is equal to string 2

Comparing 1 and 2 using _strnicmp(str1, str2, 100)

string 1 is less than string 2

strncmpi, strncmpl, _strnicmp, _fstrnicmp

Header string.h

Prototype int strncmpi(const char *str1, const char *str2, size_t n);

int strncmpl(char *str1, char *str2, int n);

int _strnicmp(const char *str1, const char *str2, size_t n);

int __far _fstrnicmp(const char __far *str1, const char __far *str2,

size_t n);

Description

These functions are case-insensitive versions of strncmp. The first n characters of each

string are compared. If either is less than n characters long, the comparison terminates;

the return value is the result of the comparison up until the termination. The returned

value is zero for a successful match; a positive or negative number represents the

difference in the mismatched characters.

The _fstrnicmp function is a model-independent (large model) form of _strnicmp. They

are identical, except that the _fstrnicmp arguments and return values are far.

Synonym Function: strnicmp

Return Value

Returns... /if...

< 0

string1 is less than string2

= 0

string1 is equal to string2

> 0

string1 is greater than string2

Compatibility _strn*/ strn*: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstrnicmp: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also

strncmp

strcmp Functions

strncpy, _fstrncpy

Header string.h

Prototype char *strncpy(char *string1, const char *string2, size_t n);

char __far *__far _fstrncpy(char __far *string1, const char __far

*string2, size_t n);

Description The strncpy function copies the first n characters of string2 into string1. If string2 is

longer than string1 or longer than n, the result will not be null terminated. If string2 is

less than n characters, string1 will be padded to n with null characters.

The _fstrncpy function is a model-independent (large model) form of strncpy. These

functions are identical, except that the _fstrncpy arguments and return values are far.

Synonym

Function: fstrncpy

Return Value

Returns string1.

Compatibility

strncpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstrncpy: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

See Also strcpy

stpcpy

Example /* Example of strncpy */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char str1[50] = "This is the first string";

char str2[50] = "The second string is this";

printf (" str1 = \"% s\"\n", str1);

printf (" str2 = \"% s\"\n", str2);

strncpy (str1, str2, 10);

printf ("\nAfter strncpy(str1, str2,

10)...\n\n");

printf (" str1 = \"% s\"\n", str1);

printf (" str2 = \"% s\"\n", str2);

}

Output str1 = "This is the first string"

str2 = "The second string is this"

After strncpy(str1, str2, 10)...

str1 = "The seconde first string"

str2 = "The second string is this"

strpbrk, _fstrpbrk

Header string.h

Prototype char *strpbrk(const char *string1, const char *string2);

char __far *__far _fstrpbrk(const char __far *string1, const char __far

*string2);

Description The strpbrk function finds the first occurrence in string1 of any character from string2.

The terminating null character is not included in the search.

The _fstrpbrk function is a model-independent (large model) form of strpbrk. These

functions are identical, except that the _fstrpbrk arguments and return values are far.

Synonym

Function: fstrpbrk

Return Value

Returns a pointer to the first occurrence in string1 of any character from string2, or

NULL if no character from string2 exists in string1.

Compatibility strpbrk: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

_fstrpbrk: DOS, Windows 3.x, Phar Lap/ DOSX, Win32

Example /* Example of strpbrk */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "The quick brown fox jumped

over the lazy dog";

char srch[80];

char *res;

printf (" The search string is:\n

\"% s\"\n\n", str);

printf (" Enter the set of characters

for strpbrk(): ");

gets (srch);

res = strpbrk (str, srch);

if (res == NULL)

printf ("\nSorry but none of those

characters where found.\n");

else

{

printf ("\nMatching character found at

offset %d\n", res -str);

printf (" The result points to

\"% s\"\n", res);

}

}

Output The search sting is:

"The quick brown fox jumped over the lazy dog"

Enter the set of characters for strpbrk(): qrt

Matching character found at offset 4

The result points to "quick brown fox jumped

over the lazy dog"

strrchr, _fstrrchr

Header string.h

Prototype char *strrchr(const char *string, int ch);

char __far *__far _fstrrchr(const char __far *string, int ch);

Description The strrchr function finds the last occurrence of character ch (converted to char) in string.

The string's terminating null character is included in the search.

The _fstrrchr function is a model-independent (large model) form of strrchr. These

functions are identical, except that the _fstrrchr arguments and return values are far

pointers.

Synonym Function: fstrrchr

Return Value Both functions return a pointer to the last occurrence of ch in string. They return a NULL

pointer if ch is not found.

Compatibility strrchr: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrrchr: DOS Windows 3.x Phar Lap/ DOSX Win32

Example /* Example of strrchr */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "Peter piper picked a peck of

pickled peppers";

char *res;

printf (" Using strrchr to look for 'p' in string:\n \"% s\"\n\n",

str);

res = strrchr(str, 'p'); if (! res)

printf (" 'p' was not found in the search string\n");

else

printf (" The last occurance of 'p' was found in the search

string at "

"offset %d\n", res -str);

}

Output Using strrchr to look for 'p' in string:

"Peter piper picked a peck of pickled peppers"

The last occurance of 'p' was found in the

search string at offset 40

strspn, _fstrspn

Header string.h

Prototype size_t strspn(const char *string1, const char *string2);

size_t __far _fstrspn(const char __far *string1, const char __far

*string2);

Description The strspn function returns the length of the initial segment of string1 which consists

entirely of characters found in string2. The null character terminating string2 is not

considered in the matching process. If string1 begins with a character not in string2,

strspn returns 0.

The _fstrspn function is a model-independent (large model) form of strspn. These

functions are identical, except that the _fstrspn arguments are far pointers.

Synonym Function: fstrspn

Return Value Both functions return the length of the initial segment of string1 which consists entirely

of characters found in string2.

Compatibility

strspn: DOS Windows 3.x Phar Lap/ DOSX Win32 _fstrspn: DOS Windows 3.x Phar

Lap/ DOSX Win32

Example /* Example of strspn */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "The quick brown fox jumped

over the lazy dog";

char srch[80];

unsigned res;

printf (" The search string is:\n

\"% s\"\n\n", str);

printf (" Enter the set of characters

for strspn(): ");

gets (srch);

res = strspn (str, srch);

if (res == 0)

printf ("\nSorry, but not all of those

characters where found.\n");

else

printf ("\nCharacters match until offset

%d\n", res);

}

Output The search string is:

"The quick brown fox jumped over the lazy dog"

Enter the set of characters for strspn(): ehT

kciqu z

Characters match until offset 10

strstr, _fstrstr

Header

string.h

Prototype char *strstr(const char *string1, const char *string2);

char __far *__far _fstrstr(const char __far *string1, const char __far

*string2);

Description

The strstr function returns a pointer to the first occurrence of string2 within string1.

The _fstrstr function is a model-independent (large model) form of strstr. These functions

are identical, except that the _fstrstr arguments and return value are far pointers.

Synonym Function: fstrstr

Return Value These functions return a pointer to the first occurence of string2 within string1, or they

return NULL if no occurrence was found. If string2 is of 0 length, the functions return

string1.

Compatibility strstr: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrstr: DOS Windows 3.x Phar Lap/ DOSX Win32

Example /* Example of strstr */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

void main ()

{

char *str = "The quick brown fox jumped

over the lazy dog";

char srch[80];

char *res;

printf ("The source string is:\n

\"% s\"\n\n", str);

printf ("Enter the search string for

strstr(): ");

gets (srch);

res = strstr (str, srch);

if (res == NULL)

printf ("\nSorry, that string was not

found.\n");

else

{

printf ("\nMatching string found at offset

%d\n", res -str);

printf (" Result points to the string:

\n \"% s\"\n", res);

}

}

Output The source string is:

"The quick brown fox jumped over the lazy dog"

Enter the search string for strstr(): lazy

Matching string found at offset 36

Result points to the string:

"lazy dog"

strtok, _fstrtok

Header string.h

Prototype char * strtok(char * string1, const char * string2);

char __far *__far _fstrtok(char __far *string1, const char __far

*string2);

Description

strtok parses string1 into tokens delimited by characters in string2. It returns a pointer to

the first character in string1, which is not one of the delimiting characters, and writes a

'\0' at the position of the next delimiter. Because an internal record is stored of the current

position within the string, a subsequent strtok call with a NULL value for string1

continues parsing from the position reached in the previous call. string2 may change

between calls.

The _fstrtok function is a model-independent (large model) form of strtok. These

functions are identical, except that the _fstrtok arguments and return value are far

pointers.

Synonym Function: fstrtok

Return Value The first time these functions are called, they return a pointer to the first token in string1.

In later calls with the same token string, a pointer to the next token is returned. When

there are no more tokens, a NULL pointer is returned.

Compatibility strtok: DOS Windows 3.x Phar Lap/ DOSX Win32

_fstrtok: DOS Windows 3.x Phar Lap/ DOSX Win32

Example /* Example for strtok */

#include <stdio.hgt

#include <stdlib.h>

#include <string.h>

#define delim "\n\r\t\v "

char * gettoken (FILE *fp)

{

static char linebuf[128];

static char *res = NULL;

do

{

if (res == NULL)

{

fgets (linebuf, 128, fp);

res = strtok (linebuf, delim);

}

else

res = strtok (NULL, delim);

} while (! feof (fp) && !res);

return res;

}

void main ()

{

char fname[_MAX_PATH];

char *token;

FILE *fp;

printf (" Enter filename: ");

gets (fname);

if ((fp = fopen (fname, "r")) == NULL)

{

perror (" Unable to open file");

exit (EXIT_FAILURE);

}

do

{

token = gettoken (fp);

printf ("% s\n", token);

} while (! feof(fp));

}

Output Enter filename: strtok. c

/*

Example

for

strtok

*/

#include

<stdio.h>

#include

<stdlib.h>

.

.

.

=

gettoken

(fp);

printf

("% s\n",

token);

}

while

(! feof(fp));

}

strxfrm

Header

string.h

Prototype size_t strxfrm(char *string1, const char *string2, size_t count);

Description

The strxfrm function transforms string2 to a differently collated form and stores it in

string1. The count argument is the maximum number of characters placed in string1. The

transformation uses the collating sequence for the locale, as set by the setlocale function.

The size of the array needed to hold the transformation of the source string can be

expressed as:

1 + strxfrm(NULL, string, 0)

Return Value The length of the transformed string, not counting the terminating null character. The

contents of string1 are unpredictable if the return value is greater than or equal to count.

Compatibility

DOS Windows 3.x Phar Lap DOSX Win32

See Also

localeconv

setlocale

strcmp Functions

strcoll

_sys_errlist

Header string.h

Prototype extern char *_sys_errlist[];

Description This variable is an array of error messages indexed by errno values. Error messages

printed by perror and returned by strerror and _strerror are retrieved from this array. It is

better to use those functions rather than access the array directly because the functions

handle out-of-range errno values correctly.

Synonym

Variable: sys-errlist

Compatibility

DOS Windows 3.x Phar Lap DOSX Win32

See Also

errno

_sys_nerr

perror

strerror

_sys_nerr

Header

string.h

Prototype extern int _sys_nerr;

Description

This variable tells how many elements the _sys_errlist variable contains.

Synonym

Variable: sys_nerr

Compatibility

DOS Windows 3.x Phar Lap DOSX Win32

See Also

errno

_sys_errlist

Home | Compiler & Tools | IDDE Reference | STL | Search | Download | Forums

Copyright © 1999-2010 by Digital Mars ®, All Rights Reserved | Page generated by Ddoc.