Return to varargs.3 CVS log

Up to [Research Unix] / researchv10dc / man / adm / man3

Annotation of researchv10dc/man/adm/man3/varargs.3, revision 1.1.1.1

1.1       root        1: .TH VARARGS 3
                      2: .CT 2 data_man
                      3: .SH NAME
                      4: varargs \(mi variable argument list
                      5: .SH SYNOPSIS
                      6: .nf
                      7: .B #include <varargs.h>
                      8: .IB function (va_alist)
                      9: .B va_dcl
                     10: .PP
                     11: .B va_list  pvar;
                     12: .PP
                     13: .B va_start(pvar);
                     14: .PP
                     15: .B va_arg(pvar, type);
                     16: .PP
                     17: .B va_end(pvar);
                     18: .fi
                     19: .SH DESCRIPTION
                     20: This set of macros allows portable procedures that accept variable
                     21: argument lists to be written.
                     22: Routines which have variable argument lists (such as
                     23: .IR printf (3))
                     24: that do not use varargs are inherently nonportable, since different
                     25: machines use different argument passing conventions.
                     26: .PP
                     27: The literal identifier
                     28: .I va_alist
                     29: is used in a function header to declare a variable argument list.
                     30: It is declared by
                     31: .I va_dcl.
                     32: Note that there is no semicolon after
                     33: .I va_dcl.
                     34: .PP
                     35: .B Va_list
                     36: is the type of the variable
                     37: .I pvar,
                     38: which is used to traverse the list.
                     39: One variable of this type must always be declared.
                     40: .PP
                     41: .I Va_start
                     42: initializes
                     43: .I pvar
                     44: to the beginning of the list.
                     45: .PP
                     46: .I Va_arg
                     47: returns the next argument in the list
                     48: pointed to by
                     49: .IR pvar .
                     50: .I Type
                     51: is the type the argument is expected to be.
                     52: Different types can be mixed, but it is up
                     53: to the routine to know what type is
                     54: expected, since it cannot be determined at runtime.
                     55: .PP
                     56: .I Va_end
                     57: is used to finish up.
                     58: .PP
                     59: Multiple traversals, each bracketed by
                     60: .I va_start
                     61: and
                     62: .I va_end,
                     63: are possible.
                     64: .SH EXAMPLES
                     65: How to define
                     66: .I execl
                     67: in terms of
                     68: .IR execv ;
                     69: see
                     70: .IR exec (2):
                     71: .IP
                     72: .nf
                     73: .ft L
                     74: #include <varargs.h>
                     75: execl(va_alist)
                     76: va_dcl
                     77: {
                     78:        va_list ap;
                     79:        char *file;
                     80:        char *args[100];
                     81:        int argno = 0;
                     82:        va_start(ap);
                     83:        file = va_arg(ap, char*);
                     84:        while(args[argno++] = va_arg(ap, char*));
                     85:        va_end(ap);
                     86:        execv(file, args);
                     87: }
                     88: .fi
                     89: .ft P

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.