|
7019
|
1 ## Copyright (C) 2007 John W. Eaton |
|
|
2 ## |
|
|
3 ## This file is part of Octave. |
|
|
4 ## |
|
|
5 ## Octave 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 3 of the License, or (at |
|
|
8 ## your option) any later version. |
|
|
9 ## |
|
|
10 ## Octave 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, see |
|
|
17 ## <http://www.gnu.org/licenses/>. |
|
|
18 ## |
|
6874
|
19 ## This script is used to generate the graphics.h file from graphics.h.in. |
|
|
20 ## |
|
|
21 ## Lines between the BEGIN_PROPERTIES and END_PROPERTIES markers have |
|
|
22 ## one of the following formats: |
|
|
23 ## |
|
|
24 ## TYPE NAME |
|
|
25 ## TYPE NAME QUALIFIERS |
|
|
26 ## mutable TYPE NAME |
|
|
27 ## mutable TYPE NAME QUALIFIERS |
|
|
28 ## |
|
|
29 ## For each property, we generate a declaration for the property. |
|
|
30 ## |
|
|
31 ## If QUALIFIERS is omitted, we generate the following functions directly |
|
|
32 ## in the class declaration: |
|
|
33 ## |
|
6875
|
34 ## TYPE |
|
|
35 ## get_NAME (void) const |
|
|
36 ## { |
|
|
37 ## return NAME; |
|
|
38 ## } |
|
|
39 ## |
|
|
40 ## void |
|
|
41 ## set_NAME (const TYPE& val) |
|
|
42 ## { |
|
|
43 ## if (! error_state) |
|
|
44 ## NAME = val; |
|
|
45 ## } |
|
|
46 ## |
|
|
47 ## void |
|
|
48 ## set_NAME (const octave_value& val) |
|
|
49 ## { |
|
|
50 ## set_NAME (TYPE (val)); |
|
|
51 ## } |
|
6874
|
52 ## |
|
|
53 ## If present, the QUALIFIERS string may include any of the characters |
|
7379
|
54 ## g, G, m, s, S, o, O, h, which have the following meanings: |
|
6874
|
55 ## |
|
|
56 ## g: There is a custom inline definition for the get function, |
|
|
57 ## so we don't emit one. |
|
|
58 ## |
|
|
59 ## G: There is a custom extern definition for the get function, |
|
|
60 ## so we emit only the declaration. |
|
|
61 ## |
|
|
62 ## s: There is a custom inline definition for the type-specific set |
|
|
63 ## function, so we don't emit one. |
|
|
64 ## |
|
|
65 ## S: There is a custom extern definition for the type-specific set |
|
|
66 ## function, so we emit only the declaration. |
|
|
67 ## |
|
|
68 ## o: There is a custom inline definition for the octave_value version |
|
|
69 ## of the set function, so we don't emit one. |
|
|
70 ## |
|
|
71 ## O: There is a custom extern definition for the octave_value version |
|
|
72 ## of the set function, so we emit only the declaration. |
|
|
73 ## |
|
6904
|
74 ## a: The octave_value version of the set function will use assignment: |
|
|
75 ## |
|
|
76 ## void |
|
|
77 ## set_NAME (const octave_value& val) |
|
|
78 ## { |
|
|
79 ## TYPE tmp (NAME); |
|
|
80 ## tmp = val; |
|
|
81 ## set_NAME (tmp); |
|
|
82 ## } |
|
|
83 ## |
|
|
84 ## This is useful for things like the radio_value classes which |
|
|
85 ## use an overloaded assignment operator of the form |
|
|
86 ## |
|
|
87 ## radio_property& operator = (const octave_value& val); |
|
|
88 ## |
|
|
89 ## that preserves the list of possible values, which is different |
|
|
90 ## from what would happen if we simply used the |
|
|
91 ## |
|
|
92 ## TYPE (const octave_value&) |
|
|
93 ## |
|
|
94 ## constructor, which creates a new radio_property and so cannot |
|
|
95 ## preserve the old list of possible values. |
|
|
96 ## |
|
7214
|
97 ## l: Add the line |
|
|
98 ## |
|
|
99 ## update_axis_limits ("NAME"); |
|
|
100 ## |
|
|
101 ## to the type-specific set function. |
|
|
102 ## |
|
6874
|
103 ## m: Add the line |
|
|
104 ## |
|
|
105 ## set_NAMEmode ("manual"); |
|
|
106 ## |
|
|
107 ## to the type-specific set function. |
|
|
108 ## |
|
7379
|
109 ## h: Make the property hidden |
|
|
110 ## |
|
7427
|
111 ## r: Make the property read-only. A read-only property is not |
|
|
112 ## settable from the global set (caseless_str, octave_value) |
|
|
113 ## method, but still has set_X accessor. |
|
|
114 ## |
|
|
115 ## u: The property has an updater method. This effectively add |
|
|
116 ## the line |
|
|
117 ## |
|
|
118 ## update_NAME (); |
|
|
119 ## |
|
|
120 ## to the type-specific set function. This line is added before |
|
|
121 ## any other update call (like those added by the 'l' or 'm' |
|
|
122 ## modifiers. |
|
|
123 ## |
|
6874
|
124 ## The 'o' and 'O' qualifiers are only useful when the the property type |
|
|
125 ## is something other than octave_value. |
|
|
126 |
|
7363
|
127 ## simple accessor |
|
|
128 |
|
|
129 function emit_get_accessor (i, rtype, faccess) |
|
|
130 { |
|
|
131 printf (" %s get_%s (void) const", rtype, name[i]); |
|
|
132 |
|
|
133 if (emit_get[i] == "definition") |
|
|
134 printf (" { return %s.%s (); }\n", name[i], faccess); |
|
|
135 else |
|
|
136 printf (";\n"); |
|
|
137 } |
|
|
138 |
|
|
139 ## bool_property |
|
|
140 |
|
|
141 function emit_get_bool (i) |
|
|
142 { |
|
|
143 printf (" bool is_%s (void) const", name[i]); |
|
|
144 |
|
|
145 if (emit_get[i] == "definition") |
|
|
146 printf (" { return %s.is_on (); }\n", name[i]); |
|
|
147 else |
|
|
148 printf (";\n"); |
|
|
149 |
|
|
150 emit_get_accessor(i, "std::string", "current_value"); |
|
|
151 } |
|
|
152 |
|
|
153 ## radio_property |
|
|
154 |
|
|
155 function emit_get_radio (i) |
|
|
156 { |
|
|
157 printf (" bool %s_is (const std::string& v) const", name[i]); |
|
|
158 |
|
|
159 if (emit_get[i] == "definition") |
|
|
160 printf (" { return %s.is (v); }\n", name[i]); |
|
|
161 else |
|
|
162 printf (";\n"); |
|
|
163 |
|
|
164 emit_get_accessor(i, "std::string", "current_value"); |
|
|
165 } |
|
|
166 |
|
|
167 ## color_property |
|
|
168 |
|
|
169 function emit_get_color (i) |
|
|
170 { |
|
|
171 printf (" bool %s_is_rgb (void) const { return %s.is_rgb (); }\n", name[i], name[i]); |
|
|
172 |
|
|
173 printf (" bool %s_is (const std::string& v) const", name[i]); |
|
|
174 |
|
|
175 if (emit_get[i] == "definition") |
|
|
176 printf (" { return %s.is (v); }\n", name[i]); |
|
|
177 else |
|
|
178 printf (";\n"); |
|
|
179 |
|
|
180 printf (" Matrix get_%s_rgb (void) const", name[i]); |
|
|
181 |
|
|
182 if (emit_get[i] == "definition") |
|
|
183 printf (" { return (%s.is_rgb () ? %s.rgb () : Matrix ()); }\n", name[i], name[i]); |
|
|
184 else |
|
|
185 printf (";\n"); |
|
|
186 |
|
|
187 emit_get_accessor(i, "octave_value", "get"); |
|
|
188 } |
|
|
189 |
|
|
190 ## callback_property |
|
|
191 |
|
|
192 function emit_get_callback (i) |
|
|
193 { |
|
7367
|
194 printf (" void execute_%s (const octave_value& data = octave_value ()) const", name[i]); |
|
7363
|
195 |
|
|
196 if (emit_get[i] == "definition") |
|
7367
|
197 printf (" { %s.execute (data); }\n", name[i]); |
|
7363
|
198 else |
|
|
199 printf (";\n"); |
|
|
200 |
|
|
201 emit_get_accessor(i, "octave_value", "get"); |
|
|
202 } |
|
|
203 |
|
|
204 ## data_property |
|
|
205 |
|
|
206 function emit_get_data (i) |
|
|
207 { |
|
|
208 emit_get_accessor(i, "NDArray", "array_value"); |
|
|
209 |
|
|
210 printf (" data_property get_%s_property (void) const { return %s; }\n", |
|
|
211 name[i], name[i]); |
|
|
212 } |
|
|
213 |
|
|
214 ## common section |
|
|
215 |
|
|
216 function emit_common_declarations () |
|
|
217 { |
|
|
218 printf ("public:\n"); |
|
|
219 printf (" properties (const graphics_handle& mh, const graphics_handle& p);\n\n"); |
|
|
220 printf (" ~properties (void) { }\n\n"); |
|
7406
|
221 printf (" void set (const caseless_str& pname, const octave_value& val);\n\n"); |
|
7379
|
222 printf (" octave_value get (bool all = false) const;\n\n"); |
|
7406
|
223 printf (" octave_value get (const caseless_str& pname) const;\n\n"); |
|
7363
|
224 printf (" std::string graphics_object_name (void) const { return go_name; }\n\n"); |
|
|
225 printf (" static property_list::pval_map_type factory_defaults (void);\n\n"); |
|
|
226 printf ("private:\n static std::string go_name;\n\n"); |
|
|
227 } |
|
|
228 |
|
7225
|
229 function emit_declarations () |
|
6874
|
230 { |
|
7363
|
231 if (class_name) |
|
|
232 emit_common_declarations(); |
|
|
233 |
|
6874
|
234 if (idx > 0) |
|
7363
|
235 print "private:\n"; |
|
6874
|
236 |
|
|
237 for (i = 1; i <= idx; i++) |
|
7363
|
238 printf (" %s%s %s;\n", mutable[i] ? "mutable " : "", type[i], name[i]); |
|
6874
|
239 |
|
|
240 if (idx > 0) |
|
7363
|
241 print "\npublic:\n"; |
|
6874
|
242 |
|
|
243 for (i = 1; i <= idx; i++) |
|
|
244 { |
|
7363
|
245 if (emit_get[i]) |
|
|
246 { |
|
|
247 if (type[i] == "array_property" || type[i] == "any_property") |
|
|
248 emit_get_accessor(i, "octave_value", "get"); |
|
|
249 else if (type[i] == "handle_property") |
|
|
250 emit_get_accessor(i, "graphics_handle", "handle_value"); |
|
|
251 else if (type[i] == "string_property") |
|
|
252 emit_get_accessor(i, "std::string", "string_value"); |
|
|
253 else if (type[i] == "double_property") |
|
|
254 emit_get_accessor(i, "double", "double_value"); |
|
|
255 else if (type[i] == "data_property") |
|
|
256 emit_get_data(i); |
|
|
257 else if (type[i] == "bool_property") |
|
|
258 emit_get_bool(i); |
|
|
259 else if (type[i] == "radio_property") |
|
|
260 emit_get_radio(i); |
|
|
261 else if (type[i] == "color_property") |
|
|
262 emit_get_color(i); |
|
|
263 else if (type[i] == "callback_property") |
|
|
264 emit_get_callback(i); |
|
|
265 else |
|
6874
|
266 { |
|
7363
|
267 printf (" %s get_%s (void) const", type[i], name[i]); |
|
6874
|
268 |
|
7363
|
269 if (emit_get[i] == "definition") |
|
|
270 printf (" { return %s; }\n", name[i]); |
|
|
271 else |
|
|
272 printf (";\n"); |
|
6874
|
273 } |
|
7363
|
274 printf ("\n"); |
|
|
275 } |
|
6874
|
276 } |
|
|
277 |
|
|
278 if (idx > 0) |
|
7363
|
279 printf ("\n"); |
|
6874
|
280 |
|
|
281 for (i = 1; i <= idx; i++) |
|
|
282 { |
|
7363
|
283 if (emit_set[i]) |
|
|
284 { |
|
|
285 printf (" void set_%s (const octave_value& val)", name[i], type[i]); |
|
6874
|
286 |
|
7363
|
287 if (emit_set[i] == "definition") |
|
|
288 { |
|
|
289 printf ("\n {\n if (! error_state)\n {\n %s = val;\n", |
|
|
290 name[i]); |
|
7427
|
291 if (updater[i]) |
|
|
292 printf (" %s ();\n", updater[i]); |
|
7363
|
293 if (limits[i]) |
|
|
294 printf (" update_axis_limits (\"%s\");\n", name[i]); |
|
|
295 if (mode[i]) |
|
|
296 printf (" set_%smode (\"manual\");\n", name[i]); |
|
|
297 printf (" mark_modified ();\n }\n }\n\n"); |
|
6874
|
298 } |
|
7363
|
299 else |
|
|
300 printf (";\n\n"); |
|
|
301 } |
|
6874
|
302 |
|
7363
|
303 ## if (emit_ov_set[i]) |
|
|
304 ## { |
|
|
305 ## printf (" void set_%s (const octave_value& val)", name[i]); |
|
|
306 ## |
|
|
307 ## if (emit_ov_set[i] == "definition") |
|
|
308 ## printf (" { set_%s (%s (val)); }\n\n", name[i], type[i]); |
|
|
309 ## else if (emit_ov_set[i] == "assignment") |
|
|
310 ## { |
|
|
311 ## printf ("\n {\n %s tmp (%s);\n tmp = val;\n set_%s (tmp);\n };\n\n", |
|
|
312 ## type[i], name[i], name[i], name[i]); |
|
|
313 ## } |
|
|
314 ## else |
|
|
315 ## printf (";\n"); |
|
|
316 ## } |
|
6874
|
317 } |
|
|
318 |
|
7363
|
319 ## if (idx > 0) |
|
|
320 ## print "\nprivate:"; |
|
|
321 } |
|
|
322 |
|
|
323 function emit_source () |
|
|
324 { |
|
|
325 if (class_name) |
|
|
326 { |
|
|
327 printf ("// ******** %s ********\n\n", class_name) >> filename; |
|
|
328 |
|
|
329 ## constructor |
|
|
330 |
|
|
331 printf ("%s::properties::properties (const graphics_handle& mh, const graphics_handle& p)\n", class_name) >> filename; |
|
|
332 printf (" : base_properties (go_name, mh, p),\n") >> filename; |
|
|
333 |
|
|
334 for (i = 1; i <= idx; i++) |
|
|
335 { |
|
7397
|
336 printf (" %s (\"%s\", mh, %s)", name[i], name[i], defval[i]) >> filename; |
|
7363
|
337 if (i < idx) |
|
|
338 printf (",") >> filename; |
|
|
339 printf ("\n") >> filename; |
|
|
340 } |
|
|
341 |
|
7379
|
342 printf ("{\n") >> filename; |
|
7363
|
343 |
|
7379
|
344 for (i = 1; i <= idx; i++) |
|
|
345 { |
|
|
346 ## printf (" insert_static_property (\"%s\", %s);\n", name[i], name[i]) >> filename; |
|
|
347 if (hidden[i]) |
|
|
348 printf (" %s.set_hidden (true);\n", name[i]) >> filename; |
|
|
349 } |
|
7363
|
350 |
|
7379
|
351 printf (" init ();\n}\n\n") >> filename; |
|
7363
|
352 |
|
|
353 ## set method |
|
|
354 |
|
7406
|
355 printf ("void\n%s::properties::set (const caseless_str& pname, const octave_value& val)\n{\n", |
|
7363
|
356 class_name) >> filename; |
|
|
357 |
|
|
358 for (i = 1; i <= idx; i++) |
|
|
359 { |
|
7403
|
360 if (! readonly[i]) |
|
7406
|
361 printf (" %sif (pname.compare (\"%s\"))\n set_%s (val);\n", |
|
7403
|
362 (i > 1 ? "else " : ""), name[i], name[i]) >> filename; |
|
7363
|
363 } |
|
|
364 |
|
7406
|
365 printf (" else\n base_properties::set (pname, val);\n}\n\n") >> filename; |
|
7363
|
366 |
|
|
367 ## get "all" method |
|
|
368 |
|
7379
|
369 printf ("octave_value\n%s::properties::get (bool all) const\n{\n", class_name) >> filename; |
|
|
370 printf (" Octave_map m = base_properties::get (all).map_value ();\n\n") >> filename; |
|
7363
|
371 |
|
|
372 for (i = 1; i <= idx; i++) |
|
|
373 { |
|
7379
|
374 if (hidden[i]) |
|
|
375 printf (" if (all)\n m.assign (\"%s\", get_%s ()%s);\n", name[i], name[i], |
|
|
376 (type[i] == "handle_property" ? ".as_octave_value ()" : "")) >> filename; |
|
|
377 else |
|
|
378 printf (" m.assign (\"%s\", get_%s ()%s);\n", name[i], name[i], |
|
|
379 (type[i] == "handle_property" ? ".as_octave_value ()" : "")) >> filename; |
|
7363
|
380 } |
|
|
381 |
|
|
382 printf ("\n return m;\n}\n\n") >> filename; |
|
|
383 |
|
|
384 ## get "one" method |
|
|
385 |
|
7406
|
386 printf ("octave_value\n%s::properties::get (const caseless_str& pname) const\n{\n", |
|
7363
|
387 class_name) >> filename; |
|
|
388 printf (" octave_value retval;\n\n") >> filename; |
|
|
389 |
|
|
390 for (i = 1; i<= idx; i++) |
|
|
391 { |
|
7406
|
392 printf (" %sif (pname.compare (\"%s\"))\n", |
|
7363
|
393 (i > 1 ? "else " : ""), name[i]) >> filename; |
|
|
394 printf (" retval = get_%s ()%s;\n", name[i], |
|
|
395 (type[i] == "handle_property" ? ".as_octave_value ()" : "")) >> filename; |
|
|
396 } |
|
|
397 |
|
7406
|
398 printf (" else\n retval = base_properties::get (pname);\n\n") >> filename; |
|
7363
|
399 printf (" return retval;\n}\n\n") >> filename; |
|
|
400 |
|
|
401 ## factory defaults method |
|
|
402 |
|
|
403 printf ("property_list::pval_map_type\n%s::properties::factory_defaults (void)\n{\n", |
|
|
404 class_name) >> filename; |
|
|
405 printf (" property_list::pval_map_type m;\n\n") >> filename; |
|
|
406 |
|
|
407 for (i = 1; i <= idx; i++) |
|
|
408 { |
|
7397
|
409 dval = defval[i]; |
|
7363
|
410 if (type[i] == "radio_property" || type[i] == "color_property") |
|
7397
|
411 dval = gensub (/^.*\{(.*)\}.*$/, "\"\\1\"", "g", dval); |
|
|
412 if (! dval) |
|
|
413 dval = "octave_value ()"; |
|
7363
|
414 if (name[i] !~ /__.*/) |
|
7397
|
415 printf (" m[\"%s\"] = %s%s;\n", name[i], dval, |
|
7363
|
416 (type[i] == "handle_property" ? ".as_octave_value ()" : "")) >> filename; |
|
|
417 } |
|
|
418 |
|
|
419 printf ("\n return m;\n}\n\n") >> filename; |
|
|
420 |
|
|
421 ## go_name static field |
|
|
422 |
|
|
423 printf ("std::string %s::properties::go_name (\"%s\");\n\n", |
|
|
424 class_name, class_name) >> filename; |
|
|
425 } |
|
6874
|
426 } |
|
|
427 |
|
|
428 BEGIN { |
|
7363
|
429 filename = "graphics-props.cc"; |
|
|
430 printf ("// DO NOT EDIT! Generated automatically by genprops.awk.\n\n"); |
|
|
431 printf ("// DO NOT EDIT! Generated automatically by genprops.awk.\n\n") > filename; |
|
|
432 } |
|
|
433 |
|
|
434 /BEGIN_PROPERTIES\(.*\)/ { |
|
|
435 gather = 1; |
|
|
436 idx = 0; |
|
|
437 class_name = gensub (/^.*BEGIN_PROPERTIES\((.*)\)/, "\\1", "g"); |
|
|
438 next; |
|
6874
|
439 } |
|
|
440 |
|
|
441 /BEGIN_PROPERTIES/ { |
|
7363
|
442 gather = 1; |
|
|
443 idx = 0; |
|
|
444 class_name = ""; |
|
|
445 next; |
|
6874
|
446 } |
|
|
447 |
|
|
448 /END_PROPERTIES/ { |
|
7363
|
449 emit_declarations(); |
|
|
450 emit_source(); |
|
|
451 gather = 0; |
|
|
452 next; |
|
6874
|
453 } |
|
|
454 |
|
|
455 { |
|
|
456 if (gather) |
|
7363
|
457 { |
|
7403
|
458 if (NF < 2 || /^[ \t]*\/\//) |
|
7363
|
459 next; |
|
6874
|
460 |
|
7363
|
461 idx++; |
|
6874
|
462 |
|
7363
|
463 field = 1; |
|
6874
|
464 |
|
7363
|
465 if ($field == "mutable") |
|
|
466 { |
|
|
467 mutable[idx] = 1; |
|
|
468 field++; |
|
|
469 } |
|
|
470 else |
|
|
471 mutable[idx] = 0; |
|
6874
|
472 |
|
7363
|
473 type[idx] = $(field++); |
|
|
474 name[idx] = $(field++); |
|
6874
|
475 |
|
7363
|
476 limits[idx] = 0; |
|
|
477 mode[idx] = 0; |
|
7403
|
478 hidden[idx] = 0; |
|
|
479 readonly[idx] = 0; |
|
7363
|
480 emit_get[idx] = "definition"; |
|
|
481 emit_set[idx] = "definition"; |
|
7397
|
482 defval[idx] = ""; |
|
7427
|
483 updater[idx] = ""; |
|
7363
|
484 ## if (type[idx] == "octave_value") |
|
|
485 ## emit_ov_set[idx] = ""; |
|
|
486 ## else |
|
|
487 ## emit_ov_set[idx] = "definition"; |
|
6874
|
488 |
|
7363
|
489 if (NF >= field) |
|
|
490 { |
|
|
491 if ($field != ",") |
|
|
492 { |
|
|
493 quals = $(field++); |
|
7214
|
494 |
|
7363
|
495 if (index (quals, "l")) |
|
|
496 limits[idx] = 1; |
|
6874
|
497 |
|
7363
|
498 if (index (quals, "m")) |
|
|
499 mode[idx] = 1; |
|
|
500 |
|
|
501 ## There is a custom inline definition for the get function, |
|
|
502 ## so we don't emit anything. |
|
|
503 if (index (quals, "g")) |
|
|
504 emit_get[idx] = ""; |
|
6874
|
505 |
|
7363
|
506 ## There is a custom extern definition for the get function, |
|
|
507 ## but we still emit the declaration. |
|
|
508 if (index (quals, "G")) |
|
|
509 emit_get[idx] = "declaration"; |
|
6874
|
510 |
|
7363
|
511 ## There is a custom inline definition for the set function, |
|
|
512 ## so we don't emit anything. |
|
|
513 if (index (quals, "s")) |
|
|
514 emit_set[idx] = ""; |
|
6874
|
515 |
|
7363
|
516 ## There is a custom extern definition for the set function, |
|
|
517 ## but we still emit the declaration. |
|
|
518 if (index (quals, "S")) |
|
|
519 emit_set[idx] = "declaration"; |
|
7379
|
520 |
|
7403
|
521 ## The property is hidden |
|
|
522 if (index (quals, "h")) |
|
|
523 hidden[idx] = 1; |
|
|
524 |
|
|
525 ## The property is read-only |
|
|
526 if (index (quals, "r")) |
|
|
527 readonly[idx] = 1; |
|
6904
|
528 |
|
7427
|
529 ## There is an updater method that should be called |
|
|
530 ## from the set method |
|
|
531 if (index (quals, "u")) |
|
|
532 updater[idx] = ("update_" name[idx]); |
|
|
533 |
|
7363
|
534 ## ## emmit an asignment set function |
|
|
535 ## if (index (quals, "a")) |
|
|
536 ## emit_ov_set[idx] = "assignment"; |
|
|
537 ## |
|
|
538 ## if (type[idx] != "octave_value") |
|
|
539 ## { |
|
|
540 ## ## The 'o' and 'O' qualifiers are only useful when the |
|
|
541 ## ## the property type is something other than an |
|
|
542 ## ## octave_value. |
|
|
543 ## |
|
|
544 ## ## There is a custom inline definition for the |
|
|
545 ## ## octave_value version of the set function, so we |
|
|
546 ## ## don't emit anything. |
|
|
547 ## if (index (quals, "o")) |
|
|
548 ## emit_ov_set[idx] = ""; |
|
|
549 ## |
|
|
550 ## ## There is a custom extern definition for the |
|
|
551 ## ## octave_value version of the set function, but we |
|
|
552 ## ## still emit the declaration. |
|
|
553 ## if (index (quals, "O")) |
|
|
554 ## emit_ov_set[idx] = "declaration"; |
|
|
555 ## } |
|
|
556 } |
|
6874
|
557 |
|
7363
|
558 if (NF > field && $field == ",") |
|
|
559 { |
|
|
560 field++; |
|
6874
|
561 |
|
7363
|
562 for (i = field; i <= NF; i++) |
|
7397
|
563 defval[idx] = (defval[idx] (i > field ? " " : "") $i); |
|
7363
|
564 } |
|
6874
|
565 } |
|
7363
|
566 |
|
|
567 } |
|
6874
|
568 else |
|
7363
|
569 print $0; |
|
6883
|
570 } |
