![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to quadf CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / apl / doc|
Return to quadf CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / apl / doc |
1.1 root 1: .LP
2: The following standard quad functions
3: are available in \*u \*a:
4: .IP "\*(qdcr \'name\'" 24
5: The result of ``\*(qdcr'' is a character array
6: containing the function whose name is
7: passed as an argument.
8: .IP "\*(qdfx newfn"
9: The contents of the character array
10: specified as an argument are fixed as
11: an \*a function.
12: .IP "\*(qdnc \'arg\'"
13: This function can be used to determine what
14: type of variable an \*a symbol is. The
15: apl symbol must be specified inside quote
16: marks, as shown. The returned value will be:
17: .br
18: 0 \(em symbol is undefined
19: .br
20: 2 \(em symbol is a label or variable
21: .br
22: 3 \(em symbol is a function name
23: .br
24: 4 \(em unknown type (should not occur)
25: .br
26: .IP "\*(qdnl arg"
27: The argument should be a scalar or vector
28: with components 1, 2, or 3.
29: This function returns a two-dimensional
30: character array containing the names of
31: all items whose types are specified in the
32: vector
33: (same type definitions as for ``\*(qdnc'' above).
34: The ordering of names in the matrix is fortuitous.
35: .sp 2
36: .LP
37: The following non-standard quad functions are
38: defined:
39: .IP "fd \*(qdap \'string\'" 24
40: This quad function is used to append a
41: character string onto the end of a \*u
42: file. The first argument specifies the
43: file descriptor of the file (which should
44: have been opened earlier). The second
45: argument is a character array which is
46: to be appended. A carriage return is
47: automatically appended to the end of
48: each row of the character array when it
49: is appended to the end of the file.
50: .IP "\*(qdchdir \'directory\'"
51: This quad function can be used to change
52: \*a to another directory. Normally, \*a
53: runs in the directory that you were in
54: when it was started by the ``apl'' command.
55: The argument is a character
56: vector specifying the new directory (there
57: is NO way to default this). A 0 is returned
58: if the ``chdir'' was successful; a \(mi1 is
59: returned if it failed.
60: .IP "\*(qdclose fd"
61: This function complements ``\*(qdopen''. The
62: argument is the file descriptor of a \*u
63: file to be closed. This function returns
64: 0 for success or \(mi1 for failure.
65: .IP "mode \*(qdcreat \'file\'"
66: This function creates a \*u file. If the
67: file already exists, it is truncated to zero
68: length. The creation mode is specified as
69: the first argument
70: The filename is specified
71: in a character vector as the second argument.
72: The file descriptor of the created file (or
73: \(mi1 for error) is returned.
74: .IP "\*(qddup fd"
75: This function executes the ``dup'' system
76: call. It returns an integer number which
77: may be used as a file descriptor on later
78: I/O calls.
79: The new file descriptor
80: is a duplicate of the argument ``fd''.
81: If the argument file descriptor could not be
82: duplicated, \(mi1 is returned.
83: .IP "\*(qdexec matrix"
84: Takes a two-dimensional character matrix
85: and formats it into a \*u ``exec'' system
86: call. The matrix passed as an argument
87: must be two-dimensional, the rows must
88: be \fIzero\fR terminated.
89: .IP "\*(qdexit code"
90: This quad function is used to terminate
91: the execution of the current process,
92: with the completion code ``code''. It should
93: be used to terminate child processes and
94: can be used to terminate an \*a session;
95: however, it is recommended that the system command
96: ``)off'' be used for that purpose.
97: .IP "\*(qdfloat charvect"
98: This quad function is useful in conjunction
99: with ``\*(qdwrite'' and ``\*(qdread''.
100: Although any type of
101: data may be written to a \*u file with
102: ``\*(qdwrite'', when it is read with ``\*(qdread'' it
103: will be interpreted as character data. This
104: function will convert a character array into
105: numeric form. The array must be a multiple
106: of 4 elements long for apl2 and 8 for apl.
107: The converted array is the returned value.
108: .IP "\*(qdfork xx"
109: ``xx'' is a dummy argument. A ``fork'' system
110: call is performed.
111: This quad function
112: probably will be followed by a
113: ``\*(qdexec'' quad function.
114: The process-id
115: of the child is returned to the parent;
116: a zero is returned to the child.
117: .IP "pid \*(qdkill signal"
118: This function executes the ``kill'' system
119: call. The first argument specifies what
120: process is to be signalled. The second
121: argument specifies what signal is to be
122: sent. A 0 is returned for a successful
123: ``kill''; \(mi1 is returned if the specified
124: process could not be found or is not
125: owned by the current user.
126: .IP "mode \*(qdopen \'file\'"
127: This function is dyadic. It opens a \*u
128: file for use by an \*a function with calls
129: via ``\*(qdread'' and ``\*(qdwrite''. The first
130: argument is the mode for the open (0=read,
131: 1=write, 2=read/write). The second
132: argument is a character vector containing
133: the file name. The file descriptor of the
134: opened file is returned (\(mi1 for error).
135: .IP "\*(qdpipe xx"
136: This quad function can be used to set up
137: a pipe (used for interprocess communication)
138: It returns a 2-element vector containing
139: the two ``pipe'' file descriptors.
140: .IP "\*(qdrd fd"
141: This function reads one line from the
142: file descriptor specified. If the line
143: is completely blank, a null string is
144: returned. An end-of-file will also return
145: a null string. Otherwise, the returned
146: value is the character string which was
147: read.
148: .IP "\*(qdrm \'filename\'"
149: The specified file will be removed,
150: equivalent to )drop filename. A 0
151: is returned for a successful remove;
152: \(mi1 is returned if the file could not be
153: removed or does not exist.
154: .IP "fd \*(qdread nbytes"
155: This function reads a specified number
156: of bytes from a designated file. The
157: first argument is the file descriptor;
158: the second is the number of bytes to be
159: read. The data which is read is returned.
160: Note that the returned vector is always
161: character data \(em to convert to numeric
162: format see the function ``\*(qdfloat''.
163: .IP "\*(qdrline fd"
164: This quad function is identical to ``\*(qdrd'',
165: described above.
166: .IP "\*(qdrun \'unix command\'"
167: The argument passed to ``\*(qdrun'' is executed
168: as a \*u shell command.
169: .IP "\*(qdseek (fd,pos,mode)"
170: This function executes the ``seek'' system
171: call on a \*u file. The argument to
172: ``\*(qdseek'' is a three-element vector containing
173: the file descriptor, seek offset, and mode
174: A 0 is returned for
175: a successful seek; \(mi1 is returned if an
176: error is detected.
177: .IP "signal \*(qdsig action"
178: This quad function allows signal processing
179: to be turned on and off under \*a function
180: control. The first argument is the signal
181: whose processing is to be changed. The
182: second argument specifies how the signal
183: will be processed \(em if zero, the signal will
184: cause termination of \*a and a possible
185: core dump; if non-zero, the signal will be
186: ignored. Note that the special way in which
187: interrupts and other signals are processed
188: by \*a is turned off by a call to ``\*(qdsig''
189: and cannot be turned back on. A \(mi1 is
190: returned on error, a positive number or zero
191: for success.
192: .IP "\*(qdwait xx"
193: This quad function is used in conjunction
194: with ``\*(qdfork'' \(em it returns a 3-element
195: vector of information about a child
196: process which has terminated. The first
197: element is either the
198: process-id of a completed
199: child process or \(mi1 (no children).
200: The second is the status of the dead
201: process,
202: and the last is the completion code.
203: .IP "fd \*(qdwrite data"
204: This function writes data to a specified
205: file. The first argument is the file
206: descriptor; the second is the data to be
207: written. The number of bytes written is
208: returned as the count. Any type of data
209: (character or numeric) may be written in
210: this manner.
211: .LP
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.