| Previous | Contents | Index |
Unmaps a mapped region. This function is reentrant.
#include <mman.h>int munmap (void *addr, size_t len);
addr
The address of the region that you want to unmap.len
The length, in bytes, of that region the you want to unmap.
The munmap function unmaps a mapped file or shared memory region.The addr and len arguments specify the address and length, in bytes, respectively, of the region to be unmapped.
The len argument must be a multiple of the page size as returned by sysconf(_SC_PAGE_SIZE) ; otherwise, the length of the region is rounded up to the next multiple of the page size.
The result of using an address that lies in an unmapped region and not in any subsequently mapped region is undefined.
See also sysconf .
0 Indicates success. - 1 Indicates an error; errno is set to one of the following values:
- ENIVAL -- The addr argument is not a multiple of the page size as returned by sysconf(_SC_PAGE_SIZE) .
- EFAULT -- The range [ addr, addr + len] includes an invalid address.
Move the cursor to coordinates (y,x) and add a character to the specified window.
#include <curses.h>int mvaddch (int y, int x, char ch);
int mvwaddch (WINDOW *win, int y, int x, char ch);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.ch
If this argument is a new-line character (\n), the mvaddch and mvwaddch functions clear the line to the end, and move the cursor to the next line at the same x coordinate. A carriage return (\r) moves the cursor to the beginning of the specified line. A tab (\t) moves the cursor to the next tabstop within the window.
This routine performs the same function as mvwaddch , but on the stdscr window.When mvwaddch is used on a subwindow, it writes the character onto the underlying window as well.
OK Indicates success. ERR Indicates that writing the character would cause the screen to scroll illegally. For more information, see the scrollok function.
Move the cursor to coordinates (y,x) and add the specified string, to which str points, to the specified window.
#include <curses.h>int mvaddstr (int y, int x, char *str);
int mvwaddstr (WINDOW *win, int y, int x, char *str);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.str
A pointer to the character string.
This routine performs the same function as mvwaddstr , but on the stdscr window.When mvwaddstr is used on a subwindow, the string is written onto the underlying window as well.
OK Indicates success. ERR Indicates that the function causes the screen to scroll illegally, but it places as much of the string onto the window as possible. For more information, see the scrollok function.
Moves the terminal's cursor from (lasty,lastx) to (newy,newx).
#include <curses.h>int mvcur (int lasty, int lastx, int newy, int newx);
lasty
The cursor position.lastx
The cursor position.newy
The resulting cursor position.newx
The resulting cursor position.
In HP C for OpenVMS Systems, mvcur and move perform the same function.See also move .
OK Indicates success. ERR Indicates that moving the window placed part or all of the window off the edge of the terminal screen. The terminal screen remains unaltered.
Move the cursor to coordinates (y,x) and delete the character on the specified window. The mvdelch function acts on the stdscr window.
#include <curses.h>int mvdelch (int y, int x);
int mvwdelch (WINDOW *win, int y, int x);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.
Each of the following characters on the same line shifts to the left, and the last character becomes blank.
OK Indicates success. ERR Indicates that deleting the character would cause the screen to scroll illegally. For more information, see the scrollok function.
Move the cursor to coordinates (y,x), get a character from the terminal screen, and echo it on the specified window. The mvgetch function acts on the stdscr window.
#include <curses.h>int mvgetch (int y, int x);
int mvwgetch (WINDOW *win, int y, int x);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.
The mvgetch and mvwgetch functions refresh the specified window before fetching the character.
x The returned character. ERR Indicates that the function causes the screen to scroll illegally. For more information, see the scrollok function in this section.
Move the cursor to coordinates (y,x), get a string from the terminal screen, store it in the variable str (which must be large enough to contain the string), and echo it on the specified window. The mvgetstr function acts on the stdscr window.
#include <curses.h>int mvgetstr (int y, int x, char *str);
int mvwgetstr (WINDOW *win, int y, int x, char *str);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.str
The string that is displayed.
The mvgetstr and mvwgetstr functions strip the new-line terminator (\n) from the string.
OK Indicates success. ERR Indicates that the function causes the screen to scroll illegally.
Move the cursor to coordinates (y,x) and return the character on the specified window without making changes to the window. The mvinch function acts on the stdscr window.
#include <curses.h>int mvinch (int y, int x);
int mvwinch (WINDOW *win, int y, int x);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.
x The returned character. ERR Indicates an input error.
Move the cursor to coordinates (y,x) and insert the character ch into the specified window. The mvinsch function acts on the stdscr window.
#include <curses.h>int mvinsch (int y, int x, char ch);
int mvwinsch (WINDOW *win, int y, int x, char ch);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.ch
The character to be inserted at the window's coordinates.
After the character is inserted, each character on the line shifts to the right, and the last character on the line is deleted.
OK Indicates success. ERR Indicates that the function makes the screen scroll illegally. For more information, see the scrollok function in this section.
Move the cursor to coordinates (y,x) and insert the specified string into the specified window. The mvinsstr function acts on the stdscr window.
#include <curses.h>int mvinsstr (int y, int x, char *str);
int mvwinsstr (WINDOW *win, int y, int x, char *str);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.str
The string that is displayed.
Each character after the string shifts to the right, and the last character disappears. The mvinsstr and mvwinsstr functions are specific to HP C for OpenVMS Systems and are not portable.
OK Indicates success. ERR Indicates that the function makes the screen scroll illegally. For more information, see the scrollok function.
Moves the starting position of the window to the specified (y,x) coordinates.
#include <curses.h>mvwin (WINDOW *win, int y, int x);
win
A pointer to the window.y
A window coordinate.x
A window coordinate.
When moving subwindows, the mvwin function does not rewrite the contents of the subwindow on the underlying window at the new position. If you write anything to the subwindow after the move, the function also writes to the underlying window.
OK Indicates success. ERR Indicates that moving the window put part or all of the window off the edge of the terminal screen. The terminal screen remains unaltered.
High-resolution sleep (REALTIME). Suspends a process (or thread in a threaded program) from execution for the specified timer interval.
#include <time.h>int nanosleep (const struct timespec *rqtp, struct timespec *rmtp);
rqtp
A pointer to the timespec data structure that defines the time interval during which the calling process or thread is suspended.rmtp
A pointer to the timespec data structure that receives the amount of time remaining in the previously requested interval, or zero if the full interval has elapsed.
The nanosleep function suspends a process or thread until one of the following conditions is met:
- The time interval specified by the rqtp argument has elapsed.
- A signal is delivered to the calling process and the action is to invoke a signal-catching function or to terminate the process.
The suspension time may be longer than requested because the argument value is rounded up to an integer multiple of the sleep resolution or because of the scheduling of other activity by the system. Except when interrupted by a signal, the suspension time is not less than the time specified by the rqtp argument (as measured by the system clock, CLOCK_REALTIME).
The use of the nanosleep function has no effect on the action or blockage of any signal.
If the requested time has elapsed, the call was successful and the nanosleep function returns zero.
On failure, the nanosleep function returns - 1 and sets errno to indicate the failure. The function fails if it has been interrupted by a signal, or if the rqtp argument specified a nanosecond value less than 0 or greater than or equal to 1 billion.
If the rmtp argument is non-NULL, the timespec structure it references is updated to contain the amount of time remaining in the interval (the requested time minus the time actually slept).
If the rmtp argument is NULL, the remaining time is not returned.
See also clock_getres , clock_gettime , clock_settime , and sleep .
0 Indicates success. The requested time has elapsed. - 1 Indicates failure. The function call was unsuccessful or was interrupted by a signal; errno is set to one of the following values:
- EINTR -- The nanosleep function was interrupted by a signal.
- EINVAL -- The rqtp argument specified a nanosecond value less than 0 or greater than or equal to 1 billion.
Creates a new window with numlines lines and numcols columns starting at the coordinates (begin_y,begin_x) on the terminal screen.
#include <curses.h>WINDOW *newwin (int numlines, int numcols, int begin_y, int begin_x);
numlines
If it is 0, the newwin function sets that dimension to LINES (begin_y). To get a new window of dimensions LINES by COLS, use the following line:
newwin (0, 0, 0, 0)numcols
If it is 0, the newwin function sets that dimension to COLS (begin_x). Therefore, to get a new window of dimensions LINES by COLS, use the following line:
newwin (0, 0, 0, 0)begin_y
A window coordinate.begin_x
A window coordinate.
x The address of the allocated window. ERR Indicates an error.
Returns the next machine-representable number following x in the direction of y.
#include <math.h>double nextafter (double x, double y);
float nextafterf (float x, float y);
long double nextafterl (long double x, long double y);
x
A real number.y
A real number.
The nextafter functions return the next machine-representable floating-point number following x in the direction of y. If y is less than x, nextafter returns the largest representable floating-point number less than x.
x The next representable floating-point value following x in the direction of y. HUGE_VAL Overflow; errno is set to ERANGE. NaN x or y is NaN; errno is set to EDOM.
Increases or decreases process priority relative to the process current priority by the amount of the argument. This function is nonreentrant.
#include <unistd.h>int nice (int increment);
increment
As a positive argument, decreases priority; as a negative argument, increases priority. Issuing nice(0) restores the base priority. The resulting priority cannot be less than 1, or greater than the process's base priority. If it is, the nice function quietly does nothing.
When a process calls the vfork function, the resulting child inherits the parent's priority.With the DECC$ALLOW_UNPRIVILEGED_NICE feature logical enabled, the nice function exhibits its legacy behavior of not checking the privilege of the calling process (that is, any user may lower the nice value to increase process priorities). Also, when the caller sets a priority above MAX_PRIORITY, the nice value is set to the base priority.
With DECC$ALLOW_UNPRIVILEGED_NICE disabled, the nice function conforms to the X/Open standard of checking the privilege of the calling process (only users with ALTPRI privilege can lower the nice value to increase process priorities), and when the caller sets a priority above MAX_PRIORITY, the nice value is set to MAX_PRIORITY.
See also vfork .
0 Indicates success. - 1 Indicates failure.
Returns the nearest integral value to the argument.
#include <math.h>double nint (double x);
float nintf (float x,);
long double nintl (long double x);
x
A real number.
The nint functions return the nearest integral value to x, except halfway cases are rounded to the integral value larger in magnitude. This corresponds to the Fortran generic intrinsic function nint .
n The nearest integral value to x. NaN x is NaN; errno is set to EDOM.
| Previous | Next | Contents | Index |