|
5164
|
1 /* |
|
|
2 |
|
|
3 Copyright (C) 2001 John W. Eaton and Paul Kienzle |
|
|
4 |
|
|
5 This program is free software; you can redistribute it and/or modify it |
|
|
6 under the terms of the GNU General Public License as published by the |
|
|
7 Free Software Foundation; either version 2, or (at your option) any |
|
|
8 later version. |
|
|
9 |
|
|
10 This program is distributed in the hope that it will be useful, but WITHOUT |
|
|
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
13 for more details. |
|
|
14 |
|
|
15 You should have received a copy of the GNU General Public License |
|
|
16 along with Octave; see the file COPYING. If not, write to the Free |
|
5307
|
17 Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
|
|
18 02110-1301, USA. |
|
5164
|
19 |
|
|
20 */ |
|
|
21 |
|
|
22 #ifdef HAVE_CONFIG_H |
|
|
23 #include <config.h> |
|
|
24 #endif |
|
|
25 |
|
|
26 #include <list> |
|
|
27 #include <map> |
|
|
28 #include <string> |
|
|
29 |
|
|
30 #include "defun-dld.h" |
|
|
31 #include "ov.h" |
|
|
32 #include "ov-fcn.h" |
|
|
33 #include "ov-typeinfo.h" |
|
|
34 #include "pager.h" |
|
|
35 #include "parse.h" |
|
|
36 #include "symtab.h" |
|
|
37 #include "variables.h" |
|
|
38 |
|
5775
|
39 // FIXME should be using a map from type_id->name, rather |
|
5164
|
40 // than type_name->name |
|
|
41 |
|
|
42 template class std::map<std::string,std::string>; |
|
|
43 |
|
|
44 typedef std::map<std::string,std::string> Table; |
|
|
45 |
|
|
46 class |
|
|
47 octave_dispatch : public octave_function |
|
|
48 { |
|
|
49 public: |
|
|
50 |
|
5775
|
51 // FIXME need to handle doc strings of dispatched functions, for |
|
5164
|
52 // example, by appending "for <f>(<type>,...) see <name>" for each |
|
|
53 // time dispatch(f,type,name) is called. |
|
|
54 octave_dispatch (const std::string &nm) |
|
|
55 : octave_function (nm, "Overloaded function"), tab (), base (nm), |
|
|
56 has_alias (false) |
|
|
57 { } |
|
|
58 |
|
5775
|
59 // FIXME if we get deleted, we should restore the original |
|
5164
|
60 // symbol_record from base before dying. |
|
|
61 ~octave_dispatch (void) { } |
|
|
62 |
|
|
63 bool is_builtin_function (void) const { return true; } |
|
|
64 |
|
|
65 octave_function *function_value (bool) { return this; } |
|
|
66 |
|
|
67 octave_value do_index_op (const octave_value_list&, int) |
|
|
68 { |
|
|
69 error ("dispatch: do_index_op"); |
|
|
70 return octave_value (); |
|
|
71 } |
|
|
72 |
|
|
73 octave_value subsref (const std::string&, |
|
|
74 const std::list<octave_value_list>&) |
|
|
75 { |
|
|
76 error ("dispatch: subsref (str, list)"); |
|
|
77 panic_impossible (); |
|
|
78 return octave_value (); |
|
|
79 } |
|
|
80 |
|
|
81 octave_value_list subsref (const std::string& type, |
|
|
82 const std::list<octave_value_list>& idx, |
|
|
83 int nargout); |
|
|
84 |
|
|
85 octave_value_list do_multi_index_op (int, const octave_value_list&); |
|
|
86 |
|
|
87 void add (const std::string t, const std::string n); |
|
|
88 |
|
|
89 void clear (const std::string t); |
|
|
90 |
|
|
91 void print (std::ostream& os, bool pr_as_read=false) const; |
|
|
92 |
|
|
93 private: |
|
|
94 |
|
|
95 Table tab; |
|
|
96 std::string base; |
|
|
97 bool has_alias; |
|
|
98 |
|
|
99 octave_dispatch (void) |
|
|
100 : octave_function (), tab (), base (), has_alias (false) { } |
|
|
101 |
|
|
102 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA |
|
|
103 |
|
|
104 DECLARE_OCTAVE_ALLOCATOR |
|
|
105 }; |
|
|
106 |
|
|
107 DEFINE_OCTAVE_ALLOCATOR (octave_dispatch); |
|
|
108 |
|
|
109 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_dispatch, |
|
|
110 "overloaded function", "function"); |
|
|
111 |
|
|
112 void |
|
|
113 octave_dispatch::add (const std::string t, const std::string n) |
|
|
114 { |
|
|
115 if (tab.count (t) > 0 && tab[t] != n) |
|
|
116 warning ("replacing %s(%s,...)->%s with %s", |
|
|
117 base.c_str (), t.c_str (), tab[t].c_str (), n.c_str ()); |
|
|
118 |
|
|
119 tab[t] = n; |
|
|
120 |
|
|
121 if (t == "any") |
|
|
122 has_alias = true; |
|
|
123 } |
|
|
124 |
|
|
125 void |
|
|
126 octave_dispatch::clear (const std::string t) |
|
|
127 { |
|
|
128 tab.erase (t); |
|
|
129 |
|
|
130 if (t == "any") |
|
|
131 has_alias = false; |
|
|
132 } |
|
|
133 |
|
|
134 octave_value_list |
|
|
135 octave_dispatch::subsref (const std::string& type, |
|
|
136 const std::list<octave_value_list>& idx, |
|
|
137 int nargout) |
|
|
138 { |
|
|
139 octave_value_list retval; |
|
|
140 |
|
|
141 switch (type[0]) |
|
|
142 { |
|
|
143 case '(': |
|
|
144 retval = do_multi_index_op (nargout, idx.front ()); |
|
|
145 break; |
|
|
146 |
|
|
147 case '{': |
|
|
148 case '.': |
|
|
149 { |
|
|
150 const std::string nm = type_name (); |
|
|
151 error ("%s cannot be indexed with %c", nm.c_str (), type[0]); |
|
|
152 } |
|
|
153 break; |
|
|
154 |
|
|
155 default: |
|
|
156 panic_impossible (); |
|
|
157 } |
|
|
158 |
|
|
159 if (idx.size () > 1) |
|
|
160 retval = retval(0).next_subsref (type, idx); |
|
|
161 |
|
|
162 return retval; |
|
|
163 } |
|
|
164 |
|
|
165 static octave_function* |
|
|
166 builtin (const std::string& base) |
|
|
167 { |
|
|
168 octave_function *fcn = 0; |
|
|
169 |
|
|
170 // Check if we are overriding a builtin function. This is the |
|
|
171 // case if builtin is protected. |
|
|
172 symbol_record *builtin = fbi_sym_tab->lookup ("builtin:" + base, 0); |
|
|
173 |
|
|
174 if (! builtin) |
|
|
175 error ("builtin record has gone missing"); |
|
|
176 |
|
|
177 if (error_state) |
|
|
178 return fcn; |
|
|
179 |
|
|
180 if (builtin->is_read_only ()) |
|
|
181 { |
|
|
182 // builtin is read only, so checking for updates is pointless |
|
|
183 if (builtin->is_function ()) |
|
|
184 fcn = builtin->def().function_value (); |
|
|
185 else |
|
|
186 error ("builtin %s is not a function", base.c_str ()); |
|
|
187 } |
|
|
188 else |
|
|
189 { |
|
|
190 // Check that builtin is up to date. |
|
|
191 |
|
|
192 // Don't try to fight octave's function name handling |
|
|
193 // mechanism. Instead, move dispatch record out of the way, |
|
|
194 // and restore the builtin to its original name. |
|
|
195 symbol_record *dispatch = fbi_sym_tab->lookup (base, 0); |
|
|
196 if (! dispatch) |
|
|
197 error ("dispatch record has gone missing"); |
|
|
198 |
|
|
199 dispatch->unprotect (); |
|
|
200 |
|
|
201 fbi_sym_tab->rename (base, "dispatch:" + base); |
|
|
202 |
|
|
203 fbi_sym_tab->rename ("builtin:" + base, base); |
|
|
204 |
|
|
205 // check for updates to builtin function; ignore errors that |
|
|
206 // appear (they interfere with renaming), and remove the updated |
|
5775
|
207 // name from the current symbol table. FIXME check that |
|
5164
|
208 // updating a function updates it in all contexts --- it may be |
|
|
209 // that it is updated only in the current symbol table, and not |
|
|
210 // the caller. I believe this won't be a problem because the |
|
|
211 // caller will go through the same logic and end up with the |
|
|
212 // newer version. |
|
|
213 fcn = is_valid_function (base, "dispatch", 1); |
|
|
214 int cache_error = error_state; |
|
|
215 error_state = 0; |
|
|
216 curr_sym_tab->clear_function (base); |
|
|
217 |
|
|
218 // Move the builtin function out of the way and restore the |
|
|
219 // dispatch fuction. |
|
5775
|
220 // FIXME what if builtin wants to protect itself? |
|
5399
|
221 symbol_record *found = fbi_sym_tab->lookup (base, 0); |
|
5164
|
222 bool readonly = found->is_read_only (); |
|
|
223 found->unprotect (); |
|
|
224 fbi_sym_tab->rename (base, "builtin:" + base); |
|
|
225 fbi_sym_tab->rename ("dispatch:" + base, base); |
|
|
226 if (readonly) |
|
|
227 found->protect (); |
|
|
228 dispatch->protect (); |
|
|
229 |
|
|
230 // remember if there were any errors. |
|
|
231 error_state = cache_error; |
|
|
232 } |
|
|
233 |
|
|
234 return fcn; |
|
|
235 } |
|
|
236 |
|
|
237 static bool |
|
|
238 any_arg_is_magic_colon (const octave_value_list& args) |
|
|
239 { |
|
|
240 int nargin = args.length (); |
|
|
241 |
|
|
242 for (int i = 0; i < nargin; i++) |
|
|
243 if (args(i).is_magic_colon ()) |
|
|
244 return true; |
|
|
245 |
|
|
246 return false; |
|
|
247 } |
|
|
248 |
|
|
249 octave_value_list |
|
|
250 octave_dispatch::do_multi_index_op (int nargout, const octave_value_list& args) |
|
|
251 { |
|
|
252 octave_value_list retval; |
|
|
253 |
|
|
254 if (error_state) return retval; |
|
|
255 |
|
|
256 if (any_arg_is_magic_colon (args)) |
|
|
257 { |
|
|
258 ::error ("invalid use of colon in function argument list"); |
|
|
259 return retval; |
|
|
260 } |
|
|
261 |
|
|
262 // If more than one argument, check if argument template matches any |
|
|
263 // overloaded functions. Also provide a catch-all '*' type to provide |
|
|
264 // single level pseudo rename and replace functionality. |
|
|
265 if (args.length () > 0 && tab.count (args(0).type_name ()) > 0) |
|
|
266 retval = feval (tab[args(0).type_name()], args, nargout); |
|
|
267 else if (has_alias) |
|
|
268 retval = feval (tab["any"], args, nargout); |
|
|
269 else |
|
|
270 { |
|
|
271 octave_function *fcn = builtin (base); |
|
|
272 if (! error_state && fcn) |
|
|
273 retval = fcn->do_multi_index_op (nargout, args); |
|
|
274 } |
|
|
275 |
|
|
276 return retval; |
|
|
277 } |
|
|
278 |
|
|
279 void |
|
|
280 octave_dispatch::print (std::ostream& os, bool) const |
|
|
281 { |
|
|
282 os << "Overloaded function " << base << std::endl; |
|
|
283 |
|
|
284 for (Table::const_iterator it = tab.begin (); it != tab.end (); it++) |
|
|
285 os << base << "(" << it->first << ",...)->" |
|
|
286 << it->second << "(" << it->first << ",...)" |
|
|
287 << std::endl; |
|
|
288 } |
|
|
289 |
|
|
290 DEFUN_DLD (builtin, args, nargout, |
|
|
291 "-*- texinfo -*-\n\ |
|
|
292 @deftypefn {Loadable Function} {[@dots{}]} builtin (@var{f}, @dots{})\n\ |
|
|
293 Call the base function @var{f} even if @var{f} is overloaded to\n\ |
|
|
294 some other function for the given type signature.\n\ |
|
5646
|
295 @seealso{dispatch}\n\ |
|
|
296 @end deftypefn") |
|
5164
|
297 { |
|
|
298 octave_value_list retval; |
|
|
299 |
|
|
300 int nargin = args.length (); |
|
|
301 |
|
|
302 if (nargin > 0) |
|
|
303 { |
|
|
304 const std::string name (args(0).string_value ()); |
|
|
305 |
|
|
306 if (error_state) |
|
|
307 return retval; |
|
|
308 |
|
|
309 symbol_record *sr = fbi_sym_tab->lookup (name, 0); |
|
5200
|
310 |
|
|
311 if (sr) |
|
5164
|
312 { |
|
5200
|
313 if (sr->def().type_id () == octave_dispatch::static_type_id ()) |
|
|
314 { |
|
|
315 octave_function *fcn = builtin (name); |
|
5164
|
316 |
|
5200
|
317 if (!error_state && fcn) |
|
|
318 retval = fcn->do_multi_index_op (nargout, |
|
|
319 args.splice (0, 1, retval)); |
|
|
320 } |
|
|
321 else |
|
|
322 retval = feval (name, args, nargout); |
|
5164
|
323 } |
|
|
324 else |
|
5200
|
325 error ("builtin: lookup for symbol `%s' failed", name.c_str ()); |
|
5164
|
326 } |
|
|
327 else |
|
5823
|
328 print_usage (); |
|
5164
|
329 |
|
|
330 return retval; |
|
|
331 } |
|
|
332 |
|
|
333 static void |
|
|
334 dispatch_record (const std::string &f, const std::string &n, |
|
|
335 const std::string &t) |
|
|
336 { |
|
|
337 // find the base function in the symbol table, loading it if it |
|
|
338 // is not already there; if it is already a dispatch, then bonus |
|
|
339 |
|
|
340 symbol_record *sr = fbi_sym_tab->lookup (f, true); |
|
|
341 |
|
|
342 if (sr->def().type_id () != octave_dispatch::static_type_id ()) |
|
|
343 { |
|
|
344 // Preserve mark_as_command status |
|
|
345 bool iscommand = sr->is_command (); |
|
|
346 |
|
|
347 // Not an overloaded name, so if only display or clear then we are done |
|
|
348 if (t.empty ()) |
|
|
349 return; |
|
|
350 |
|
|
351 // sr is the base symbol; rename it to keep it safe. When we need |
|
|
352 // it we will rename it back again. |
|
|
353 if (sr->is_read_only ()) |
|
|
354 { |
|
|
355 sr->unprotect (); |
|
|
356 fbi_sym_tab->rename (f, "builtin:" + f); |
|
|
357 sr = fbi_sym_tab->lookup (f, true); |
|
|
358 sr->protect (); |
|
|
359 } |
|
|
360 else |
|
|
361 fbi_sym_tab->rename (f, "builtin:" + f); |
|
|
362 |
|
5399
|
363 // It would be good to hide the builtin:XXX name, but since the |
|
|
364 // new XXX name in the symbol table is set to BUILTIN_FUNCTION, |
|
|
365 // things don't work quite the way we would like. |
|
|
366 // sr->hide (); |
|
5164
|
367 |
|
|
368 // Problem: when a function is first called a new record |
|
|
369 // is created for it in the current symbol table, so calling |
|
|
370 // dispatch on a function that has already been called, we |
|
|
371 // should also clear it from all existing symbol tables. |
|
|
372 // This is too much work, so we will only do it for the |
|
|
373 // top level symbol table. We can't use the clear_function() |
|
|
374 // method, because it won't clear builtin functions. Instead |
|
|
375 // we check if the symbol is a function and clear it then. This |
|
|
376 // won't properly clear shadowed functions, or functions in |
|
|
377 // other namespaces (such as the current, if called from a |
|
|
378 // function). |
|
|
379 symbol_record *local = top_level_sym_tab->lookup (f, false); |
|
|
380 if (local && local->is_function ()) |
|
|
381 local->clear (); |
|
|
382 |
|
|
383 // Build a new dispatch object based on the function definition |
|
|
384 octave_dispatch *dispatch = new octave_dispatch (f); |
|
|
385 |
|
|
386 // Create a symbol record for the dispatch object. |
|
|
387 sr = fbi_sym_tab->lookup (f, true); |
|
|
388 sr->unprotect (); |
|
|
389 sr->define (octave_value (dispatch), symbol_record::BUILTIN_FUNCTION); |
|
|
390 // std::cout << "iscommand('"<<f<<"')=" << iscommand << std::endl; |
|
|
391 if (iscommand) |
|
|
392 sr->mark_as_command(); |
|
5399
|
393 sr->document ("\n\n@noindent\nOverloaded function:\n"); |
|
5775
|
394 sr->make_eternal (); // FIXME why?? |
|
5164
|
395 sr->mark_as_static (); |
|
|
396 sr->protect (); |
|
|
397 } |
|
|
398 |
|
|
399 // clear/replace/extend the map with the new type-function pair |
|
|
400 const octave_dispatch& rep |
|
5760
|
401 = dynamic_cast<const octave_dispatch&> (sr->def().get_rep ()); |
|
5164
|
402 |
|
|
403 if (t.empty ()) |
|
5775
|
404 // FIXME should return the list if nargout > 1 |
|
5164
|
405 rep.print (octave_stdout); |
|
|
406 else if (n.empty ()) |
|
|
407 { |
|
5775
|
408 // FIXME should we eliminate the dispatch function if |
|
5164
|
409 // there are no more elements? |
|
5775
|
410 // FIXME should clear the " $t:\w+" from the help string. |
|
|
411 // FIXME -- seems bad to cast away const here... |
|
5164
|
412 octave_dispatch& xrep = const_cast<octave_dispatch&> (rep); |
|
|
413 |
|
|
414 xrep.clear (t); |
|
|
415 } |
|
|
416 else |
|
|
417 { |
|
5775
|
418 // FIXME -- seems bad to cast away const here... |
|
5164
|
419 octave_dispatch& xrep = const_cast<octave_dispatch&> (rep); |
|
|
420 |
|
|
421 xrep.add (t, n); |
|
|
422 |
|
|
423 if (! sr->help().empty ()) |
|
5300
|
424 sr->document (sr->help() + "\n" + n + " (" + t + ", ...)\n"); |
|
5164
|
425 } |
|
|
426 } |
|
|
427 |
|
|
428 DEFUN_DLD (dispatch, args, , |
|
|
429 "-*- texinfo -*-\n\ |
|
|
430 @deftypefn {Loadable Function} {} dispatch (@var{f}, @var{r}, @var{type})\n\ |
|
|
431 \n\ |
|
|
432 Replace the function @var{f} with a dispatch so that function @var{r}\n\ |
|
|
433 is called when @var{f} is called with the first argument of the named\n\ |
|
|
434 @var{type}. If the type is @var{any} then call @var{r} if no other type\n\ |
|
|
435 matches. The original function @var{f} is accessible using\n\ |
|
|
436 @code{builtin (@var{f}, @dots{}).\n\ |
|
|
437 \n\ |
|
|
438 If @var{r} is omitted, clear dispatch function associated with @var{type}.\n\ |
|
|
439 \n\ |
|
|
440 If both @var{r} and @var{type} are omitted, list dispatch functions\n\ |
|
5646
|
441 for @var{f}.\n\ |
|
|
442 @seealso{builtin}\n\ |
|
|
443 @end deftypefn") |
|
5164
|
444 { |
|
|
445 octave_value retval; |
|
|
446 int nargin = args.length (); |
|
|
447 |
|
|
448 if (nargin < 1 || nargin > 3) |
|
|
449 { |
|
5823
|
450 print_usage (); |
|
5164
|
451 return retval; |
|
|
452 } |
|
|
453 |
|
|
454 std::string f, t, n; |
|
|
455 if (nargin > 0) |
|
|
456 f = args(0).string_value (); |
|
|
457 |
|
|
458 if (nargin == 2) |
|
|
459 t = args(1).string_value (); |
|
|
460 else if (nargin > 2) |
|
|
461 { |
|
|
462 n = args(1).string_value (); |
|
|
463 t = args(2).string_value (); |
|
|
464 } |
|
|
465 |
|
|
466 if (error_state) |
|
|
467 return retval; |
|
|
468 |
|
|
469 static bool register_type = true; |
|
|
470 |
|
|
471 // register dispatch function type if you have not already done so |
|
|
472 if (register_type) |
|
|
473 { |
|
|
474 octave_dispatch::register_type (); |
|
|
475 register_type = false; |
|
|
476 fbi_sym_tab->lookup("dispatch")->mark_as_static (); |
|
|
477 } |
|
|
478 |
|
|
479 dispatch_record (f, n, t); |
|
|
480 |
|
|
481 return retval; |
|
|
482 } |
|
|
483 |
|
|
484 /* |
|
|
485 |
|
|
486 %!test # builtin function replacement |
|
|
487 %! dispatch('sin','length','string') |
|
5582
|
488 %! assert(sin("abc"),3) |
|
5164
|
489 %! assert(sin(0),0,10*eps); |
|
|
490 %!test # 'any' function |
|
|
491 %! dispatch('sin','exp','any') |
|
|
492 %! assert(sin(0),1,eps); |
|
5582
|
493 %! assert(sin("abc"),3); |
|
5164
|
494 %!test # 'builtin' function |
|
|
495 %! assert(builtin('sin',0),0,eps); |
|
|
496 %! builtin('eval','x=1;'); |
|
|
497 %! assert(x,1); |
|
|
498 %!test # clear function mapping |
|
|
499 %! dispatch('sin','string') |
|
|
500 %! dispatch('sin','any') |
|
|
501 %! assert(sin(0),0,10*eps); |
|
|
502 %!test # oct-file replacement |
|
|
503 %! dispatch('fft','length','string') |
|
|
504 %! assert(fft([1,1]),[2,0]); |
|
5582
|
505 %! assert(fft("abc"),3) |
|
5164
|
506 %! dispatch('fft','string'); |
|
|
507 %!test # m-file replacement |
|
|
508 %! dispatch('hamming','length','string') |
|
|
509 %! assert(hamming(1),1) |
|
5582
|
510 %! assert(hamming("abc"),3) |
|
5164
|
511 %! dispatch('hamming','string') |
|
|
512 |
|
|
513 %!test # override preloaded builtin |
|
|
514 %! evalin('base','cos(1);'); |
|
|
515 %! dispatch('cos','length','string') |
|
5582
|
516 %! evalin('base','assert(cos("abc"),3)'); |
|
|
517 %! evalin('base','assert(cos(0),1,eps)'); |
|
5164
|
518 %! dispatch('cos','string') |
|
|
519 %!test # override pre-loaded oct-file |
|
|
520 %! evalin('base','qr(1);'); |
|
|
521 %! dispatch('qr','length','string') |
|
5582
|
522 %! evalin('base','assert(qr("abc"),3)'); |
|
|
523 %! evalin('base','assert(qr(1),1)'); |
|
5164
|
524 %! dispatch('qr','string'); |
|
|
525 %!test # override pre-loaded m-file |
|
|
526 %! evalin('base','hanning(1);'); |
|
|
527 %! dispatch('hanning','length','string') |
|
|
528 %! evalin('base','assert(hanning("abc"),3)'); |
|
|
529 %! evalin('base','assert(hanning(1),1)'); |
|
|
530 %! dispatch('hanning','string'); |
|
|
531 |
|
5775
|
532 FIXME I would rather not create dispatch_x/dispatch_y |
|
5164
|
533 in the current directory! I don't want them installed accidentally. |
|
|
534 |
|
|
535 %!test # replace base m-file |
|
|
536 %! system("echo 'function a=dispatch_x(a)'>dispatch_x.m"); |
|
|
537 %! dispatch('dispatch_x','length','string') |
|
|
538 %! assert(dispatch_x(3),3) |
|
5582
|
539 %! assert(dispatch_x("a"),1) |
|
5832
|
540 %! sleep (2); |
|
5164
|
541 %! system("echo 'function a=dispatch_x(a),++a;'>dispatch_x.m"); |
|
5832
|
542 %! rehash(); |
|
5164
|
543 %! assert(dispatch_x(3),4) |
|
5582
|
544 %! assert(dispatch_x("a"),1) |
|
5164
|
545 %!test |
|
5832
|
546 %! unlink("dispatch_x.m"); |
|
5164
|
547 |
|
|
548 %!test # replace dispatch m-file |
|
|
549 %! system("echo 'function a=dispatch_y(a)'>dispatch_y.m"); |
|
|
550 %! dispatch('hello','dispatch_y','complex scalar') |
|
|
551 %! assert(hello(3i),3i) |
|
5832
|
552 %! sleep (2); |
|
5164
|
553 %! system("echo 'function a=dispatch_y(a),++a;'>dispatch_y.m"); |
|
5832
|
554 %! rehash(); |
|
5164
|
555 %! assert(hello(3i),1+3i) |
|
|
556 %!test |
|
5832
|
557 %! unlink("dispatch_y.m"); |
|
5164
|
558 |
|
5775
|
559 FIXME add tests for preservation of mark_as_command status. |
|
5164
|
560 |
|
|
561 */ |
