United States    
COMPAQ
Compaq C

Compaq C
Run-Time Library Reference Manual for OpenVMS Systems


Previous Contents Index


iswctype

Indicates if a wide character has a specified property.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswctype (wint_t wc, wctype_t wc_prop);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a valid wide-character code in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

wc_prop

A valid property name in the current locale. This is set up by calling the wctype function.

Description

This function tests whether wc has the character-class property wc_prop. Set wc_prop by calling the wctype function.

See also wctype in this section.


Return Values

nonzero If the character has the property wc_prop.
0 If the character does not have the property wc_prop.

Example


#include <locale.h> 
#include <wchar.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h>                                        
#include <ctype.h> 
 
/* This test will set up the "upper" character class using      */ 
/* wctype() and then verify whether the characters 'a' and 'A'  */ 
/* are members of this class                                    */ 
 
#include <stdlib.h> 
 
main() 
{ 
 
    wchar_t w_char1, 
            w_char2; 
    wctype_t ret_val; 
 
    char *char1 = "a"; 
    char *char2 = "A"; 
 
    ret_val = wctype("upper"); 
 
    /* Convert char1 to wide-character format - w_char1 */ 
 
    if (mbtowc(&w_char1, char1, 1) == -1) { 
       perror("mbtowc"); 
        exit(EXIT_FAILURE); 
    } 
 
    if (iswctype((wint_t) w_char1, ret_val)) 
        printf("[%C] is a member of the character class upper\n", 
                w_char1); 
    else 
        printf("[%C] is not a member of the character class upper\n", 
                w_char1); 
 
    /* Convert char2 to wide-character format - w_char2 */ 
 
    if (mbtowc(&w_char2, char2, 1) == -1) { 
        perror("mbtowc"); 
        exit(EXIT_FAILURE); 
    } 
 
    if (iswctype((wint_t) w_char2, ret_val)) 
        printf("[%C] is a member of the character class upper\n", 
                w_char2); 
    else 
        printf("[%C] is not a member of the character class upper\n", 
                w_char2); 
} 

Running the example program produces the following result:


[a] is not a member of the character class upper 
[A] is a member of the character class upper 


iswdigit

Indicates if a wide character is classed as a digit in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswdigit (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a decimal digit.
0 If not a decimal digit.

iswgraph

Indicates if a wide character is classed as a graphic character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswgraph (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a graphic character.
0 If not a graphic character.

iswlower

Indicates if a wide character is classed as a lowercase character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswlower (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a lowercase character.
0 If not a lowercase character.

iswprint

Indicates if a wide character is classed as a printing character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswprint (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a printing character.
0 If not a printing character.

iswpunct

Indicates if a wide character is classed as a punctuation character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswpunct (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a punctuation character.
0 If not a punctuation character.

iswspace

Indicates if a wide character is classed as a space character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswspace (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a whitespace character.
0 If not a whitespace character.

iswupper

Indicates if a wide character is classed as an uppercase character in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswupper (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If an uppercase character.
0 If not an uppercase character.

iswxdigit

Indicates if a wide character is a hexadecimal digit (0 to 9, A to F, or a to f) in the program's current locale.

Format

#include <wctype.h> (ISO C)

#include <wchar.h> (XPG4)

int iswxdigit (wint_t wc);


Arguments

wc

An object of type wint_t . The value of wc must be representable as a wchar_t in the current locale, or must equal the value of the macro WEOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a hexadecimal digit.
0 If not a hexadecimal digit.

isxdigit

Indicates if a character is a hexadecimal digit (0 to 9, A to F, or a to f) in the program's current locale.

Format

#include <ctype.h>

int isxdigit (int character);


Argument

character

An object of type int . The value of character must be representable as an unsigned char in the current locale, or must equal the value of the macro EOF. If it has any other value, the behavior is undefined.

Return Values

nonzero If a hexadecimal digit.
0 If not a hexadecimal digit.

jrand48

Generate uniformly distributed pseudorandom number sequences. Returns 48-bit signed, long integers.

Format

#include <stdlib.h>

long int jrand48 (unsigned short int xsubi[3]);


Arguments

xsubi

An array of three short int that form a 48-bit integer when concatentated together.

Description

This function generates pseudorandom numbers using the linear congruential algorithm and 48-bit integer arithmetic.

The function returns signed long integers uniformly distributed over the range of y values, such that -231 <= y < 231 .

The function works by generating a sequence of 48-bit integer values, Xi, according to the linear congruential formula:


       Xn+1 = (aXn+c)mod m        n >= 0 

The argument m equals 248 , so 48-bit integer arithmetic is performed. Unless you invoke the lcong48 function, the multiplier value a and the addend value c are:


      a = 5DEECE66D16 = 2736731631558
      c = B16 = 138

The jrand48 function requires that the calling program pass an array as the xsubi argument, which for the first call must be initialized to the initial value of the pseudorandom number sequence. Unlike the drand48 function, it is not necessary to call an initialization function prior to the first call.

By using different arguments, jrand48 allows separate modules of a large program to generate several independent sequences of pseudorandom numbers. For example, the sequence of numbers that one module generates does not depend upon how many times the function is called by other modules.


Return Values

n Signed, long integers uniformly distributed over the range -2 31 <= y < 2 31 .

kill

Sends a signal to the process specified by a process ID.

Format

#include <signal.h>

int kill (int pid, int sig);


Arguments

pid

The process ID.

sig

The signal code.

Description

This function is restricted to C and C++ programs that include the main function.

The kill function sends a signal to a process, as if the process had called raise . If the signal is not trapped or ignored by the target program, the program exits.

OpenVMS VAX and Alpha implement different rules about what process you are allowed to send signals to. A program always has privileges to send a signal to a child started with vfork / exec . For other processes, the results are determined by the OpenVMS security model for your system.

Because of an OpenVMS restriction, the kill function cannot deliver a signal to a target process that runs an image installed with privileges.

Unless you have system privileges, the sending and receiving processes must have the same user identification code (UIC).

On OpenVMS systems before Version 7.0, kill treats a signal value of 0 as if SIGKILL were specified.

For OpenVMS Version 7.0 and higher systems, if you include <stdlib.h> and compile with the _POSIX_EXIT feature-test macro set, then:


Return Values

0 Indicates that kill was successfully queued.
--1 Indicates errors. The receiving process may have a different UIC and you are not a system user, or the receiving process does not exist.

labs

Returns the absolute value of an integer as a long int .

Format

#include <stdlib.h>

long int labs (long int j);


Argument

j

A value of type long int .

lcong48

Initializes a 48-bit uniformly distributed pseudorandom number sequences.

Format

#include <stdlib.h>

void lcong48 (unsigned short int param[7]);


Arguments

param

An array that in turn specifies the initial Xi, the multiplier value a, and the addend value c.

Description

This function generates pseudorandom numbers using the linear congruential algorithm and 48-bit integer arithmetic.

You can use lcong48 to initialize the random number generator before you call any of the following functions:

drand48
lrand48
mrand48

The lcong48 function specifies the initial Xi value, the multiplier value a, and the addend value c. The param array elements specify the following:
param[0-2] Xi
param[3-5] Multiplier a value
param[6] 16-bit addend c value

After lcong48 has been called, a subsequent call to either srand48 or seed48 restores the standard a and c as specified previously.

The lcong48 function does not return a value.

See also drand48 , lrand48 , mrand48 , srand48 , and seed48 in this section.


ldexp

Returns its first argument multiplied by 2 raised to the power of its second argument; that is, x(2n) .

Format

#include <math.h>

double ldexp (double x, int n);


Arguments

x

A base value of type double that is to be multiplied by 2n .

n

The integer exponent value to which 2 is raised.

Return Values

x(2 n) The first argument multiplied by 2 raised to the power of the second argument.
0 Indicates underflow; errno is set to ERANGE.
HUGE_VAL Indicates overflow; errno is set to ERANGE.

ldiv

Returns the quotient and the remainder after the division of its arguments.

Format

#include <stdlib.h>

ldiv_t ldiv (long int numer, long int denom);


Arguments

numer

A numerator of type long int .

denom

A denominator of type long int .

Description

The type ldiv_t is defined in the <stdlib.h> header file as follows:


typedef struct 
        { 
             long   quot, rem; 
        } ldiv_t; 

See also div in this section.


leaveok

Signals Curses to leave the cursor at the current coordinates after an update to the window.

Format

#include <curses.h>

leaveok (WINDOW *win, bool boolf);


Arguments

win

A pointer to the window.

boolf

A Boolean TRUE or FALSE value. If boolf is TRUE, the cursor remains in place after the last update and the coordinate setting on win changes accordingly. If boolf is FALSE, the cursor moves to the currently specified (y,x) coordinates of win.

Description

This function defaults to moving the cursor to the current coordinates of win. The bool type is defined in the <curses.h> header file as follows:


#define bool int 


link

Creates a new link (directory entry) for an existing file.

Format

#include <unistd.h>

link (const char *path1, const char *path2);


Arguments

path1

Pointer to a path name naming an existing file.

path2

Pointer to a path name naming the new directory entry to be created.

Description

The link function atomically creates a new link for the existing file, and the link count of the file is incremented by one.

The link function can be used on directory files.

If link fails, no link is created and the link count of the file remains unchanged.


Return Values

0 Successful completion.
--1 Indicates an error. The function sets errno to one of the following values:
  • EEXIST -- The link named by path2 exists.
  • EFTYPE -- Wildcards appear in either path1 or path2.
  • EINVAL -- One or both arguments specify a syntactically invalid path name.
  • ENAMETOOLONG -- The length of path1 or path2 exceeds {PATH_MAX}, or a path name component is longer than {NAME_MAX}.
  • EXDEV -- The link named by path2 and the file named by path1 are on different devices.


Previous Next Contents Index
  

1.800.AT.COMPAQ

privacy and legal statement