1
|
1 /* |
|
2 |
7017
|
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, |
|
4 2003, 2004, 2005, 2006, 2007 John W. Eaton |
1
|
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 |
7016
|
10 Free Software Foundation; either version 3 of the License, or (at your |
|
11 option) any later version. |
1
|
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 |
7016
|
19 along with Octave; see the file COPYING. If not, see |
|
20 <http://www.gnu.org/licenses/>. |
1
|
21 |
|
22 */ |
|
23 |
240
|
24 #ifdef HAVE_CONFIG_H |
1192
|
25 #include <config.h> |
1
|
26 #endif |
|
27 |
1343
|
28 #include <cstdlib> |
|
29 |
3503
|
30 #include <iostream> |
164
|
31 |
1352
|
32 #include "Range.h" |
4650
|
33 #include "boolNDArray.h" |
1560
|
34 #include "dColVector.h" |
4650
|
35 #include "dNDArray.h" |
1352
|
36 |
1
|
37 #include "idx-vector.h" |
1560
|
38 #include "lo-error.h" |
2500
|
39 #include "lo-mappers.h" |
1
|
40 |
1560
|
41 #define IDX_VEC_REP idx_vector::idx_vector_rep |
|
42 |
|
43 IDX_VEC_REP::idx_vector_rep (const IDX_VEC_REP& a) |
4653
|
44 : data (0), len (a.len), num_zeros (a.num_zeros), num_ones (a.num_ones), |
7422
|
45 range_base (a.range_base), range_step (a.range_step), |
4653
|
46 max_val (a.max_val), min_val (a.min_val), |
|
47 frozen_at_z_len (a.frozen_at_z_len), frozen_len (a.frozen_len), |
7422
|
48 colon (a.colon), range(a.range), one_zero (a.one_zero), |
|
49 initialized (a.initialized), frozen (a.frozen), |
|
50 colon_equiv_checked (a.colon_equiv_checked), |
4653
|
51 colon_equiv (a.colon_equiv), orig_dims (a.orig_dims) |
1
|
52 { |
|
53 if (len > 0) |
|
54 { |
7422
|
55 if (! range) |
|
56 { |
|
57 data = new octave_idx_type [len]; |
|
58 |
|
59 for (octave_idx_type i = 0; i < len; i++) |
|
60 data[i] = a.data[i]; |
|
61 } |
1
|
62 } |
|
63 } |
|
64 |
5275
|
65 octave_idx_type |
4938
|
66 IDX_VEC_REP::tree_to_mat_idx (double x, bool& conversion_error) |
1
|
67 { |
5275
|
68 octave_idx_type retval = -1; |
4732
|
69 |
|
70 conversion_error = false; |
|
71 |
|
72 if (D_NINT (x) != x) |
|
73 { |
|
74 (*current_liboctave_error_handler) |
|
75 ("expecting integer index, found %f", x); |
|
76 |
|
77 conversion_error = true; |
|
78 } |
|
79 else |
5275
|
80 retval = static_cast<octave_idx_type> (x - 1); |
4732
|
81 |
|
82 return retval; |
3928
|
83 } |
|
84 |
2500
|
85 static inline bool |
|
86 idx_is_inf_or_nan (double x) |
|
87 { |
|
88 bool retval = false; |
|
89 |
|
90 if (xisnan (x)) |
|
91 { |
|
92 (*current_liboctave_error_handler) ("NaN invalid as index"); |
|
93 retval = true; |
|
94 } |
|
95 else if (xisinf (x)) |
|
96 { |
|
97 (*current_liboctave_error_handler) ("Inf invalid as index"); |
|
98 retval = true; |
|
99 } |
|
100 |
|
101 return retval; |
1
|
102 } |
|
103 |
1560
|
104 IDX_VEC_REP::idx_vector_rep (const ColumnVector& v) |
7422
|
105 : data (0), len (v.length ()), num_zeros (0), num_ones (0), |
|
106 range_base (0), range_step (0), max_val (0), min_val (0), count (1), |
|
107 frozen_at_z_len (0), frozen_len (0), colon (0), range(0), |
|
108 one_zero (0), initialized (0), frozen (0), colon_equiv_checked (0), |
|
109 colon_equiv (0), orig_dims (len, 1) |
1
|
110 { |
1560
|
111 if (len == 0) |
1
|
112 { |
191
|
113 initialized = 1; |
1
|
114 return; |
|
115 } |
1560
|
116 else |
1
|
117 { |
5275
|
118 data = new octave_idx_type [len]; |
2500
|
119 |
4732
|
120 bool conversion_error = false; |
|
121 |
5275
|
122 for (octave_idx_type i = 0; i < len; i++) |
2500
|
123 { |
|
124 double d = v.elem (i); |
|
125 |
|
126 if (idx_is_inf_or_nan (d)) |
|
127 return; |
|
128 else |
4732
|
129 data[i] = tree_to_mat_idx (d, conversion_error); |
|
130 |
|
131 if (conversion_error) |
|
132 return; |
2500
|
133 } |
1
|
134 } |
1560
|
135 |
|
136 init_state (); |
|
137 } |
|
138 |
4650
|
139 IDX_VEC_REP::idx_vector_rep (const NDArray& nda) |
4653
|
140 : data (0), len (nda.length ()), num_zeros (0), num_ones (0), |
7422
|
141 range_base (0), range_step (0), max_val (0), min_val (0), count (1), |
|
142 frozen_at_z_len (0), frozen_len (0), colon (0), range(0), |
|
143 one_zero (0), initialized (0), frozen (0), colon_equiv_checked (0), |
|
144 colon_equiv (0), orig_dims (nda.dims ()) |
1560
|
145 { |
|
146 if (len == 0) |
1
|
147 { |
1560
|
148 initialized = 1; |
|
149 return; |
1
|
150 } |
|
151 else |
|
152 { |
5275
|
153 octave_idx_type k = 0; |
|
154 data = new octave_idx_type [len]; |
2500
|
155 |
4732
|
156 bool conversion_error = false; |
|
157 |
5275
|
158 for (octave_idx_type i = 0; i < len; i++) |
4650
|
159 { |
|
160 double d = nda.elem (i); |
2500
|
161 |
4650
|
162 if (idx_is_inf_or_nan (d)) |
|
163 return; |
|
164 else |
4732
|
165 data[k++] = tree_to_mat_idx (d, conversion_error); |
|
166 |
|
167 if (conversion_error) |
|
168 return; |
4650
|
169 } |
1
|
170 } |
|
171 |
1560
|
172 init_state (); |
1
|
173 } |
|
174 |
1560
|
175 IDX_VEC_REP::idx_vector_rep (const Range& r) |
4653
|
176 : data (0), len (r.nelem ()), num_zeros (0), num_ones (0), |
7422
|
177 range_base (0), range_step (0), max_val (0), min_val (0), |
|
178 count (1), frozen_at_z_len (0), frozen_len (0), colon (0), |
|
179 range(1), one_zero (0), initialized (0), frozen (0), |
|
180 colon_equiv_checked (0), colon_equiv (0), orig_dims (1, len) |
1
|
181 { |
191
|
182 if (len < 0) |
|
183 { |
1560
|
184 (*current_liboctave_error_handler) ("invalid range used as index"); |
191
|
185 return; |
|
186 } |
|
187 else if (len == 0) |
|
188 { |
|
189 initialized = 1; |
|
190 return; |
|
191 } |
1
|
192 |
6457
|
193 if (r.all_elements_are_ints ()) |
|
194 { |
7422
|
195 range_base = static_cast<octave_idx_type> (r.base () - 1); |
|
196 range_step = static_cast<octave_idx_type> (r.inc ()); |
4732
|
197 |
7422
|
198 init_state (); |
1
|
199 } |
6457
|
200 else |
|
201 (*current_liboctave_error_handler) |
|
202 ("expecting integer index, found non integer Range"); |
1
|
203 } |
|
204 |
3928
|
205 IDX_VEC_REP::idx_vector_rep (double d) |
4653
|
206 : data (0), len (1), num_zeros (0), num_ones (0), |
7422
|
207 range_base (0), range_step (0), max_val (0), min_val (0), |
|
208 count (1), frozen_at_z_len (0), frozen_len (0), colon (0), |
|
209 range(1), one_zero (0), initialized (0), frozen (0), |
|
210 colon_equiv_checked (0), colon_equiv (0), orig_dims (1, 1) |
3928
|
211 { |
|
212 if (idx_is_inf_or_nan (d)) |
|
213 return; |
|
214 else |
|
215 { |
4732
|
216 bool conversion_error = false; |
|
217 |
7422
|
218 range_base = tree_to_mat_idx (d, conversion_error); |
|
219 range_step = 1; |
4732
|
220 |
|
221 if (conversion_error) |
|
222 return; |
3928
|
223 } |
|
224 |
|
225 init_state (); |
|
226 } |
|
227 |
5275
|
228 IDX_VEC_REP::idx_vector_rep (octave_idx_type i) |
4653
|
229 : data (0), len (1), num_zeros (0), num_ones (0), |
7422
|
230 range_base (tree_to_mat_idx (i)), range_step (1), |
4653
|
231 max_val (0), min_val (0), count (1), frozen_at_z_len (0), |
7422
|
232 frozen_len (0), colon (0), range(1), one_zero (0), |
|
233 initialized (0), frozen (0), colon_equiv_checked (0), |
|
234 colon_equiv (0), orig_dims (1, 1) |
3928
|
235 { |
|
236 init_state (); |
|
237 } |
|
238 |
1560
|
239 IDX_VEC_REP::idx_vector_rep (char c) |
7422
|
240 : data (0), len (0), num_zeros (0), num_ones (0), range_base (0), |
|
241 range_step (0), max_val (0), min_val (0), count (1), |
|
242 frozen_at_z_len (0), frozen_len (0), colon (1), range(0), |
|
243 one_zero (0), initialized (0), frozen (0), colon_equiv_checked (0), |
|
244 colon_equiv (0), orig_dims (0, 0) |
1560
|
245 { |
|
246 assert (c == ':'); |
|
247 |
|
248 init_state (); |
|
249 } |
|
250 |
2828
|
251 IDX_VEC_REP::idx_vector_rep (bool b) |
7422
|
252 : data (0), len (1), num_zeros (0), num_ones (0), range_base (0), |
|
253 range_step (0), max_val (0), min_val (0), count (1), |
|
254 frozen_at_z_len (0), frozen_len (0), colon (0), range(0), |
|
255 one_zero (1), initialized (0), frozen (0), colon_equiv_checked (0), |
|
256 colon_equiv (0), orig_dims (1, 1) |
2828
|
257 { |
5275
|
258 data = new octave_idx_type [len]; |
2828
|
259 |
|
260 data[0] = tree_to_mat_idx (b); |
|
261 |
|
262 init_state (); |
|
263 } |
|
264 |
4650
|
265 IDX_VEC_REP::idx_vector_rep (const boolNDArray& bnda) |
4653
|
266 : data (0), len (bnda.length ()), num_zeros (0), num_ones (0), |
7422
|
267 range_base (0), range_step (0), max_val (0), min_val (0), |
|
268 count (1), frozen_at_z_len (0), frozen_len (0), colon (0), |
|
269 range(0), one_zero (1), initialized (0), frozen (0), |
|
270 colon_equiv_checked (0), colon_equiv (0), orig_dims (bnda.dims ()) |
2828
|
271 { |
|
272 if (len == 0) |
|
273 { |
|
274 initialized = 1; |
|
275 return; |
|
276 } |
|
277 else |
|
278 { |
5275
|
279 octave_idx_type k = 0; |
|
280 data = new octave_idx_type [len]; |
2828
|
281 |
5275
|
282 for (octave_idx_type i = 0; i < len; i++) |
4650
|
283 data[k++] = tree_to_mat_idx (bnda.elem (i)); |
2828
|
284 } |
|
285 |
|
286 init_state (); |
|
287 } |
|
288 |
1560
|
289 IDX_VEC_REP& |
|
290 IDX_VEC_REP::operator = (const IDX_VEC_REP& a) |
1
|
291 { |
|
292 if (this != &a) |
|
293 { |
|
294 delete [] data; |
|
295 len = a.len; |
7422
|
296 |
|
297 if (a.data) |
|
298 { |
|
299 data = new octave_idx_type [len]; |
|
300 |
|
301 for (octave_idx_type i = 0; i < len; i++) |
|
302 data[i] = a.data[i]; |
|
303 } |
|
304 else |
|
305 data = 0; |
1
|
306 |
|
307 num_zeros = a.num_zeros; |
|
308 num_ones = a.num_ones; |
|
309 max_val = a.max_val; |
|
310 min_val = a.min_val; |
4653
|
311 frozen_at_z_len = a.frozen_at_z_len; |
|
312 frozen_len = a.frozen_len; |
|
313 colon = a.colon; |
7422
|
314 range = a.range; |
|
315 range_base = a.range_base; |
|
316 range_step = a.range_step; |
4653
|
317 one_zero = a.one_zero; |
|
318 initialized = a.initialized; |
|
319 frozen = a.frozen; |
|
320 colon_equiv_checked = a.colon_equiv_checked; |
|
321 colon_equiv = a.colon_equiv; |
|
322 orig_dims = a.orig_dims; |
1
|
323 } |
4653
|
324 |
1
|
325 return *this; |
|
326 } |
|
327 |
|
328 void |
1560
|
329 IDX_VEC_REP::init_state (void) |
1
|
330 { |
|
331 num_zeros = 0; |
|
332 num_ones = 0; |
|
333 |
1560
|
334 if (colon) |
1
|
335 { |
2828
|
336 min_val = 0; |
|
337 max_val = 0; |
1
|
338 } |
7422
|
339 else if (range) |
|
340 { |
|
341 if (range_step >= 0) |
|
342 { |
|
343 min_val = range_base; |
|
344 max_val = (len > 0) ? range_base + (len-1)*range_step : range_base; |
|
345 } |
|
346 else |
|
347 { |
|
348 max_val = range_base; |
|
349 min_val = (len > 0) ? range_base + (len-1)*range_step : range_base; |
|
350 } |
|
351 |
|
352 if ((range_base <= 0 && range_step > 0) |
|
353 || (range_base >= 0 && range_step < 0)) |
|
354 num_zeros = 1; |
|
355 |
|
356 if ((range_base <= 1 && range_step > 0) |
|
357 || (range_base >= 1 && range_step < 0)) |
|
358 num_zeros = 0; |
|
359 } |
1
|
360 else |
|
361 { |
|
362 min_val = max_val = data[0]; |
|
363 |
5275
|
364 octave_idx_type i = 0; |
1
|
365 do |
|
366 { |
1560
|
367 if (data[i] == -1) |
|
368 num_zeros++; |
|
369 else if (data[i] == 0) |
|
370 num_ones++; |
|
371 |
1
|
372 if (data[i] > max_val) |
|
373 max_val = data[i]; |
|
374 |
|
375 if (data[i] < min_val) |
|
376 min_val = data[i]; |
|
377 } |
|
378 while (++i < len); |
|
379 } |
1560
|
380 |
|
381 initialized = 1; |
|
382 } |
|
383 |
|
384 void |
5275
|
385 IDX_VEC_REP::maybe_convert_one_zero_to_idx (octave_idx_type z_len) |
1560
|
386 { |
3680
|
387 if (one_zero && (z_len == len || z_len == 0)) |
1560
|
388 { |
|
389 if (num_ones == 0) |
|
390 { |
|
391 len = 0; |
|
392 max_val = 0; |
|
393 min_val = 0; |
|
394 delete [] data; |
|
395 data = 0; |
|
396 } |
|
397 else |
|
398 { |
|
399 assert (num_ones + num_zeros == len); |
|
400 |
5275
|
401 octave_idx_type *new_data = new octave_idx_type [num_ones]; |
|
402 octave_idx_type k = 0; |
|
403 for (octave_idx_type i = 0; i < len; i++) |
1560
|
404 if (data[i] == 0) |
1650
|
405 new_data[k++] = i; |
1560
|
406 |
|
407 delete [] data; |
|
408 len = num_ones; |
|
409 data = new_data; |
|
410 |
|
411 min_val = max_val = data[0]; |
|
412 |
5275
|
413 octave_idx_type i = 0; |
1560
|
414 do |
|
415 { |
|
416 if (data[i] > max_val) |
|
417 max_val = data[i]; |
|
418 |
|
419 if (data[i] < min_val) |
|
420 min_val = data[i]; |
|
421 } |
|
422 while (++i < len); |
|
423 } |
|
424 } |
1
|
425 } |
|
426 |
5275
|
427 octave_idx_type |
|
428 IDX_VEC_REP::checkelem (octave_idx_type n) const |
227
|
429 { |
|
430 if (n < 0 || n >= len) |
|
431 { |
1560
|
432 (*current_liboctave_error_handler) ("idx-vector: index out of range"); |
227
|
433 return 0; |
|
434 } |
|
435 |
|
436 return elem (n); |
|
437 } |
|
438 |
1552
|
439 static inline int |
3262
|
440 intcmp (const void *ii, const void *jj) |
1552
|
441 { |
5275
|
442 return (*(static_cast<const octave_idx_type *> (ii)) - *(static_cast<const octave_idx_type *> (jj))); |
1552
|
443 } |
|
444 |
1560
|
445 static inline void |
5275
|
446 sort_data (octave_idx_type *d, octave_idx_type l) |
1560
|
447 { |
5275
|
448 qsort (d, l, sizeof (octave_idx_type), intcmp); |
1560
|
449 } |
|
450 |
5275
|
451 static inline octave_idx_type |
|
452 make_uniq (octave_idx_type *d, octave_idx_type l) |
1560
|
453 { |
3125
|
454 if (l < 2) |
|
455 return l; |
|
456 |
5275
|
457 octave_idx_type k = 0; |
|
458 for (octave_idx_type ii = 1; ii < l; ii++) |
1560
|
459 { |
1650
|
460 if (d[ii] != d[k]) |
1560
|
461 { |
|
462 k++; |
1650
|
463 d[k] = d[ii]; |
1560
|
464 } |
|
465 } |
|
466 return k+1; |
|
467 } |
|
468 |
5275
|
469 static inline octave_idx_type * |
|
470 copy_data (const octave_idx_type *d, octave_idx_type l) |
209
|
471 { |
5275
|
472 octave_idx_type *new_data = new octave_idx_type [l]; |
1560
|
473 |
5275
|
474 for (octave_idx_type ii = 0; ii < l; ii++) |
1650
|
475 new_data[ii] = d[ii]; |
1560
|
476 |
|
477 return new_data; |
|
478 } |
|
479 |
|
480 int |
5275
|
481 IDX_VEC_REP::is_colon_equiv (octave_idx_type n, int sort_uniq) |
1560
|
482 { |
|
483 if (! colon_equiv_checked) |
|
484 { |
|
485 if (colon) |
|
486 { |
|
487 colon_equiv = 1; |
|
488 } |
7422
|
489 else if (range) |
|
490 { |
|
491 colon_equiv = (range_base == 0 |
|
492 && len == n |
|
493 && (range_step == 1 |
|
494 || (range_step == -1 && sort_uniq))); |
|
495 } |
5275
|
496 else if (static_cast<octave_idx_type> (len) > 1) |
1560
|
497 { |
3472
|
498 if (one_zero) |
|
499 { |
|
500 colon_equiv = (len == n && ones_count () == n); |
|
501 } |
|
502 else if (sort_uniq) |
2356
|
503 { |
5275
|
504 octave_idx_type *tmp_data = copy_data (data, len); |
2966
|
505 |
2356
|
506 sort_data (tmp_data, len); |
|
507 |
5275
|
508 octave_idx_type tmp_len = make_uniq (tmp_data, len); |
2966
|
509 |
|
510 colon_equiv = (tmp_len == n |
|
511 && tmp_data[0] == 0 |
|
512 && tmp_data[tmp_len-1] == tmp_len - 1); |
1560
|
513 |
2966
|
514 delete [] tmp_data; |
|
515 } |
|
516 else |
|
517 { |
|
518 if (len == n) |
|
519 { |
|
520 colon_equiv = 1; |
1560
|
521 |
5275
|
522 for (octave_idx_type ii = 0; ii < n; ii++) |
2966
|
523 if (data[ii] != ii) |
|
524 { |
|
525 colon_equiv = 0; |
|
526 break; |
|
527 } |
|
528 } |
|
529 } |
1560
|
530 } |
|
531 else |
2966
|
532 colon_equiv = (len == n && (n == 0 || (n == 1 && data[0] == 0))); |
1560
|
533 |
|
534 colon_equiv_checked = 1; |
|
535 } |
|
536 |
|
537 return colon_equiv; |
209
|
538 } |
|
539 |
417
|
540 void |
3079
|
541 IDX_VEC_REP::sort (bool uniq) |
|
542 { |
7422
|
543 if (range && len) |
|
544 { |
|
545 if (range_step < 0) |
|
546 { |
|
547 range_base += (len-1)*(range_step); |
|
548 range_step = -range_step; |
|
549 } |
|
550 } |
|
551 else if (len > 1) |
3125
|
552 { |
|
553 sort_data (data, len); |
3079
|
554 |
3125
|
555 if (uniq) |
|
556 len = make_uniq (data, len); |
|
557 } |
3079
|
558 } |
|
559 |
|
560 void |
5275
|
561 IDX_VEC_REP::shorten (octave_idx_type n) |
434
|
562 { |
|
563 if (n > 0 && n <= len) |
|
564 len = n; |
|
565 else |
1560
|
566 (*current_liboctave_error_handler) |
|
567 ("idx_vector::shorten: internal error!"); |
434
|
568 } |
|
569 |
3504
|
570 std::ostream& |
|
571 IDX_VEC_REP::print (std::ostream& os) const |
1560
|
572 { |
5275
|
573 for (octave_idx_type ii = 0; ii < len; ii++) |
1650
|
574 os << data[ii] << "\n"; |
1560
|
575 return os; |
|
576 } |
|
577 |
5275
|
578 octave_idx_type |
5781
|
579 IDX_VEC_REP::freeze (octave_idx_type z_len, const char *tag, bool resize_ok) |
1
|
580 { |
1560
|
581 if (frozen) |
3680
|
582 return frozen_len; |
1560
|
583 |
|
584 frozen_len = -1; |
|
585 |
|
586 if (colon) |
|
587 frozen_len = z_len; |
|
588 else |
|
589 { |
|
590 if (len == 0) |
|
591 frozen_len = 0; |
|
592 else |
|
593 { |
2828
|
594 maybe_convert_one_zero_to_idx (z_len); |
1560
|
595 |
1650
|
596 max_val = max (); |
|
597 min_val = min (); |
1560
|
598 |
|
599 if (min_val < 0) |
|
600 { |
|
601 if (tag) |
|
602 (*current_liboctave_error_handler) |
|
603 ("invalid %s index = %d", tag, min_val+1); |
|
604 else |
|
605 (*current_liboctave_error_handler) |
|
606 ("invalid index = %d", min_val+1); |
|
607 |
|
608 initialized = 0; |
|
609 } |
|
610 else if (! resize_ok && max_val >= z_len) |
|
611 { |
|
612 if (tag) |
|
613 (*current_liboctave_error_handler) |
|
614 ("invalid %s index = %d", tag, max_val+1); |
|
615 else |
|
616 (*current_liboctave_error_handler) |
|
617 ("invalid index = %d", max_val+1); |
|
618 |
|
619 initialized = 0; |
|
620 } |
|
621 else |
4461
|
622 { |
5781
|
623 if (max_val >= z_len) |
4461
|
624 { |
|
625 if (tag) |
5781
|
626 (*current_liboctave_warning_with_id_handler) |
|
627 ("Octave:resize-on-range-error", |
|
628 "resizing object with %s index = %d out of bounds", |
4461
|
629 tag, max_val+1); |
|
630 else |
5781
|
631 (*current_liboctave_warning_with_id_handler) |
|
632 ("Octave:resize-on-range-error", |
|
633 "resizing object with index = %d out of bounds", |
4461
|
634 max_val+1); |
|
635 } |
|
636 |
|
637 frozen_len = length (z_len); |
|
638 } |
1560
|
639 } |
|
640 } |
|
641 |
|
642 frozen = 1; |
3680
|
643 |
|
644 frozen_at_z_len = z_len ? z_len : len; |
1560
|
645 |
|
646 return frozen_len; |
1
|
647 } |
|
648 |
|
649 /* |
|
650 ;;; Local Variables: *** |
|
651 ;;; mode: C++ *** |
|
652 ;;; End: *** |
|
653 */ |