|
1
|
1 // builtins.cc -*- C++ -*- |
|
|
2 /* |
|
|
3 |
|
|
4 Copyright (C) 1992, 1993 John W. Eaton |
|
|
5 |
|
|
6 This file is part of Octave. |
|
|
7 |
|
|
8 Octave is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
|
10 Free Software Foundation; either version 2, or (at your option) any |
|
|
11 later version. |
|
|
12 |
|
|
13 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
16 for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
|
19 along with Octave; see the file COPYING. If not, write to the Free |
|
|
20 Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
|
|
21 |
|
|
22 */ |
|
|
23 |
|
|
24 #ifdef __GNUG__ |
|
|
25 #pragma implementation |
|
|
26 #endif |
|
|
27 |
|
|
28 #include <iostream.h> |
|
|
29 #include <math.h> |
|
|
30 #include <float.h> |
|
|
31 |
|
|
32 #include "tree-const.h" |
|
|
33 #include "symtab.h" |
|
|
34 #include "t-builtins.h" |
|
|
35 #include "g-builtins.h" |
|
|
36 #include "builtins.h" |
|
|
37 #include "octave.h" |
|
|
38 #include "utils.h" |
|
|
39 #include "tree.h" |
|
|
40 #include "mappers.h" |
|
|
41 #include "user-prefs.h" |
|
|
42 #include "variables.h" |
|
|
43 |
|
|
44 // NOTE: nargin == 1 means that the function takes no arguments (just |
|
|
45 // like C, the first argument is (or should be, anyway) the function |
|
|
46 // name). Also, -1 is shorthand for infinity. |
|
|
47 |
|
|
48 // The following initializations may eventually need to be reworked |
|
|
49 // like the builtin functions in bash were around version 1.12... |
|
|
50 |
|
|
51 static builtin_mapper_functions mapper_functions[] = |
|
|
52 { |
|
|
53 { "abs", 2, 1, 0, fabs, abs, NULL, |
|
|
54 "compute abs(X) for each element of X\n", }, |
|
|
55 |
|
|
56 { "acos", 2, 1, 0, acos, NULL, acos, |
|
|
57 "compute acos(X) for each element of X\n", }, |
|
|
58 |
|
|
59 { "acosh", 2, 1, 0, acosh, NULL, acosh, |
|
|
60 "compute acosh(X) for each element of X\n", }, |
|
|
61 |
|
|
62 { "angle", 2, 1, 0, arg, arg, NULL, |
|
|
63 "compute arg(X) for each element of X\n", }, |
|
|
64 |
|
|
65 { "arg", 2, 1, 0, arg, arg, NULL, |
|
|
66 "compute arg(X) for each element of X\n", }, |
|
|
67 |
|
|
68 { "asin", 2, 1, 0, asin, NULL, asin, |
|
|
69 "compute asin(X) for each element of X\n", }, |
|
|
70 |
|
|
71 { "asinh", 2, 1, 0, asinh, NULL, asinh, |
|
|
72 "compute asinh(X) for each element of X\n", }, |
|
|
73 |
|
|
74 { "atan", 2, 1, 0, atan, NULL, atan, |
|
|
75 "compute atan(X) for each element of X\n", }, |
|
|
76 |
|
|
77 { "atanh", 2, 1, 0, atanh, NULL, atanh, |
|
|
78 "compute atanh(X) for each element of X\n", }, |
|
|
79 |
|
|
80 { "ceil", 2, 1, 0, ceil, NULL, ceil, |
|
|
81 "ceil(X): round elements of X toward +Inf\n", }, |
|
|
82 |
|
|
83 { "conj", 2, 1, 0, conj, NULL, conj, |
|
|
84 "compute complex conjugate for each element of X\n", }, |
|
|
85 |
|
|
86 { "cos", 2, 1, 0, cos, NULL, cos, |
|
|
87 "compute cos(X) for each element of X\n", }, |
|
|
88 |
|
|
89 { "cosh", 2, 1, 0, cosh, NULL, cosh, |
|
|
90 "compute cosh(X) for each element of X\n", }, |
|
|
91 |
|
|
92 { "exp", 2, 1, 0, exp, NULL, exp, |
|
|
93 "compute exp(X) for each element of X\n", }, |
|
|
94 |
|
|
95 { "finite", 2, 1, 0, xfinite, xfinite, NULL, |
|
|
96 "finite(X): return 1 for finite elements of X\n", }, |
|
|
97 |
|
|
98 { "fix", 2, 1, 0, fix, NULL, fix, |
|
|
99 "fix(X): round elements of X toward zero\n", }, |
|
|
100 |
|
|
101 { "floor", 2, 1, 0, floor, NULL, floor, |
|
|
102 "floor(X): round elements of X toward -Inf\n", }, |
|
|
103 |
|
|
104 { "isinf", 2, 1, 0, xisinf, xisinf, NULL, |
|
|
105 "isinf(X): return 1 for elements of X infinite\n", }, |
|
|
106 |
|
|
107 { "imag", 2, 1, 0, imag, imag, NULL, |
|
|
108 "return imaginary part for each elements of X\n", }, |
|
|
109 |
|
|
110 #ifdef HAVE_ISNAN |
|
|
111 { "isnan", 2, 1, 0, xisnan, xisnan, NULL, |
|
|
112 "isnan(X): return 1 where elements of X are NaNs\n", }, |
|
|
113 #endif |
|
|
114 |
|
|
115 { "log", 2, 1, 1, log, NULL, log, |
|
|
116 "compute log(X) for each element of X\n", }, |
|
|
117 |
|
|
118 { "log10", 2, 1, 1, log10, NULL, log10, |
|
|
119 "compute log10(X) for each element of X\n", }, |
|
|
120 |
|
|
121 { "real", 2, 1, 0, real, real, NULL, |
|
|
122 "return real part for each element of X\n", }, |
|
|
123 |
|
|
124 { "round", 2, 1, 0, round, NULL, round, |
|
|
125 "round(X): round elements of X to nearest integer\n", }, |
|
|
126 |
|
|
127 { "sign", 2, 1, 0, signum, NULL, signum, |
|
|
128 "sign(X): apply signum function to elements of X\n", }, |
|
|
129 |
|
|
130 { "sin", 2, 1, 0, sin, NULL, sin, |
|
|
131 "compute sin(X) for each element of X\n", }, |
|
|
132 |
|
|
133 { "sinh", 2, 1, 0, sinh, NULL, sinh, |
|
|
134 "compute sinh(X) for each element of X\n", }, |
|
|
135 |
|
|
136 { "sqrt", 2, 1, 1, sqrt, NULL, sqrt, |
|
|
137 "compute sqrt(X) for each element of X\n", }, |
|
|
138 |
|
|
139 { "tan", 2, 1, 0, tan, NULL, tan, |
|
|
140 "compute tan(X) for each element of X\n", }, |
|
|
141 |
|
|
142 { "tanh", 2, 1, 0, tanh, NULL, tanh, |
|
|
143 "compute tanh(X) for each element of X\n", }, |
|
|
144 |
|
|
145 { NULL, -1, -1, -1, NULL, NULL, NULL, NULL, }, |
|
|
146 }; |
|
|
147 |
|
|
148 static builtin_text_functions text_functions[] = |
|
|
149 { |
|
|
150 { "casesen", 2, builtin_casesen, |
|
|
151 "print warning if user tries to change case sensitivity\n", }, |
|
|
152 |
|
|
153 { "cd", 2, builtin_cd, |
|
|
154 "change current working directory\n", }, |
|
|
155 |
|
|
156 { "clear", -1, builtin_clear, |
|
79
|
157 "clear symbol(s) matching a list of regular expressions\n", }, |
|
1
|
158 |
|
|
159 { "dir", -1, builtin_ls, |
|
|
160 "print a directory listing\n", }, |
|
|
161 |
|
|
162 { "document", -1, builtin_document, |
|
|
163 "define help string for symbol\n", }, |
|
|
164 |
|
|
165 { "edit_history", -1, builtin_edit_history, |
|
|
166 "usage: edit_history [first] [last]\n", }, |
|
|
167 |
|
|
168 { "format", -1, builtin_format, |
|
|
169 "set output formatting style\n", }, |
|
|
170 |
|
|
171 { "help", -1, builtin_help, |
|
|
172 "print cryptic yet witty messages\n", }, |
|
|
173 |
|
|
174 { "history", -1, builtin_history, |
|
|
175 "print/save/load command history\n", }, |
|
|
176 |
|
|
177 { "load", -1, builtin_load, |
|
|
178 "load variables from a file\n", }, |
|
|
179 |
|
|
180 { "ls", -1, builtin_ls, |
|
|
181 "print a directory listing\n", }, |
|
|
182 |
|
61
|
183 { "run_history", -1, builtin_run_history, |
|
|
184 "usage: run_history [first] [last]\n", }, |
|
|
185 |
|
1
|
186 { "save", -1, builtin_save, |
|
|
187 "save variables to a file\n", }, |
|
|
188 |
|
|
189 { "set", -1, builtin_set, |
|
|
190 "set plotting options\n", }, |
|
|
191 |
|
|
192 { "show", -1, builtin_show, |
|
|
193 "show plotting options\n", }, |
|
|
194 |
|
|
195 { "who", -1, builtin_who, |
|
|
196 "list symbols\n", }, |
|
|
197 |
|
|
198 { NULL, -1, NULL, NULL, }, |
|
|
199 }; |
|
|
200 |
|
|
201 static builtin_general_functions general_functions[] = |
|
|
202 { |
|
|
203 { "all", 2, 1, builtin_all, |
|
|
204 "all(X): are all elements of X nonzero?\n", }, |
|
|
205 |
|
|
206 { "any", 2, 1, builtin_any, |
|
|
207 "any(X): are any elements of X nonzero?\n", }, |
|
|
208 |
|
19
|
209 { "balance", 4, 4, builtin_balance, |
|
|
210 "balancing for algebraic and generalized eigenvalue prblems\n\ |
|
|
211 Usage: \n\ |
|
|
212 algebraic eigenvalues problem:\n\ |
|
|
213 aa = balance(a{,opt}) or [{dd,}aa] = balance(a{,opt})\n\ |
|
|
214 generalized eigenvalue problem:\n\ |
|
|
215 [cc, dd, aa, bb] = balance (a, b {,opt})\n\ |
|
|
216 where 'opt' is an optional single character argument as follows: \n\ |
|
|
217 'N' or 'n': no balancing; arguments copied, transformation(s) \n\ |
|
|
218 set to identity\n\ |
|
|
219 'P' or 'p': permute argument(s) to isolate eigenvalues where possible\n\ |
|
|
220 'S' or 's': scale to improve accuracy of computed eigenvalues\n\ |
|
|
221 'B' or 'b': (default) permute and scale, in that order. Rows/columns of a \n\ |
|
|
222 (and b) that are isolated by permutation are not scaled\n\ |
|
|
223 [dd, aa] = balance (a, opt) returns aa = dd\a*dd,\n\ |
|
|
224 [cc, dd, aa, bb] = balance (a, b, opt) returns aa (bb) = cc*a*dd (cc*b*dd)\n", }, |
|
|
225 |
|
1
|
226 { "clc", 1, 0, builtin_clc, |
|
|
227 "clear screen\n", }, |
|
|
228 |
|
|
229 { "clock", 1, 0, builtin_clock, |
|
|
230 "return current date and time in vector\n", }, |
|
|
231 |
|
|
232 { "closeplot", 1, 0, builtin_closeplot, |
|
|
233 "close the stream to plotter\n", }, |
|
|
234 |
|
|
235 { "colloc", 7, 4, builtin_colloc, |
|
|
236 "[r, A, B, q] = colloc (n [, 'left'] [, 'right']): collocation weights\n", }, |
|
|
237 |
|
|
238 { "cumprod", 2, 1, builtin_cumprod, |
|
|
239 "cumprod (X): cumulative products\n", }, |
|
|
240 |
|
|
241 { "cumsum", 2, 1, builtin_cumsum, |
|
|
242 "cumsum (X): cumulative sums\n", }, |
|
|
243 |
|
|
244 { "dassl", 5, 1, builtin_dassl, |
|
|
245 "solve DAEs using Petzold's DASSL. Usage:\n\ |
|
|
246 \n\ |
|
|
247 dassl ('function_name', x_0, xdot_0, t_out)\n\ |
|
|
248 dassl ('function_name', x_0, xdot_0, t_out, t_crit)\n\ |
|
|
249 \n\ |
|
|
250 The first argument is the name of the function to call to\n\ |
|
|
251 compute the vector of residuals. It must have the form\n\ |
|
|
252 \n\ |
|
|
253 res = f (x, xdot, t)\n\ |
|
|
254 \n\ |
|
|
255 where x, xdot, and res are vectors, and t is a scalar.\n\n", }, |
|
|
256 |
|
|
257 { "date", 1, 0, builtin_date, |
|
|
258 "return current date in a string\n", }, |
|
|
259 |
|
|
260 { "det", 2, 1, builtin_det, |
|
|
261 "det(X): determinant of a square matrix\n", }, |
|
|
262 |
|
|
263 { "diag", 3, 1, builtin_diag, |
|
|
264 "diag(X [,k]): form/extract diagonals\n", }, |
|
|
265 |
|
|
266 { "disp", 3, 1, builtin_disp, |
|
|
267 "disp(X): display value\n", }, |
|
|
268 |
|
|
269 { "eig", 2, 1, builtin_eig, |
|
|
270 "eig (x): compute eigenvalues and eigenvectors of x\n", }, |
|
|
271 |
|
|
272 { "error", 2, 1, builtin_error, |
|
|
273 "print message and jump to top level\n", }, |
|
|
274 |
|
|
275 { "eval", 2, 1, builtin_eval, |
|
|
276 "evaluate text as octave source\n", }, |
|
|
277 |
|
|
278 { "exist", 2, 1, builtin_exist, |
|
|
279 "check if variable or file exists\n", }, |
|
|
280 |
|
|
281 { "exit", 1, 0, builtin_quit, |
|
|
282 "exit Octave gracefully\n", }, |
|
|
283 |
|
|
284 { "expm", 2, 1, builtin_expm, |
|
|
285 "Matrix exponential, e^A\n", }, |
|
|
286 |
|
|
287 { "eye", 3, 1, builtin_eye, |
|
|
288 "create an identity matrix\n", }, |
|
|
289 |
|
|
290 { "fclose", 2, 1, builtin_fclose, |
|
|
291 "fclose('filename' or filenum): close a file\n", }, |
|
|
292 |
|
|
293 { "feval", -1, 1, builtin_feval, |
|
|
294 "evaluate argument as function\n", }, |
|
|
295 |
|
|
296 { "fflush", 2, 1, builtin_fflush, |
|
|
297 "fflush('filename' or filenum): flush buffered data to output file\n", }, |
|
|
298 |
|
|
299 { "fft", 2, 1, builtin_fft, |
|
|
300 "fft(X): fast fourier transform of a vector\n", }, |
|
|
301 |
|
|
302 { "fgets",3, 2, builtin_fgets, |
|
|
303 "[string, length] = fgets('filename' or filenum, length): read a string from a file\n", }, |
|
|
304 |
|
|
305 { "find", -1, 1, builtin_find, |
|
|
306 "find (x): return vector of indices of nonzero elements\n", }, |
|
|
307 |
|
|
308 { "flops", 2, 1, builtin_flops, |
|
|
309 "count floating point operations\n", }, |
|
|
310 |
|
|
311 { "fopen", 3, 1, builtin_fopen, |
|
|
312 "filenum = fopen('filename','mode'): open a file\n", }, |
|
|
313 |
|
|
314 { "fprintf", -1, 1, builtin_fprintf, |
|
|
315 "fprintf ('file', 'fmt', ...)\n", }, |
|
|
316 |
|
|
317 { "freport", 1, 1, builtin_freport, |
|
|
318 "freport: list open files and their status\n", }, |
|
|
319 |
|
|
320 { "frewind", 2, 1, builtin_frewind, |
|
|
321 "frewind('filename' or filenum): set file position at beginning of file\n", }, |
|
|
322 |
|
|
323 { "fscanf", 3, -1, builtin_fscanf, |
|
|
324 "[a,b,c...] = fscanf ('file', 'fmt')\n", }, |
|
|
325 |
|
|
326 { "fseek", 4, 1, builtin_fseek, |
|
|
327 "fseek('filename' or filenum): set file position for reading or writing\n", }, |
|
|
328 |
|
|
329 { "fsolve", 5, 1, builtin_fsolve, |
|
|
330 "Solve nonlinear equations using Minpack. Usage:\n\ |
|
|
331 \n\ |
|
|
332 [x, info] = fsolve ('f', x0)\n\ |
|
|
333 \n\ |
|
|
334 Where the first argument is the name of the function to call to\n\ |
|
|
335 compute the vector of function values. It must have the form\n\ |
|
|
336 \n\ |
|
|
337 y = f (x) |
|
|
338 \n\ |
|
|
339 where y and x are vectors.\n\n", }, |
|
|
340 |
|
|
341 { "fsqp", 11, 3, builtin_fsqp, |
|
|
342 "solve NLPs\n", }, |
|
|
343 |
|
|
344 { "ftell", 2, 1, builtin_ftell, |
|
|
345 "position = ftell ('filename' or filenum): returns the current file position\n", }, |
|
|
346 |
|
|
347 { "getenv", 2, 1, builtin_getenv, |
|
|
348 "get environment variable values\n", }, |
|
|
349 |
|
31
|
350 { "givens", 3, 2, builtin_givens, |
|
|
351 "Givens rotation:\n\ |
|
|
352 G = givens(x,y) returns an orthogonal matrix G = [c s; -conj(s) c] such\n\ |
|
|
353 that G[x;y] = [*;0] (x,y scalars)\n\ |
|
|
354 [c,s] = givens(x,y) returns the (c,s) values themselves.",}, |
|
|
355 |
|
|
356 |
|
1
|
357 { "hess", 2, 2, builtin_hess, |
|
31
|
358 "Hessenberg decomposition\n",}, |
|
1
|
359 |
|
|
360 { "home", 1, 0, builtin_clc, |
|
|
361 "clear screen\n", }, |
|
|
362 |
|
|
363 { "input", 3, 1, builtin_input, |
|
|
364 "input('prompt' [,'s']): prompt user for [string] input\n", }, |
|
|
365 |
|
|
366 { "ifft", 2, 1, builtin_ifft, |
|
|
367 "ifft(X): inverse fast fourier transform of a vector\n", }, |
|
|
368 |
|
|
369 { "inv", 2, 1, builtin_inv, |
|
|
370 "inv(X): inverse of a square matrix\n", }, |
|
|
371 |
|
|
372 { "inverse", 2, 1, builtin_inv, |
|
|
373 "inverse(X): inverse of a square matrix\n", }, |
|
|
374 |
|
|
375 { "isstr", 2, 1, builtin_isstr, |
|
|
376 "isstr(X): return 1 if X is a string\n", }, |
|
|
377 |
|
|
378 { "keyboard", 2, 1, builtin_keyboard, |
|
|
379 "maybe help in debugging M-files\n", }, |
|
|
380 |
|
|
381 { "logm", 2, 1, builtin_logm, |
|
|
382 "Matrix logarithm, log (A)\n", }, |
|
|
383 |
|
|
384 { "lpsolve", 11, 3, builtin_lpsolve, |
|
|
385 "Solve linear programs using lp_solve.\n", }, |
|
|
386 |
|
|
387 { "lsode", 6, 1, builtin_lsode, |
|
|
388 "solve ODEs using Hindmarsh's LSODE. Usage:\n\ |
|
|
389 \n\ |
|
|
390 lsode ('function_name', x0, t_out\n\ |
|
|
391 lsode ('function_name', x0, t_out, t_crit)\n\ |
|
|
392 \n\ |
|
|
393 The first argument is the name of the function to call to\n\ |
|
|
394 compute the vector of right hand sides. It must have the form\n\ |
|
|
395 \n\ |
|
|
396 xdot = f (x, t)\n\ |
|
|
397 \n\ |
|
|
398 where xdot and x are vectors and t is a scalar.\n\n", }, |
|
|
399 |
|
|
400 { "lu", 2, 3, builtin_lu, |
|
|
401 "[L, U, P] = lu (A) -- LU factorization\n", }, |
|
|
402 |
|
|
403 { "max", 3, 2, builtin_max, |
|
|
404 "maximum value(s) of a vector (matrix)\n", }, |
|
|
405 |
|
|
406 { "min", 3, 2, builtin_min, |
|
|
407 "minimum value(s) of a vector (matrix)\n", }, |
|
|
408 |
|
|
409 { "npsol", 11, 3, builtin_npsol, |
|
|
410 "Solve nonlinear programs using Gill and Murray's NPSOL. Usage:\n\ |
|
|
411 \n\ |
|
|
412 [x, obj, info, lambda] = npsol (x, 'phi' [, lb, ub] [, lb, A, ub] [, lb, 'g', ub])\n\n\ |
|
|
413 Groups of arguments surrounded in `[]' are optional, but\n\ |
|
|
414 must appear in the same relative order shown above.\n\ |
|
|
415 \n\ |
|
|
416 The second argument is a string containing the name of the objective\n\ |
|
|
417 function to call. The objective function must be of the form\n\ |
|
|
418 \n\ |
|
|
419 y = phi (x)\n\ |
|
|
420 \n\ |
|
|
421 where x is a vector and y is a scalar.\n\n", }, |
|
|
422 |
|
|
423 { "ones", 3, 1, builtin_ones, |
|
|
424 "create a matrix of all ones\n", }, |
|
|
425 |
|
|
426 { "pause", 1, 0, builtin_pause, |
|
|
427 "suspend program execution\n", }, |
|
|
428 |
|
|
429 { "purge_tmp_files", 5, 1, builtin_purge_tmp_files, |
|
|
430 "delete temporary data files used for plotting\n", }, |
|
|
431 |
|
|
432 { "printf", -1, 1, builtin_printf, |
|
|
433 "printf ('fmt', ...)\n", }, |
|
|
434 |
|
|
435 { "prod", 2, 1, builtin_prod, |
|
|
436 "prod (X): products\n", }, |
|
|
437 |
|
|
438 { "pwd", 1, 0, builtin_pwd, |
|
|
439 "print current working directory\n", }, |
|
|
440 |
|
|
441 { "qpsol", 9, 3, builtin_qpsol, |
|
|
442 "Solve nonlinear programs using Gill and Murray's QPSOL. Usage:\n\ |
|
|
443 \n\ |
|
|
444 [x, obj, info, lambda] = qpsol (x, H, c [, lb, ub] [, lb, A, ub])\n\ |
|
|
445 \n\ |
|
|
446 Groups of arguments surrounded in `[]' are optional, but\n\ |
|
|
447 must appear in the same relative order shown above.", }, |
|
|
448 |
|
|
449 { "qr", 2, 2, builtin_qr, |
|
|
450 "[q, r] = qr (X): form QR factorization of X\n", }, |
|
|
451 |
|
|
452 { "quad", 6, 3, builtin_quad, |
|
|
453 "Integrate a nonlinear function of one variable using Quadpack.\n\ |
|
|
454 Usage:\n\ |
|
|
455 \n\ |
|
|
456 [v, ier, nfun] = quad ('f', a, b [, tol] [, sing])\n\ |
|
|
457 \n\ |
|
|
458 Where the first argument is the name of the function to call to\n\ |
|
|
459 compute the value of the integrand. It must have the form\n\ |
|
|
460 \n\ |
|
|
461 y = f (x) |
|
|
462 \n\ |
|
|
463 where y and x are scalars.\n\ |
|
|
464 \n\ |
|
|
465 The second and third arguments are limits of integration. Either or\n\ |
|
|
466 both may be infinite. The optional argument tol specifies the desired\n\ |
|
|
467 accuracy of the result. The optional argument sing is a vector of\n\ |
|
|
468 at which the integrand is singular.\n\n", }, |
|
|
469 |
|
|
470 { "quit", 1, 0, builtin_quit, |
|
|
471 "exit Octave gracefully\n", }, |
|
|
472 |
|
45
|
473 { "qzval", 3, 1, builtin_qzval, |
|
81
|
474 "x = qzval(a,b): compute generalized eigenvalues\n", }, |
|
45
|
475 |
|
1
|
476 { "rand", 2, 1, builtin_rand, |
|
|
477 "matrices with random elements\n", }, |
|
|
478 |
|
|
479 { "replot", 1, 0, builtin_replot, |
|
|
480 "redisplay current plot\n", }, |
|
|
481 |
|
|
482 { "scanf", 2, -1, builtin_scanf, |
|
|
483 "[a,b,c...] = scanf ('fmt')\n", }, |
|
|
484 |
|
|
485 { "setstr", 2, 1, builtin_setstr, |
|
|
486 "setstr (v): convert a vector to a string\n", }, |
|
|
487 |
|
|
488 { "shell_cmd", 2, 1, builtin_shell_command, |
|
|
489 "shell_cmd (string [, return_output]): execute shell commands\n", }, |
|
|
490 |
|
|
491 { "schur", 3, 2, builtin_schur, |
|
|
492 "returns the Schur (straight or ordered) decomposition of matrix\n", }, |
|
|
493 |
|
|
494 { "size", 2, 1, builtin_size, |
|
|
495 "size(X): return rows and columns of X\n", }, |
|
|
496 |
|
|
497 { "sort", 2, 2, builtin_sort, |
|
|
498 "[s,i] = sort(x): sort the columns of x, optionally return sort index\n", }, |
|
|
499 |
|
|
500 { "sqrtm", 2, 1, builtin_sqrtm, |
|
|
501 "Matrix sqrt, sqrt (A)\n", }, |
|
|
502 |
|
|
503 { "sprintf", -1, 1, builtin_sprintf, |
|
|
504 "s = sprintf ('fmt', ...)\n", }, |
|
|
505 |
|
|
506 { "sscanf", 3, -1, builtin_sscanf, |
|
|
507 "[a,b,c...] = sscanf (string, 'fmt')\n", }, |
|
|
508 |
|
|
509 { "sum", 2, 1, builtin_sum, |
|
|
510 "sum (X): sum of elements\n", }, |
|
|
511 |
|
|
512 { "sumsq", 2, 1, builtin_sumsq, |
|
|
513 "sumsq (X): sum of squares of elements\n", }, |
|
|
514 |
|
|
515 { "svd", 2, 3, builtin_svd, |
|
|
516 "[U,S,V] = svd(X): return SVD of X\n", }, |
|
|
517 |
|
38
|
518 { "syl", 4, 1, builtin_syl, |
|
|
519 "X = syl (A, B, C): solve the Sylvester equation A X + X B + C = 0\n", }, |
|
|
520 |
|
1
|
521 { "warranty", 1, 0, builtin_warranty, |
|
|
522 "describe copying conditions\n", }, |
|
|
523 |
|
|
524 { "zeros", 3, 1, builtin_zeros, |
|
|
525 "create a matrix of all zeros\n", }, |
|
|
526 |
|
|
527 { NULL, -1, -1, NULL, NULL, }, |
|
|
528 }; |
|
|
529 |
|
|
530 // This is a lie. Some of these get reassigned to be numeric |
|
|
531 // variables. See below. |
|
|
532 |
|
|
533 static builtin_string_variables string_variables[] = |
|
|
534 { |
|
|
535 { "I", "??", NULL, |
|
|
536 "sqrt (-1)\n", }, |
|
|
537 |
|
|
538 { "Inf", "??", NULL, |
|
|
539 "infinity\n", }, |
|
|
540 |
|
|
541 { "J", "??", NULL, |
|
|
542 "sqrt (-1)\n", }, |
|
|
543 |
|
|
544 #if defined (HAVE_ISNAN) |
|
|
545 { "NaN", "??", NULL, |
|
|
546 "not a number\n", }, |
|
|
547 #endif |
|
|
548 |
|
|
549 { "LOADPATH", "??", sv_loadpath, |
|
|
550 "colon separated list of directories to search for scripts\n", }, |
|
|
551 |
|
|
552 { "PAGER", "??", sv_pager_binary, |
|
|
553 "path to pager binary\n", }, |
|
|
554 |
|
|
555 { "PS1", "\\s:\\#> ", sv_ps1, |
|
|
556 "primary prompt string\n", }, |
|
|
557 |
|
|
558 { "PS2", "> ", sv_ps2, |
|
|
559 "secondary prompt string\n", }, |
|
|
560 |
|
|
561 { "PWD", "??PWD??", sv_pwd, |
|
|
562 "current working directory\n", }, |
|
|
563 |
|
|
564 { "SEEK_SET", "??", NULL, |
|
|
565 "used with fseek to position file relative to the beginning\n", }, |
|
|
566 |
|
|
567 { "SEEK_CUR", "??", NULL, |
|
|
568 "used with fseek to position file relative to the current position\n", }, |
|
|
569 |
|
|
570 { "SEEK_END", "??", NULL, |
|
|
571 "used with fseek to position file relative to the end\n", }, |
|
|
572 |
|
|
573 { "do_fortran_indexing", "false", do_fortran_indexing, |
|
|
574 "allow single indices for matrices\n", }, |
|
|
575 |
|
|
576 { "empty_list_elements_ok", "warn", empty_list_elements_ok, |
|
|
577 "ignore the empty element in expressions like `a = [[], 1]'\n", }, |
|
|
578 |
|
|
579 { "eps", "??", NULL, |
|
|
580 "machine precision\n", }, |
|
|
581 |
|
|
582 { "gnuplot_binary", "gnuplot", sv_gnuplot_binary, |
|
|
583 "path to gnuplot binary\n", }, |
|
|
584 |
|
|
585 { "i", "??", NULL, |
|
|
586 "sqrt (-1)\n", }, |
|
|
587 |
|
|
588 { "implicit_str_to_num_ok", "false", implicit_str_to_num_ok, |
|
|
589 "allow implicit string to number conversion\n", }, |
|
|
590 |
|
|
591 { "inf", "??", NULL, |
|
|
592 "infinity\n", }, |
|
|
593 |
|
|
594 { "j", "??", NULL, |
|
|
595 "sqrt (-1)\n", }, |
|
|
596 |
|
|
597 #if defined (HAVE_ISNAN) |
|
|
598 { "nan", "??", NULL, |
|
|
599 "not a number\n", }, |
|
|
600 #endif |
|
|
601 |
|
|
602 { "ok_to_lose_imaginary_part", "warn", ok_to_lose_imaginary_part, |
|
|
603 "silently convert from complex to real by dropping imaginary part\n", }, |
|
|
604 |
|
|
605 { "output_max_field_width", "??", set_output_max_field_width, |
|
|
606 "maximum width of an output field for numeric output\n", }, |
|
|
607 |
|
|
608 { "output_precision", "??", set_output_precision, |
|
|
609 "number of significant figures to display for numeric output\n", }, |
|
|
610 |
|
|
611 { "page_screen_output", "true", page_screen_output, |
|
|
612 "if possible, send output intended for the screen through the pager\n", }, |
|
|
613 |
|
|
614 { "pi", "??", NULL, |
|
|
615 "ratio of the circumference of a circle to its diameter\n", }, |
|
|
616 |
|
|
617 { "prefer_column_vectors", "true", prefer_column_vectors, |
|
|
618 "prefer column/row vectors\n", }, |
|
|
619 |
|
|
620 { "prefer_zero_one_indexing", "false", prefer_zero_one_indexing, |
|
|
621 "when there is a conflict, prefer zero-one style indexing\n", }, |
|
|
622 |
|
|
623 { "print_answer_id_name", "true", print_answer_id_name, |
|
|
624 "set output style to print `var_name = ...'\n", }, |
|
|
625 |
|
|
626 { "print_empty_dimensions", "true", print_empty_dimensions, |
|
|
627 "also print dimensions of empty matrices\n", }, |
|
|
628 |
|
|
629 { "propagate_empty_matrices", "true", propagate_empty_matrices, |
|
|
630 "operations on empty matrices return an empty matrix, not an error\n", }, |
|
|
631 |
|
|
632 { "resize_on_range_error", "true", resize_on_range_error, |
|
|
633 "enlarge matrices on assignment\n", }, |
|
|
634 |
|
|
635 { "return_last_computed_value", "false", return_last_computed_value, |
|
|
636 "if a function does not return any values explicitly, return the\n\ |
|
|
637 last computed value\n", }, |
|
|
638 |
|
|
639 { "silent_functions", "false", silent_functions, |
|
|
640 "suppress printing results in called functions\n", }, |
|
|
641 |
|
|
642 { "split_long_rows", "true", split_long_rows, |
|
|
643 "split long matrix rows instead of wrapping\n", }, |
|
|
644 |
|
|
645 { "stdin", "??", NULL, |
|
|
646 "file number of the standard input stream\n", }, |
|
|
647 |
|
|
648 { "stdout", "??", NULL, |
|
|
649 "file number of the standard output stream\n", }, |
|
|
650 |
|
|
651 { "stderr", "??", NULL, |
|
|
652 "file number of the standard error stream\n", }, |
|
|
653 |
|
|
654 { "treat_neg_dim_as_zero", "false", treat_neg_dim_as_zero, |
|
|
655 "convert negative dimensions to zero\n", }, |
|
|
656 |
|
|
657 { "warn_assign_as_truth_value", "true", warn_assign_as_truth_value, |
|
|
658 "produce warning for assignments used as truth values\n", }, |
|
|
659 |
|
|
660 { "warn_comma_in_global_decl", "true", warn_comma_in_global_decl, |
|
|
661 "produce warning for commas in global declarations\n", }, |
|
|
662 |
|
|
663 { "warn_divide_by_zero", "true", warn_divide_by_zero, |
|
|
664 "on IEEE machines, allow divide by zero errors to be suppressed\n", }, |
|
|
665 |
|
|
666 { NULL, NULL, NULL, NULL, }, |
|
|
667 }; |
|
|
668 |
|
|
669 void |
|
|
670 make_eternal (char *s) |
|
|
671 { |
|
|
672 symbol_record *sym_rec = curr_sym_tab->lookup (s, 0, 0); |
|
|
673 if (sym_rec != (symbol_record *) NULL) |
|
|
674 sym_rec->make_eternal (); |
|
|
675 } |
|
|
676 |
|
|
677 void |
|
|
678 install_builtins (void) |
|
|
679 { |
|
|
680 symbol_record *sym_rec; |
|
|
681 |
|
|
682 tree_builtin *tb_tmp; |
|
|
683 |
|
|
684 // So that the clear function can't delete other builtin variables and |
|
|
685 // functions, they are given eternal life. |
|
|
686 |
|
|
687 builtin_mapper_functions *mfptr = mapper_functions; |
|
|
688 while (mfptr->name != (char *) NULL) |
|
|
689 { |
|
|
690 sym_rec = curr_sym_tab->lookup (mfptr->name, 1); |
|
|
691 sym_rec->unprotect (); |
|
|
692 |
|
|
693 Mapper_fcn mfcn; |
|
|
694 mfcn.neg_arg_complex = mfptr->neg_arg_complex; |
|
|
695 mfcn.d_d_mapper = mfptr->d_d_mapper; |
|
|
696 mfcn.d_c_mapper = mfptr->d_c_mapper; |
|
|
697 mfcn.c_c_mapper = mfptr->c_c_mapper; |
|
|
698 |
|
|
699 tb_tmp = new tree_builtin (mfptr->nargin_max, mfptr->nargout_max, |
|
|
700 mfcn, sym_rec); |
|
|
701 |
|
|
702 sym_rec->define (tb_tmp); |
|
|
703 sym_rec->document (mfptr->help_string); |
|
|
704 sym_rec->make_eternal (); |
|
|
705 sym_rec->protect (); |
|
|
706 mfptr++; |
|
|
707 } |
|
|
708 |
|
|
709 builtin_text_functions *tfptr = text_functions; |
|
|
710 while (tfptr->name != (char *) NULL) |
|
|
711 { |
|
|
712 sym_rec = curr_sym_tab->lookup (tfptr->name, 1); |
|
|
713 sym_rec->unprotect (); |
|
|
714 |
|
|
715 tb_tmp = new tree_builtin (tfptr->nargin_max, 1, |
|
|
716 tfptr->text_fcn, sym_rec); |
|
|
717 |
|
|
718 sym_rec->define (tb_tmp); |
|
|
719 sym_rec->document (tfptr->help_string); |
|
|
720 sym_rec->make_eternal (); |
|
|
721 sym_rec->protect (); |
|
|
722 tfptr++; |
|
|
723 } |
|
|
724 |
|
|
725 builtin_general_functions *gfptr = general_functions; |
|
|
726 while (gfptr->name != (char *) NULL) |
|
|
727 { |
|
|
728 sym_rec = curr_sym_tab->lookup (gfptr->name, 1); |
|
|
729 sym_rec->unprotect (); |
|
|
730 |
|
|
731 tb_tmp = new tree_builtin (gfptr->nargin_max, gfptr->nargout_max, |
|
|
732 gfptr->general_fcn, sym_rec); |
|
|
733 |
|
|
734 sym_rec->define (tb_tmp); |
|
|
735 sym_rec->document (gfptr->help_string); |
|
|
736 sym_rec->make_eternal (); |
|
|
737 sym_rec->protect (); |
|
|
738 gfptr++; |
|
|
739 } |
|
|
740 |
|
|
741 // Most built-in variables are not protected because the user should |
|
|
742 // be able to redefine them. |
|
|
743 |
|
|
744 builtin_string_variables *svptr = string_variables; |
|
|
745 while (svptr->name != (char *) NULL) |
|
|
746 { |
|
|
747 sym_rec = curr_sym_tab->lookup (svptr->name, 1); |
|
|
748 sym_rec->unprotect (); |
|
|
749 |
|
|
750 tree_constant *tmp = new tree_constant (svptr->value); |
|
|
751 |
|
|
752 sym_rec->set_sv_function (svptr->sv_function); |
|
|
753 sym_rec->define (tmp); |
|
|
754 sym_rec->document (svptr->help_string); |
|
|
755 sym_rec->make_eternal (); |
|
|
756 svptr++; |
|
|
757 } |
|
|
758 |
|
|
759 // XXX FIXME XXX -- Need a convenient way to document these variables. |
|
|
760 |
|
|
761 // IMPORTANT: Always create a new tree_constant for each variable. |
|
|
762 |
|
|
763 tree_constant *tmp = NULL_TREE_CONST; |
|
|
764 bind_variable ("ans", tmp); |
|
|
765 |
|
|
766 Complex ctmp (0.0, 1.0); |
|
|
767 tmp = new tree_constant (ctmp); |
|
|
768 bind_protected_variable ("I", tmp); |
|
|
769 make_eternal ("I"); |
|
|
770 |
|
|
771 tmp = new tree_constant (ctmp); |
|
|
772 bind_protected_variable ("J", tmp); |
|
|
773 make_eternal ("J"); |
|
|
774 |
|
|
775 // Let i and j be functions so they can be redefined without being |
|
|
776 // wiped out. |
|
|
777 |
|
|
778 char *tmp_help; |
|
|
779 |
|
|
780 tmp = new tree_constant (ctmp); |
|
|
781 sym_rec = curr_sym_tab->lookup ("i", 1); |
|
|
782 tmp_help = sym_rec->help (); |
|
|
783 sym_rec->define_as_fcn (tmp); |
|
|
784 sym_rec->document (tmp_help); |
|
|
785 sym_rec->protect (); |
|
|
786 sym_rec->make_eternal (); |
|
|
787 |
|
|
788 tmp = new tree_constant (ctmp); |
|
|
789 sym_rec = curr_sym_tab->lookup ("j", 1); |
|
|
790 tmp_help = sym_rec->help (); |
|
|
791 sym_rec->define_as_fcn (tmp); |
|
|
792 sym_rec->document (tmp_help); |
|
|
793 sym_rec->protect (); |
|
|
794 sym_rec->make_eternal (); |
|
|
795 |
|
|
796 tmp = new tree_constant (get_working_directory ("initialize_globals")); |
|
|
797 bind_protected_variable ("PWD", tmp); |
|
|
798 make_eternal ("PWD"); |
|
|
799 |
|
|
800 tmp = new tree_constant (load_path); |
|
|
801 bind_variable ("LOADPATH", tmp); |
|
|
802 make_eternal ("LOADPATH"); |
|
|
803 |
|
|
804 tmp = new tree_constant (default_pager ()); |
|
|
805 bind_variable ("PAGER", tmp); |
|
|
806 make_eternal ("PAGER"); |
|
|
807 |
|
|
808 tmp = new tree_constant (0.0); |
|
|
809 bind_variable ("SEEK_SET", tmp); |
|
|
810 make_eternal ("SEEK_SET"); |
|
|
811 |
|
|
812 tmp = new tree_constant (1.0); |
|
|
813 bind_variable ("SEEK_CUR", tmp); |
|
|
814 make_eternal ("SEEK_CUR"); |
|
|
815 |
|
|
816 tmp = new tree_constant (2.0); |
|
|
817 bind_variable ("SEEK_END", tmp); |
|
|
818 make_eternal ("SEEK_END"); |
|
|
819 |
|
|
820 tmp = new tree_constant (DBL_EPSILON); |
|
|
821 bind_protected_variable ("eps", tmp); |
|
|
822 make_eternal ("eps"); |
|
|
823 |
|
|
824 tmp = new tree_constant (10.0); |
|
|
825 bind_variable ("output_max_field_width", tmp); |
|
|
826 make_eternal ("output_max_field_width"); |
|
|
827 |
|
|
828 tmp = new tree_constant (5.0); |
|
|
829 bind_variable ("output_precision", tmp); |
|
|
830 make_eternal ("output_precision"); |
|
|
831 |
|
|
832 tmp = new tree_constant (4.0 * atan (1.0)); |
|
|
833 bind_protected_variable ("pi", tmp); |
|
|
834 make_eternal ("pi"); |
|
|
835 |
|
|
836 tmp = new tree_constant (0.0); |
|
|
837 bind_protected_variable ("stdin", tmp); |
|
|
838 make_eternal ("stdin"); |
|
|
839 |
|
|
840 tmp = new tree_constant (1.0); |
|
|
841 bind_protected_variable ("stdout", tmp); |
|
|
842 make_eternal ("stdout"); |
|
|
843 |
|
|
844 tmp = new tree_constant (2.0); |
|
|
845 bind_protected_variable ("stderr", tmp); |
|
|
846 make_eternal ("stderr"); |
|
|
847 |
|
|
848 #if defined (HAVE_ISINF) || defined (HAVE_FINITE) |
|
|
849 #ifdef linux |
|
|
850 tmp = new tree_constant (HUGE_VAL); |
|
|
851 #else |
|
|
852 tmp = new tree_constant (1.0/0.0); |
|
|
853 #endif |
|
|
854 bind_protected_variable ("Inf", tmp); |
|
|
855 make_eternal ("Inf"); |
|
|
856 |
|
|
857 #ifdef linux |
|
|
858 tmp = new tree_constant (HUGE_VAL); |
|
|
859 #else |
|
|
860 tmp = new tree_constant (1.0/0.0); |
|
|
861 #endif |
|
|
862 bind_protected_variable ("inf", tmp); |
|
|
863 make_eternal ("inf"); |
|
|
864 |
|
|
865 #else |
|
|
866 |
|
|
867 // This is sort of cheesy, but what can we do, other than blowing it |
|
|
868 // off completely, or writing an entire IEEE emulation package? |
|
|
869 |
|
|
870 tmp = new tree_constant (DBL_MAX); |
|
|
871 bind_protected_variable ("Inf", tmp); |
|
|
872 make_eternal ("Inf"); |
|
|
873 |
|
|
874 tmp = new tree_constant (DBL_MAX); |
|
|
875 bind_protected_variable ("inf", tmp); |
|
|
876 make_eternal ("inf"); |
|
|
877 #endif |
|
|
878 |
|
|
879 #if defined (HAVE_ISNAN) |
|
|
880 #ifdef linux |
|
|
881 tmp = new tree_constant (NAN); |
|
|
882 #else |
|
|
883 tmp = new tree_constant (0.0/0.0); |
|
|
884 #endif |
|
|
885 bind_protected_variable ("NaN", tmp); |
|
|
886 make_eternal ("NaN"); |
|
|
887 |
|
|
888 #ifdef linux |
|
|
889 tmp = new tree_constant (NAN); |
|
|
890 #else |
|
|
891 tmp = new tree_constant (0.0/0.0); |
|
|
892 #endif |
|
|
893 bind_protected_variable ("nan", tmp); |
|
|
894 make_eternal ("nan"); |
|
|
895 #endif |
|
|
896 } |
|
|
897 |
|
|
898 int |
|
|
899 is_text_function_name (char *s) |
|
|
900 { |
|
|
901 int retval = 0; |
|
|
902 |
|
|
903 builtin_text_functions *tfptr = text_functions; |
|
|
904 while (tfptr->name != (char *) NULL) |
|
|
905 { |
|
|
906 if (strcmp (tfptr->name, s) == 0) |
|
|
907 { |
|
|
908 retval = 1; |
|
|
909 break; |
|
|
910 } |
|
|
911 tfptr++; |
|
|
912 } |
|
|
913 |
|
|
914 return retval; |
|
|
915 } |
|
|
916 |
|
|
917 help_list * |
|
|
918 builtin_mapper_functions_help (void) |
|
|
919 { |
|
|
920 int count = 0; |
|
|
921 builtin_mapper_functions *mfptr; |
|
|
922 |
|
|
923 mfptr = mapper_functions; |
|
|
924 while (mfptr->name != (char *) NULL) |
|
|
925 { |
|
|
926 count++; |
|
|
927 mfptr++; |
|
|
928 } |
|
|
929 |
|
|
930 if (count == 0) |
|
|
931 return (help_list *) NULL; |
|
|
932 |
|
|
933 help_list *hl = new help_list [count+1]; |
|
|
934 |
|
|
935 int i = 0; |
|
|
936 mfptr = mapper_functions; |
|
|
937 while (mfptr->name != (char *) NULL) |
|
|
938 { |
|
|
939 hl[i].name = mfptr->name; |
|
|
940 hl[i].help = mfptr->help_string; |
|
|
941 i++; |
|
|
942 mfptr++; |
|
|
943 } |
|
|
944 |
|
|
945 hl[count].name = (char *) NULL; |
|
|
946 hl[count].help = (char *) NULL; |
|
|
947 |
|
|
948 return hl; |
|
|
949 } |
|
|
950 |
|
|
951 help_list * |
|
|
952 builtin_general_functions_help (void) |
|
|
953 { |
|
|
954 int count = 0; |
|
|
955 builtin_general_functions *gfptr; |
|
|
956 |
|
|
957 gfptr = general_functions; |
|
|
958 while (gfptr->name != (char *) NULL) |
|
|
959 { |
|
|
960 count++; |
|
|
961 gfptr++; |
|
|
962 } |
|
|
963 |
|
|
964 if (count == 0) |
|
|
965 return (help_list *) NULL; |
|
|
966 |
|
|
967 help_list *hl = new help_list [count+1]; |
|
|
968 |
|
|
969 int i = 0; |
|
|
970 gfptr = general_functions; |
|
|
971 while (gfptr->name != (char *) NULL) |
|
|
972 { |
|
|
973 hl[i].name = gfptr->name; |
|
|
974 hl[i].help = gfptr->help_string; |
|
|
975 i++; |
|
|
976 gfptr++; |
|
|
977 } |
|
|
978 |
|
|
979 hl[count].name = (char *) NULL; |
|
|
980 hl[count].help = (char *) NULL; |
|
|
981 |
|
|
982 return hl; |
|
|
983 } |
|
|
984 |
|
|
985 help_list * |
|
|
986 builtin_text_functions_help (void) |
|
|
987 { |
|
|
988 int count = 0; |
|
|
989 builtin_text_functions *tfptr; |
|
|
990 |
|
|
991 tfptr = text_functions; |
|
|
992 while (tfptr->name != (char *) NULL) |
|
|
993 { |
|
|
994 count++; |
|
|
995 tfptr++; |
|
|
996 } |
|
|
997 |
|
|
998 if (count == 0) |
|
|
999 return (help_list *) NULL; |
|
|
1000 |
|
|
1001 help_list *hl = new help_list [count+1]; |
|
|
1002 |
|
|
1003 int i = 0; |
|
|
1004 tfptr = text_functions; |
|
|
1005 while (tfptr->name != (char *) NULL) |
|
|
1006 { |
|
|
1007 hl[i].name = tfptr->name; |
|
|
1008 hl[i].help = tfptr->help_string; |
|
|
1009 i++; |
|
|
1010 tfptr++; |
|
|
1011 } |
|
|
1012 |
|
|
1013 hl[count].name = (char *) NULL; |
|
|
1014 hl[count].help = (char *) NULL; |
|
|
1015 |
|
|
1016 return hl; |
|
|
1017 } |
|
|
1018 |
|
|
1019 help_list * |
|
|
1020 builtin_variables_help (void) |
|
|
1021 { |
|
|
1022 int count = 0; |
|
|
1023 builtin_string_variables *svptr; |
|
|
1024 |
|
|
1025 svptr = string_variables; |
|
|
1026 while (svptr->name != (char *) NULL) |
|
|
1027 { |
|
|
1028 count++; |
|
|
1029 svptr++; |
|
|
1030 } |
|
|
1031 |
|
|
1032 if (count == 0) |
|
|
1033 return (help_list *) NULL; |
|
|
1034 |
|
|
1035 help_list *hl = new help_list [count+1]; |
|
|
1036 |
|
|
1037 int i = 0; |
|
|
1038 svptr = string_variables; |
|
|
1039 while (svptr->name != (char *) NULL) |
|
|
1040 { |
|
|
1041 hl[i].name = svptr->name; |
|
|
1042 hl[i].help = svptr->help_string; |
|
|
1043 i++; |
|
|
1044 svptr++; |
|
|
1045 } |
|
|
1046 |
|
|
1047 hl[count].name = (char *) NULL; |
|
|
1048 hl[count].help = (char *) NULL; |
|
|
1049 |
|
|
1050 return hl; |
|
|
1051 } |
|
|
1052 |
|
|
1053 /* |
|
|
1054 ;;; Local Variables: *** |
|
|
1055 ;;; mode: C++ *** |
|
|
1056 ;;; page-delimiter: "^/\\*" *** |
|
|
1057 ;;; End: *** |
|
|
1058 */ |
