| blob | e26bd956406990a78c9d6e5bde3944434c7e0d1e |
1 /*----------------------------------------------------------------------*/
2 /* parameter.c */
3 /* Copyright (c) 2002 Tim Edwards, Johns Hopkins University */
4 /*----------------------------------------------------------------------*/
6 /*----------------------------------------------------------------------*/
7 /* written by Tim Edwards, 10/26/99 */
8 /* revised for segmented strings, 3/8/01 */
9 /*----------------------------------------------------------------------*/
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
15 #ifndef XC_WIN32
16 #include <X11/Intrinsic.h>
17 #include <X11/StringDefs.h>
18 #endif
20 #ifdef TCL_WRAPPER
21 #include <tk.h>
22 #else
23 #ifndef XC_WIN32
25 #endif
26 #endif
28 /*----------------------------------------------------------------------*/
29 /* Local includes */
30 /*----------------------------------------------------------------------*/
35 /*----------------------------------------------------------------------*/
36 /* Function prototype declarations */
37 /*----------------------------------------------------------------------*/
40 /*----------------------------------------------------------------------*/
41 /* Externally declared global variables */
42 /*----------------------------------------------------------------------*/
44 #ifdef TCL_WRAPPER
46 #endif
49 #ifndef TCL_WRAPPER
51 #endif
54 /*----------------------------------------------------------------------*/
55 /* The following u_char array matches parameterization types to element */
56 /* types which are able to accept the given parameterization. */
57 /*----------------------------------------------------------------------*/
59 u_char param_select[] = {
76 };
78 #ifdef TCL_WRAPPER
79 #ifndef _MSC_VER
81 /* To be done---map buttons to Tk_Windows! */
82 };
83 #else
85 #endif
86 #else
103 };
104 #endif
106 /*----------------------------------------------------------------------*/
107 /* Basic routines for matching parameters by key values. Note that */
108 /* this really, really ought to be replaced by a hash table search! */
109 /*----------------------------------------------------------------------*/
111 /*----------------------------------------------------------------------*/
112 /* Check for the existance of a parameter with key "key" in object */
113 /* "thisobj". Return true if the parameter exists. */
114 /*----------------------------------------------------------------------*/
117 {
118 oparamptr tops;
125 }
127 /*----------------------------------------------------------------------*/
128 /* Create a new parameter; allocate memory for the parameter and the */
129 /* key. */
130 /*----------------------------------------------------------------------*/
133 {
134 oparamptr newops;
141 }
143 /*----------------------------------------------------------------------*/
144 /* Create a new element (numeric) parameter. Fill in essential values */
145 /*----------------------------------------------------------------------*/
148 {
149 eparamptr newepp;
159 }
161 /*----------------------------------------------------------------------*/
162 /* Determine if a parameter is indirectly referenced. If so, return */
163 /* the parameter name. If not, return NULL. */
164 /*----------------------------------------------------------------------*/
167 {
168 eparamptr epp;
173 }
175 }
177 /*----------------------------------------------------------------------*/
178 /* Find the parameter in the indicated object by key */
179 /*----------------------------------------------------------------------*/
182 {
183 oparamptr fparam;
190 }
192 /*----------------------------------------------------------------------*/
193 /* Find the parameter in the indicated instance by key. If no such */
194 /* instance value exists, return NULL. */
195 /*----------------------------------------------------------------------*/
198 {
199 oparamptr fparam;
206 }
208 /*----------------------------------------------------------------------*/
209 /* Find the parameter in the indicated instance by key. If no such */
210 /* instance value exists, return the object (default) parameter. */
211 /* */
212 /* find_param() hides instances of expression parameters, returning the */
213 /* default parameter value. In cases where the instance value (last */
214 /* evaluated expression result) is needed, use match_instance_param(). */
215 /* An exception is made when the instance param has type XC_EXPR, */
216 /* indicating that the instance redefines the entire expression. */
217 /*----------------------------------------------------------------------*/
220 {
228 }
230 /*----------------------------------------------------------------------*/
231 /* Find the total number of parameters in an object */
232 /*----------------------------------------------------------------------*/
235 {
236 oparamptr fparam;
240 nparam++;
242 }
244 /*----------------------------------------------------------------------*/
245 /* Remove all element parameters from an element */
246 /*----------------------------------------------------------------------*/
249 {
252 }
254 /*----------------------------------------------------------------------*/
255 /* Remove an element parameter (eparam) and free memory associated with */
256 /* the parameter key. */
257 /*----------------------------------------------------------------------*/
260 {
267 else
270 /* If object is an instance and the pdata record is not NULL, */
271 /* then this is an indirect reference with the reference key */
272 /* stored as an allocated string in pdata.refkey, which needs */
273 /* to be free'd. */
281 }
283 }
284 }
286 /*----------------------------------------------------------------------*/
287 /* Free an instance parameter. Note that this routine does not free */
288 /* any strings associated with string parameters! */
289 /* */
290 /* Return a pointer to the entry before the one deleted, so we can use */
291 /* free_instance_param() inside a loop over an instance's parameters */
292 /* without having to keep track of the previous pointer position. */
293 /*----------------------------------------------------------------------*/
296 {
303 else
308 }
310 }
312 }
314 /*----------------------------------------------------------------------*/
315 /* Convenience function used by files.c to set a color parameter. */
316 /*----------------------------------------------------------------------*/
319 {
320 eparamptr epp;
327 }
329 /*----------------------------------------------*/
330 /* Draw a circle at all parameter positions */
331 /*----------------------------------------------*/
334 {
336 oparamptr ops;
337 eparamptr epp;
346 else
370 else
377 }
379 }
380 }
381 }
382 }
384 /*----------------------------------------------*/
385 /* Set the menu marks according to properties */
386 /* which are parameterized. Unmanage the */
387 /* buttons which do not apply. */
388 /* */
389 /* pgen = NULL returns menu to default settings */
390 /*----------------------------------------------*/
392 #ifdef TCL_WRAPPER
394 {
395 /* Set GUI variables associated with the "parameter" menu. */
398 oparamptr ops;
399 eparamptr epp;
405 /* For each parameter declared, set the corresponding Tcl variable */
413 }
414 }
416 /* Now reset all of those parameters that were not set above. */
417 /* Note that the parameters that we want to mark ignore the following types: */
418 /* "numeric", "substring", "expression", and "position". */
423 }
424 #else
427 {
428 Widget w;
432 oparamptr ops;
433 eparamptr epp;
435 /* Clear all checkmarks */
440 }
442 /* Check those properties which are parameterized in the element */
450 }
451 }
453 /* Unmanage widgets which do not apply to the element type */
458 else
460 }
461 }
463 #endif
465 /*------------------------------------------------------*/
466 /* This function is like epsubstitute() below it, but */
467 /* only substitutes those values that are expression */
468 /* types. This allows constraints to be applied when */
469 /* editing elements. */
470 /*------------------------------------------------------*/
473 {
475 eparamptr epp;
495 else
504 }
507 }
516 }
517 }
525 }
528 }
537 }
538 }
539 }
540 }
541 }
542 }
544 /*------------------------------------------------------*/
545 /* Make numerical parameter substitutions into an */
546 /* element. */
547 /*------------------------------------------------------*/
551 {
553 eparamptr epp;
564 /* Use the parameter from the instance, if available. */
565 /* Otherwise, revert to the type of the object. */
566 /* Normally they will be the same. */
573 /* Get integer and float values. Promote types if necessary */
588 else
598 }
599 }
606 objinstptr thisinst;
611 /* Sanity check: refkey must exist in object */
618 }
620 /* If an instance value already exists, remove it */
625 /* Create a new instance parameter */
630 /* Change the key from the parent to the child */
634 }
636 }
637 }
641 else
653 }
656 }
664 }
665 }
669 }
671 }
672 }
673 }
679 }
683 }
684 }
693 }
694 }
698 }
707 }
708 }
711 }
723 }
734 }
737 }
745 }
746 }
750 }
752 }
753 }
754 }
760 }
764 }
765 }
774 }
775 }
779 }
788 }
789 }
792 }
804 }
821 }
829 }
838 }
847 }
857 }
866 }
877 }
888 }
905 }
911 }
912 }
915 }
917 /*------------------------------------------------------*/
918 /* Make numerical parameter substitutions into all */
919 /* elements of an object. "thisinst" may be NULL, in */
920 /* which case all default values are used in the */
921 /* substitution. */
922 /* */
923 /* Return values: */
924 /* -1 if the instance declares no parameters */
925 /* 0 if parameters do not change the instance's bbox */
926 /* 1 if parameters change instance's bbox */
927 /* 2 if parameters change instance's netlist */
928 /*------------------------------------------------------*/
931 {
937 /* Perform expression parameter substitutions on all labels. */
938 /* Note that this used to be done on an immediate basis as */
939 /* labels were parsed. The main difference is that only one */
940 /* expression parameter can be used per label if it is to */
941 /* compute the result of some aspect of the label, such as */
942 /* position; this is a tradeoff for much simplified handling */
943 /* of expression results, like having to avoid infinite */
944 /* recursion in an expression result. */
961 /* substitutions into arcs and splines require that the */
962 /* line segments be recalculated. */
978 }
979 }
980 }
982 }
984 /*------------------------------------------------------*/
985 /* Same as above, but determines the object from the */
986 /* current page hierarchy. */
987 /*------------------------------------------------------*/
990 {
991 objinstptr pinst;
992 objectptr thisobj;
999 }
1001 /*----------------------------------------------*/
1002 /* Check if an element contains a parameter. */
1003 /*----------------------------------------------*/
1006 {
1013 }
1016 }
1018 /*------------------------------------------------------*/
1019 /* Find "current working values" in the element list of */
1020 /* an object, and write them into the instance's */
1021 /* parameter list. */
1022 /* This is just the opposite of "psubstitute()", except */
1023 /* that instance values are created prior to writeback, */
1024 /* and resolved afterward. */
1025 /*------------------------------------------------------*/
1028 {
1030 objectptr thisobj;
1031 objinstptr pinst;
1032 eparamptr epp;
1045 /* Make sure that all instance values exist */
1048 /* Because more than one element can point to the same parameter, we search */
1049 /* through each (numerical) parameter declared in the object. If any */
1050 /* element has a different value, the parameter is changed to match. This */
1051 /* operates on the assumption that no more than one element will change the */
1052 /* value of any one parameter on a single call to pwriteback(). */
1055 /* handle pre-assigned numeric parameters only */
1067 found++;
1070 else
1095 else
1100 }
1101 else
1104 }
1127 else
1132 }
1133 else
1136 }
1152 }
1159 }
1166 }
1173 }
1180 }
1187 }
1197 }
1207 }
1223 }
1228 }
1237 }
1240 }
1241 }
1242 }
1243 }
1245 /* Any instance values which are identical to the default value */
1246 /* get erased (so they won't be written to the output unnecessarily) */
1253 }
1255 /* Because more than one element may use the same parameter, */
1256 /* pwriteback checks for cases in which a change in one element */
1257 /* precipitates a change in another. If so, force a redraw. */
1261 }
1263 /*------------------------------------------------------*/
1264 /* If the instance comes from the library, replace the */
1265 /* default value with the instance value. */
1266 /*------------------------------------------------------*/
1269 {
1270 objectptr thisobj;
1272 /* int i, nullparms = 0; (jdk) */
1286 }
1289 /* Expression parameters should be replaced *only* if the
1290 * instance value is also an expression, and not an evaluated
1291 * result.
1292 */
1298 }
1304 }
1306 }
1307 }
1308 }
1310 /*------------------------------------------------------*/
1311 /* Resolve differences between the object instance */
1312 /* parameters and the default parameters. If they */
1313 /* are the same for any parameter, delete that instance */
1314 /* such that the instance reverts to the default value. */
1315 /*------------------------------------------------------*/
1318 {
1319 objectptr thisobj;
1320 liblistptr spec;
1324 /* If the instance has no parameters itself, ignore it. */
1327 /* If the object was pushed into from a library, we want to change */
1328 /* the default, not the instanced, parameter values. However, this */
1329 /* is not true for "virtual" library objects (in the instlist) */
1338 /* Fprintf(stdout, "Came from library: changing default value\n"); */
1341 }
1342 }
1344 /* Parameters which are changed on a top-level page must also change */
1345 /* the default value; otherwise, the instance value shadows the page */
1346 /* object's value but the page object's value is the one written to */
1347 /* the output file. */
1352 }
1360 /* If type or which fields do not match, then we don't need to look */
1361 /* any further; object and instance have different parameters. */
1369 }
1375 }
1380 }
1382 }
1383 }
1386 /* Object must recompute bounding box if any instance */
1387 /* uses a non-default parameter. */
1390 }
1391 }
1393 /*--------------------------------------------------------------*/
1394 /* Return a copy of the single eparameter "cepp" */
1395 /*--------------------------------------------------------------*/
1398 {
1399 eparamptr newepp;
1404 else
1408 }
1410 /*------------------------------------------------------*/
1411 /* Copy all element parameters from source to dest */
1412 /*------------------------------------------------------*/
1415 {
1422 }
1423 }
1425 /*--------------------------------------------------------------*/
1426 /* Return a copy of the single parameter "cops" */
1427 /*--------------------------------------------------------------*/
1430 {
1431 oparamptr newops;
1449 }
1451 }
1453 /*------------------------------------------------------*/
1454 /* Fill any NULL instance parameters with the values */
1455 /* from the calling instance, or from the instance */
1456 /* object's defaults if destinst = sourceinst. */
1457 /* */
1458 /* Expression parameters get special treatment because */
1459 /* the instance value may be holding the last evaluated */
1460 /* expression, not an instance value of the expression. */
1461 /* If so, its type will be XC_STRING or XC_FLOAT, not */
1462 /* XC_EXPR. */
1463 /*------------------------------------------------------*/
1466 {
1472 else
1480 }
1483 }
1484 }
1486 /*--------------------------------------------------------------*/
1487 /* Make an unreferenced parameter expression in the object */
1488 /* refobject. */
1489 /* The expression may have either a numeric or string result. */
1490 /* the proper "which" value is passed as an argument. */
1491 /* */
1492 /* Return NULL if unsuccessful, the parameter key (which may */
1493 /* have been modified by checkvalidname()) otherwise. */
1494 /*--------------------------------------------------------------*/
1497 {
1498 oparamptr newops;
1502 /* Check against object names, which are reserved words */
1508 pidx++;
1510 }
1512 }
1514 /* Check parameter key for valid name syntax */
1519 /* Ensure that no two parameters have the same name! */
1525 }
1526 }
1538 }
1540 /*------------------------------------------------------------------*/
1541 /* Make an unreferenced numerical parameter in the object refobject */
1542 /* */
1543 /* Return FALSE if unsuccessful, TRUE otherwise. */
1544 /*------------------------------------------------------------------*/
1547 {
1548 oparamptr newops;
1551 /* Check against object names, which are reserved words */
1556 /* Ensure that no two parameters have the same name! */
1562 }
1574 }
1576 /*----------------------------------------------------------------*/
1577 /* Make an unreferenced string parameter in the object refobject. */
1578 /* Return FALSE if unsuccessful, TRUE otherwise. */
1579 /*----------------------------------------------------------------*/
1582 {
1583 oparamptr newops;
1586 /* Check against object names, which are reserved words */
1591 /* Ensure that no two parameters have the same name! */
1597 }
1609 }
1611 /*--------------------------------------------------------------*/
1612 /* Return the built-in parameter key corresponding to a */
1613 /* parameter type (as defined in xcircuit.h). */
1614 /* */
1615 /* Numerical parameters have designated keys to avoid the */
1616 /* necessity of having to specify a key, to avoid conflicts */
1617 /* with PostScript predefined keys, and other good reasons. */
1618 /*--------------------------------------------------------------*/
1621 {
1625 "p_bad"
1626 };
1630 }
1632 /*--------------------------------------------------------------*/
1633 /* Make a numerical (integer or float) parameter. */
1634 /* If "key" is non-NULL, then the parameter key will be set */
1635 /* from this rather than from the list "param_keys". If the */
1636 /* key is an existing key with the same type as "mode", then */
1637 /* the new parameter will be linked to the existing one. */
1638 /*--------------------------------------------------------------*/
1641 {
1644 eparamptr epp;
1650 /* Parameterized strings are handled by makeparam() */
1655 }
1657 /* Make sure the parameter doesn't already exist. */
1665 {
1669 }
1670 }
1674 }
1675 }
1676 }
1678 /* Ensure that no two parameters have the same name! */
1683 }
1688 pidx++;
1690 }
1692 }
1694 /* Add the parameter to the element's parameter list */
1700 /* If keyptr does not point to an existing parameter, then we need */
1701 /* to create it in the object's parameter list and set the default */
1702 /* value to the existing value of the element. */
1712 }
1719 }
1729 }
1731 /* If the parameter exists and the instance has a non-default */
1732 /* value for it, we will not change the instance record. If */
1733 /* the element value is different, then it will change, so we */
1734 /* should redraw. */
1737 }
1738 }
1764 }
1795 }
1813 }
1827 }
1831 }
1841 }
1845 }
1855 }
1869 }
1873 }
1883 }
1887 }
1897 }
1905 else
1908 }
1913 }
1929 }
1933 }
1936 pathpgen++) {
1941 }
1942 }
1947 }
1948 }
1949 }
1950 }
1954 else
1958 }
1967 }
1971 }
1974 pathpgen++) {
1979 }
1980 }
1985 }
1986 }
1987 }
1988 }
1992 else
1996 }
1998 }
2000 }
2001 }
2003 param_done:
2005 }
2007 /*--------------------------------------------------------------*/
2008 /* Remove a numerical (integer or float) parameter. Remove by */
2009 /* type, rather than key. There may be several keys associated */
2010 /* with a particular type, so we want to remove all of them. */
2011 /*--------------------------------------------------------------*/
2014 {
2016 eparamptr epp;
2017 oparamptr ops;
2021 /* Parameterized strings are handled by makeparam() */
2025 }
2027 /* Avoid referencing the object by only looking at the element. */
2028 /* But, avoid dereferencing the pointer! */
2040 /* check for any other references to the parameter. If there */
2041 /* are none, remove all instance records of the eparam, then */
2042 /* remove the parameter itself from the object. */
2051 }
2052 }
2054 }
2060 }
2061 }
2062 }
2063 }
2065 #ifndef TCL_WRAPPER
2067 /*--------------------------------------------------------------*/
2068 /* Insert an existing parameter into a string. */
2069 /* This code needs to be replaced in the non-Tcl version with */
2070 /* a new pop-up window using a callback to labeltext(). */
2071 /* */
2072 /* This routine has been replaced in the Tcl version with a */
2073 /* callback to command "label insert parameter" from the */
2074 /* parameter-select pop-up window. */
2075 /*--------------------------------------------------------------*/
2078 {
2079 labelptr tlab;
2080 oparamptr ops;
2087 /* Don't allow nested parameters */
2093 }
2101 nparms++;
2105 }
2111 }
2112 }
2114 /* If only one parameter, then automatically use it. Otherwise, */
2115 /* prompt for which parameter to use. */
2125 i++;
2126 }
2127 }
2128 }
2136 else
2138 }
2140 #endif
2142 /*--------------------------------------------------------------*/
2143 /* Parameterize a label string. */
2144 /*--------------------------------------------------------------*/
2147 {
2148 oparamptr newops;
2152 /* Ensure that no two parameters have the same name! */
2158 }
2160 /* make sure this does not overlap another parameter */
2166 }
2168 /* Check parameter for valid name syntax */
2173 /* First, place PARAM_START and PARAM_END structures at the */
2174 /* intended parameter boundaries */
2177 /* partial string */
2181 /* Because "splitstring" changes all the pointers, find the */
2182 /* stringpart structures at textend and textpos positions. */
2189 /* Make the new segments for PARAM_START and PARAM_END. */
2193 }
2195 /* Don't include the first font designator as part of the */
2196 /* parameter or else havoc ensues. */
2201 }
2205 }
2207 }
2214 /* Now move the sections of string to the object parameter */
2228 }
2230 /*--------------------------------------------------------------*/
2231 /* Destroy the selected parameter in the indicated instance */
2232 /*--------------------------------------------------------------*/
2235 {
2236 oparamptr ops;
2237 /* short k; (jdk) */
2247 }
2248 }
2249 }
2251 /*--------------------------------------------------------------*/
2252 /* Search and destroy the selected parameter in all instances */
2253 /* of the specified object. */
2254 /*--------------------------------------------------------------*/
2257 {
2258 objinstptr tinst;
2267 }
2268 }
2269 }
2271 /*--------------------------------------------------------------*/
2272 /* Destroy the object parameter with key "key" in the object */
2273 /* "thisobj". This requires first tracking down and removing */
2274 /* all instances of the parameter which may exist anywhere in */
2275 /* the database. */
2276 /*--------------------------------------------------------------*/
2279 {
2281 liblistptr spec;
2286 /* Find all instances of this object and remove any parameter */
2287 /* substitutions which may have been made. */
2292 }
2297 else
2299 }
2300 }
2302 /* Ensure that this parameter is not referred to in the undo records */
2303 /* We could be kinder and gentler to the undo record here. . . */
2306 /* Also check through all instances on the library page */
2311 /* Remove the parameter from any labels that it might occur in */
2327 }
2328 }
2329 }
2330 }
2331 }
2332 }
2334 /* Remove the parameter from the object itself, tidying up */
2335 /* the linked list after it. */
2341 else
2346 }
2348 }
2351 }
2353 /*--------------------------------------------------------------*/
2354 /* Check if this string contains a parameter */
2355 /*--------------------------------------------------------------*/
2358 {
2364 }
2366 /*--------------------------------------------------------------*/
2367 /* Remove parameterization from a label string or substring. */
2368 /*--------------------------------------------------------------*/
2371 {
2372 oparamptr ops;
2373 oparamptr testop;
2377 /* make sure there is a parameter here */
2382 }
2385 /* Unparameterizing can cause a change in the string */
2388 /* Methodology change 7/20/06: Remove only the instance of the */
2389 /* parameter. The parameter itself will be deleted by a different */
2390 /* method, using free_object_param(). */
2399 /* Copy the default parameter into the place we are unparameterizing */
2400 /* Promote first to a string type if necessary */
2407 /* Delete the "PARAM_END" off of the copied string and link it */
2408 /* into the existing string. */
2409 /* (NOTE: If parameter is an empty string, there may be nothing */
2410 /* before PARAM_END. . .) */
2417 }
2423 }
2425 /* Remove dangling link from instance parameter */
2426 /* (If this was a global parameter, it will have no effect) */
2430 }
2432 /* This should not happen */
2436 }
2442 }
2445 else
2449 /* Merge strings at boundaries, if possible. */
2454 }
2456 /*----------------------------------------------------------------------*/
2457 /* Wrapper for unmakeparam(). Remove a parameterized substring from a */
2458 /* label, or remove a numeric parameter from an element. */
2459 /* */
2460 /* NOTE: This routine should not combine the instance-only string */
2461 /* parameter removal and the numeric parameter deletion, which is */
2462 /* fundamentally different in nature. */
2463 /*----------------------------------------------------------------------*/
2466 {
2470 labelptr settext;
2476 }
2477 else
2480 // NOTE: Need a different method for interactive edit; remove only the
2481 // parameter under the cursor.
2484 /* ETEXT_MODE implies there is only one selected label */
2489 /* Assume the cursor is inside a parameter and find the end */
2499 /* tmpptr now points to the parameter to be removed */
2502 }
2503 }
2505 }
2506 }
2508 }
2521 /* Search for parameter boundary, in case selection doesn't include */
2522 /* the whole parameter or the parameter start marker. */
2527 /* Finish search, unlinking any parameter we might be inside */
2531 }
2536 u_char found;
2540 // Remove all parameters from the string.
2550 }
2552 }
2553 }
2554 }
2558 }
2559 else
2561 }
2563 }
2564 }
2566 /*--------------------------------------------------------------*/
2567 /* Wrapper for makeparam() */
2568 /*--------------------------------------------------------------*/
2571 {
2573 labelptr settext;
2574 Boolean preselected;
2581 }
2582 else
2591 }
2595 }
2596 else
2598 }
2601 }
2603 /*----------------------------------------------------------------------*/
2604 /* Looks for a parameter overlapping the textend <--> textpos space. */
2605 /* Returns True if there is a parameter in this space. */
2606 /*----------------------------------------------------------------------*/
2609 {
2616 /* This text position can't be inside another parameter */
2620 /* The area between textend and textpos cannot contain a parameter */
2629 }
2631 /*----------------------------------------------------------------------*/
2632 /* Check whether this page object was entered via a library page */
2633 /*----------------------------------------------------------------------*/
2636 {
2638 pushlistptr thispush;
2645 }
2647 /*----------------------------------------------------------------------*/
2648 /* Remove all parameters from an object instance */
2649 /* (Reverts all parameters to default value) */
2650 /*----------------------------------------------------------------------*/
2653 {
2654 oparamptr ops;
2665 }
2666 }
2668 /*----------------------------------------------------------------------*/
2669 /* Remove all parameters from an object. */
2670 /*----------------------------------------------------------------------*/
2673 {
2674 oparamptr ops;
2685 }
2687 }
2689 /*-----------------------------------------------------------------------*/