| blob | 884fe4dca13b15ddcdf732b3539c6d5e4dbddef7 |
1 /*-------------------------------------------------------------------------
2 *
3 * nodeFuncs.c
4 * Various general-purpose manipulations of Node trees
5 *
6 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * $PostgreSQL$
12 *
13 *-------------------------------------------------------------------------
14 */
29 /*
30 * exprType -
31 * returns the Oid of the type of the expression. (Used for typechecking.)
32 */
33 Oid
35 {
36 Oid type;
42 {
56 {
59 /* slice and/or store operations yield the array type */
62 else
64 }
82 {
87 {
88 /* get the type of the subselect's first target column */
99 {
106 }
107 }
108 else
109 {
110 /* for all other sublink types, result is boolean */
112 }
113 }
116 {
117 /*
118 * Although the parser does not ever deal with already-planned
119 * expression trees, we support SubPlan nodes in this routine
120 * for the convenience of ruleutils.c.
121 */
126 {
127 /* get the type of the subselect's first target column */
130 {
137 }
138 }
139 else
140 {
141 /* for all other subplan types, result is boolean */
143 }
144 }
147 {
148 /* As above, supported for the convenience of ruleutils.c */
151 /* subplans should all return the same thing */
153 }
199 else
230 }
232 }
234 /*
235 * exprTypmod -
236 * returns the type-specific attrmod of the expression, if it can be
237 * determined. In most cases, it can't and we return -1.
238 */
239 int32
241 {
246 {
254 /* typmod is the same for array or element */
257 {
258 int32 coercedTypmod;
260 /* Be smart about length-coercion functions... */
263 }
266 {
271 {
272 /* get the typmod of the subselect's first target column */
282 /* note we don't need to care if it's an array */
283 }
284 }
293 {
294 /*
295 * If all the alternatives agree on type/typmod, return that
296 * typmod, else use -1
297 */
300 int32 typmod;
311 {
319 }
321 }
326 {
327 /*
328 * If all the elements agree on type/typmod, return that
329 * typmod, else use -1
330 */
332 Oid commontype;
333 int32 typmod;
343 else
346 {
353 }
355 }
358 {
359 /*
360 * If all the alternatives agree on type/typmod, return that
361 * typmod, else use -1
362 */
365 int32 typmod;
374 {
381 }
383 }
386 {
387 /*
388 * If all the alternatives agree on type/typmod, return that
389 * typmod, else use -1
390 */
393 int32 typmod;
402 {
409 }
411 }
414 {
418 }
430 }
432 }
434 /*
435 * exprIsLengthCoercion
436 * Detect whether an expression tree is an application of a datatype's
437 * typmod-coercion function. Optionally extract the result's typmod.
438 *
439 * If coercedTypmod is not NULL, the typmod is stored there if the expression
440 * is a length-coercion function, else -1 is stored there.
441 *
442 * Note that a combined type-and-length coercion will be treated as a
443 * length coercion by this routine.
444 */
445 bool
447 {
451 /*
452 * Scalar-type length coercions are FuncExprs, array-type length coercions
453 * are ArrayCoerceExprs
454 */
456 {
461 /*
462 * If it didn't come from a coercion context, reject.
463 */
468 /*
469 * If it's not a two-argument or three-argument function with the
470 * second argument being an int4 constant, it can't have been created
471 * from a length coercion (it must be a type coercion, instead).
472 */
483 /*
484 * OK, it is indeed a length-coercion function.
485 */
490 }
493 {
496 /* It's not a length coercion unless there's a nondefault typmod */
500 /*
501 * OK, it is indeed a length-coercion expression.
502 */
507 }
510 }
512 /*
513 * expression_returns_set
514 * Test whether an expression returns a set result.
515 *
516 * Because we use expression_tree_walker(), this can also be applied to
517 * whole targetlists; it'll produce TRUE if any one of the tlist items
518 * returns a set.
519 */
520 bool
522 {
524 }
526 static bool
528 {
532 {
537 /* else fall through to check args */
538 }
540 {
545 /* else fall through to check args */
546 }
548 /* Avoid recursion for some cases that can't return a set */
579 context);
580 }
583 /*
584 * exprLocation -
585 * returns the parse location of an expression tree, for error reports
586 *
587 * -1 is returned if the location can't be determined.
588 *
589 * For expressions larger than a single token, the intent here is to
590 * return the location of the expression's leftmost token, not necessarily
591 * the topmost Node's location field. For example, an OpExpr's location
592 * field will point at the operator name, but if it is not a prefix operator
593 * then we should return the location of the left-hand operand instead.
594 * The reason is that we want to reference the entire expression not just
595 * that operator, and pointing to its start seems to be the most natural way.
596 *
597 * The location is not perfect --- for example, since the grammar doesn't
598 * explicitly represent parentheses in the parsetree, given something that
599 * had been written "(a + b) * c" we are going to point at "a" not "(".
600 * But it should be plenty good enough for error reporting purposes.
601 *
602 * You might think that this code is overly general, for instance why check
603 * the operands of a FuncExpr node, when the function name can be expected
604 * to be to the left of them? There are a couple of reasons. The grammar
605 * sometimes builds expressions that aren't quite what the user wrote;
606 * for instance x IS NOT BETWEEN ... becomes a NOT-expression whose keyword
607 * pointer is to the right of its leftmost argument. Also, nodes that were
608 * inserted implicitly by parse analysis (such as FuncExprs for implicit
609 * coercions) will have location -1, and so we can have odd combinations of
610 * known and unknown locations in a tree.
611 */
612 int
614 {
620 {
634 /* function name should always be the first thing */
638 /* just use array argument's location */
642 {
645 /* consider both function name and leftmost arg */
648 }
653 {
656 /* consider both operator name and leftmost arg */
659 }
662 {
665 /* consider both operator name and leftmost arg */
668 }
671 {
674 /*
675 * Same as above, to handle either NOT or AND/OR. We can't
676 * special-case NOT because of the way that it's used for
677 * things like IS NOT BETWEEN.
678 */
681 }
684 {
687 /* check the testexpr, if any, and the operator/keyword */
690 }
693 /* just use argument's location */
697 /* just use argument's location */
701 {
704 /* Much as above */
707 }
710 {
713 /* Much as above */
716 }
719 {
722 /* Much as above */
725 }
728 {
731 /* Much as above */
734 }
737 /* CASE keyword should always be the first thing */
741 /* WHEN keyword should always be the first thing */
745 /* the location points at ARRAY or [, which must be leftmost */
749 /* the location points at ROW or (, which must be leftmost */
753 /* just use leftmost argument's location */
757 /* COALESCE keyword should always be the first thing */
761 /* GREATEST/LEAST keyword should always be the first thing */
765 {
768 /* consider both function name and leftmost arg */
771 }
774 /* just use argument's location */
778 /* just use argument's location */
782 {
785 /* Much as above */
788 }
797 /* just use argument's location */
801 /* use the contained RangeVar's location --- close enough */
805 {
806 /* report location of first list member that has a location */
811 {
815 }
816 }
819 {
822 /* use leftmost of operator or left operand (if any) */
823 /* we assume right operand can't be to left of operator */
826 }
838 {
841 /* consider both function name and leftmost arg */
844 }
847 /* the location points at ARRAY or [, which must be leftmost */
851 /* we need not examine the contained expression (if any) */
855 {
858 /*
859 * This could represent CAST(), ::, or TypeName 'literal',
860 * so any of the components might be leftmost.
861 */
865 }
868 /* just use argument's location (ignore operator, if any) */
875 /* XMLSERIALIZE keyword should always be the first thing */
885 /* just use argument's location */
889 /* for any other node type it's just unknown... */
892 }
894 }
896 /*
897 * leftmostLoc - support for exprLocation
898 *
899 * Take the minimum of two parse location values, but ignore unknowns
900 */
901 static int
903 {
908 else
910 }
913 /*
914 * Standard expression-tree walking support
915 *
916 * We used to have near-duplicate code in many different routines that
917 * understood how to recurse through an expression node tree. That was
918 * a pain to maintain, and we frequently had bugs due to some particular
919 * routine neglecting to support a particular node type. In most cases,
920 * these routines only actually care about certain node types, and don't
921 * care about other types except insofar as they have to recurse through
922 * non-primitive node types. Therefore, we now provide generic tree-walking
923 * logic to consolidate the redundant "boilerplate" code. There are
924 * two versions: expression_tree_walker() and expression_tree_mutator().
925 */
927 /*
928 * expression_tree_walker() is designed to support routines that traverse
929 * a tree in a read-only fashion (although it will also work for routines
930 * that modify nodes in-place but never add/delete/replace nodes).
931 * A walker routine should look like this:
932 *
933 * bool my_walker (Node *node, my_struct *context)
934 * {
935 * if (node == NULL)
936 * return false;
937 * // check for nodes that special work is required for, eg:
938 * if (IsA(node, Var))
939 * {
940 * ... do special actions for Var nodes
941 * }
942 * else if (IsA(node, ...))
943 * {
944 * ... do special actions for other node types
945 * }
946 * // for any node type not specially processed, do:
947 * return expression_tree_walker(node, my_walker, (void *) context);
948 * }
949 *
950 * The "context" argument points to a struct that holds whatever context
951 * information the walker routine needs --- it can be used to return data
952 * gathered by the walker, too. This argument is not touched by
953 * expression_tree_walker, but it is passed down to recursive sub-invocations
954 * of my_walker. The tree walk is started from a setup routine that
955 * fills in the appropriate context struct, calls my_walker with the top-level
956 * node of the tree, and then examines the results.
957 *
958 * The walker routine should return "false" to continue the tree walk, or
959 * "true" to abort the walk and immediately return "true" to the top-level
960 * caller. This can be used to short-circuit the traversal if the walker
961 * has found what it came for. "false" is returned to the top-level caller
962 * iff no invocation of the walker returned "true".
963 *
964 * The node types handled by expression_tree_walker include all those
965 * normally found in target lists and qualifier clauses during the planning
966 * stage. In particular, it handles List nodes since a cnf-ified qual clause
967 * will have List structure at the top level, and it handles TargetEntry nodes
968 * so that a scan of a target list can be handled without additional code.
969 * Also, RangeTblRef, FromExpr, JoinExpr, and SetOperationStmt nodes are
970 * handled, so that query jointrees and setOperation trees can be processed
971 * without additional code.
972 *
973 * expression_tree_walker will handle SubLink nodes by recursing normally
974 * into the "testexpr" subtree (which is an expression belonging to the outer
975 * plan). It will also call the walker on the sub-Query node; however, when
976 * expression_tree_walker itself is called on a Query node, it does nothing
977 * and returns "false". The net effect is that unless the walker does
978 * something special at a Query node, sub-selects will not be visited during
979 * an expression tree walk. This is exactly the behavior wanted in many cases
980 * --- and for those walkers that do want to recurse into sub-selects, special
981 * behavior is typically needed anyway at the entry to a sub-select (such as
982 * incrementing a depth counter). A walker that wants to examine sub-selects
983 * should include code along the lines of:
984 *
985 * if (IsA(node, Query))
986 * {
987 * adjust context for subquery;
988 * result = query_tree_walker((Query *) node, my_walker, context,
989 * 0); // adjust flags as needed
990 * restore context if needed;
991 * return result;
992 * }
993 *
994 * query_tree_walker is a convenience routine (see below) that calls the
995 * walker on all the expression subtrees of the given Query node.
996 *
997 * expression_tree_walker will handle SubPlan nodes by recursing normally
998 * into the "testexpr" and the "args" list (which are expressions belonging to
999 * the outer plan). It will not touch the completed subplan, however. Since
1000 * there is no link to the original Query, it is not possible to recurse into
1001 * subselects of an already-planned expression tree. This is OK for current
1002 * uses, but may need to be revisited in future.
1003 */
1005 bool
1009 {
1012 /*
1013 * The walker has already visited the current node, and so we need only
1014 * recurse into any sub-nodes it has.
1015 *
1016 * We assume that the walker is not interested in List nodes per se, so
1017 * when we expect a List we just recurse directly to self without
1018 * bothering to call the walker.
1019 */
1023 /* Guard against stack overflow due to overly complex expressions */
1027 {
1036 /* primitive node types with no expression subnodes */
1039 {
1042 /* recurse directly on List */
1046 }
1049 {
1052 /* recurse directly for upper/lower array index lists */
1059 /* walker must see the refexpr and refassgnexpr, however */
1064 }
1067 {
1073 }
1076 {
1082 }
1085 {
1091 }
1094 {
1100 }
1103 {
1109 }
1112 {
1118 /*
1119 * Also invoke the walker on the sublink's Query node, so it
1120 * can recurse into the sub-query if it wants to.
1121 */
1123 }
1126 {
1129 /* recurse into the testexpr, but not into the Plan */
1132 /* also examine args list */
1136 }
1143 {
1150 }
1161 {
1166 /* we assume walker doesn't care about CaseWhens, either */
1168 {
1176 }
1179 }
1184 /* Assume colnames isn't interesting */
1187 {
1194 }
1201 {
1206 /* we assume walker doesn't care about arg_names */
1209 }
1222 /* Do nothing with a sub-Query, per discussion above */
1225 {
1228 /*
1229 * Invoke the walker on the CTE's Query node, so it
1230 * can recurse into the sub-query if it wants to.
1231 */
1233 }
1237 {
1240 }
1243 {
1250 }
1253 {
1263 /*
1264 * alias clause, using list are deemed uninteresting.
1265 */
1266 }
1269 {
1277 /* groupClauses are deemed uninteresting */
1278 }
1281 {
1286 }
1291 {
1297 }
1305 }
1307 }
1309 /*
1310 * query_tree_walker --- initiate a walk of a Query's expressions
1311 *
1312 * This routine exists just to reduce the number of places that need to know
1313 * where all the expression subtrees of a Query are. Note it can be used
1314 * for starting a walk at top level of a Query regardless of whether the
1315 * walker intends to descend into subqueries. It is also useful for
1316 * descending into subqueries within a walker.
1317 *
1318 * Some callers want to suppress visitation of certain items in the sub-Query,
1319 * typically because they need to process them specially, or don't actually
1320 * want to recurse into subqueries. This is supported by the flags argument,
1321 * which is the bitwise OR of flag values to suppress visitation of
1322 * indicated items. (More flag bits may be added as needed.)
1323 */
1324 bool
1329 {
1347 {
1350 }
1354 }
1356 /*
1357 * range_table_walker is just the part of query_tree_walker that scans
1358 * a query's rangetable. This is split out since it can be useful on
1359 * its own.
1360 */
1361 bool
1366 {
1370 {
1373 /* For historical reasons, visiting RTEs is not the default */
1379 {
1383 /* nothing to do */
1403 }
1404 }
1406 }
1409 /*
1410 * expression_tree_mutator() is designed to support routines that make a
1411 * modified copy of an expression tree, with some nodes being added,
1412 * removed, or replaced by new subtrees. The original tree is (normally)
1413 * not changed. Each recursion level is responsible for returning a copy of
1414 * (or appropriately modified substitute for) the subtree it is handed.
1415 * A mutator routine should look like this:
1416 *
1417 * Node * my_mutator (Node *node, my_struct *context)
1418 * {
1419 * if (node == NULL)
1420 * return NULL;
1421 * // check for nodes that special work is required for, eg:
1422 * if (IsA(node, Var))
1423 * {
1424 * ... create and return modified copy of Var node
1425 * }
1426 * else if (IsA(node, ...))
1427 * {
1428 * ... do special transformations of other node types
1429 * }
1430 * // for any node type not specially processed, do:
1431 * return expression_tree_mutator(node, my_mutator, (void *) context);
1432 * }
1433 *
1434 * The "context" argument points to a struct that holds whatever context
1435 * information the mutator routine needs --- it can be used to return extra
1436 * data gathered by the mutator, too. This argument is not touched by
1437 * expression_tree_mutator, but it is passed down to recursive sub-invocations
1438 * of my_mutator. The tree walk is started from a setup routine that
1439 * fills in the appropriate context struct, calls my_mutator with the
1440 * top-level node of the tree, and does any required post-processing.
1441 *
1442 * Each level of recursion must return an appropriately modified Node.
1443 * If expression_tree_mutator() is called, it will make an exact copy
1444 * of the given Node, but invoke my_mutator() to copy the sub-node(s)
1445 * of that Node. In this way, my_mutator() has full control over the
1446 * copying process but need not directly deal with expression trees
1447 * that it has no interest in.
1448 *
1449 * Just as for expression_tree_walker, the node types handled by
1450 * expression_tree_mutator include all those normally found in target lists
1451 * and qualifier clauses during the planning stage.
1452 *
1453 * expression_tree_mutator will handle SubLink nodes by recursing normally
1454 * into the "testexpr" subtree (which is an expression belonging to the outer
1455 * plan). It will also call the mutator on the sub-Query node; however, when
1456 * expression_tree_mutator itself is called on a Query node, it does nothing
1457 * and returns the unmodified Query node. The net effect is that unless the
1458 * mutator does something special at a Query node, sub-selects will not be
1459 * visited or modified; the original sub-select will be linked to by the new
1460 * SubLink node. Mutators that want to descend into sub-selects will usually
1461 * do so by recognizing Query nodes and calling query_tree_mutator (below).
1462 *
1463 * expression_tree_mutator will handle a SubPlan node by recursing into the
1464 * "testexpr" and the "args" list (which belong to the outer plan), but it
1465 * will simply copy the link to the inner plan, since that's typically what
1466 * expression tree mutators want. A mutator that wants to modify the subplan
1467 * can force appropriate behavior by recognizing SubPlan expression nodes
1468 * and doing the right thing.
1469 */
1471 Node *
1475 {
1476 /*
1477 * The mutator has already decided not to modify the current node, but we
1478 * must call the mutator for any sub-nodes.
1479 */
1481 #define FLATCOPY(newnode, node, nodetype) \
1482 ( (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
1483 memcpy((newnode), (node), sizeof(nodetype)) )
1485 #define CHECKFLATCOPY(newnode, node, nodetype) \
1486 ( AssertMacro(IsA((node), nodetype)), \
1487 (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
1488 memcpy((newnode), (node), sizeof(nodetype)) )
1490 #define MUTATE(newfield, oldfield, fieldtype) \
1491 ( (newfield) = (fieldtype) mutator((Node *) (oldfield), context) )
1496 /* Guard against stack overflow due to overly complex expressions */
1500 {
1501 /*
1502 * Primitive node types with no expression subnodes. Var and
1503 * Const are frequent enough to deserve special cases, the others
1504 * we just use copyObject for.
1505 */
1507 {
1513 }
1516 {
1521 /* XXX we don't bother with datumCopy; should we? */
1523 }
1533 {
1540 }
1543 {
1549 List *);
1551 List *);
1553 Expr *);
1555 Expr *);
1557 }
1560 {
1567 }
1570 {
1577 }
1580 {
1587 }
1590 {
1597 }
1600 {
1607 }
1610 {
1617 /*
1618 * Also invoke the mutator on the sublink's Query node, so it
1619 * can recurse into the sub-query if it wants to.
1620 */
1623 }
1626 {
1631 /* transform testexpr */
1633 /* transform args list (params to be passed to subplan) */
1635 /* but not the sub-Plan itself, which is referenced as-is */
1637 }
1640 {
1647 }
1650 {
1657 }
1660 {
1669 }
1672 {
1679 }
1682 {
1689 }
1692 {
1699 }
1702 {
1709 }
1712 {
1721 }
1724 {
1732 }
1735 {
1742 }
1745 {
1751 /* Assume colnames needn't be duplicated */
1753 }
1756 {
1764 }
1767 {
1774 }
1777 {
1784 }
1787 {
1793 /* assume mutator does not care about arg_names */
1796 }
1799 {
1806 }
1809 {
1816 }
1819 {
1826 }
1829 {
1836 }
1839 {
1846 }
1849 /* Do nothing with a sub-Query, per discussion above */
1852 {
1858 /*
1859 * Also invoke the mutator on the CTE's Query node, so it
1860 * can recurse into the sub-query if it wants to.
1861 */
1864 }
1867 {
1868 /*
1869 * We assume the mutator isn't interested in the list nodes
1870 * per se, so just invoke it on each list element. NOTE: this
1871 * would fail badly on a list with integer elements!
1872 */
1878 {
1881 context));
1882 }
1884 }
1887 {
1895 }
1898 {
1906 /* We do not mutate alias or using by default */
1908 }
1911 {
1918 /* We do not mutate groupClauses by default */
1920 }
1923 {
1928 /* Assume we need not copy the relids bitmapsets */
1931 }
1934 {
1940 /* Assume we need not copy the relids bitmapset */
1942 }
1945 {
1952 }
1955 {
1961 /* Assume we need not copy the relids bitmapsets */
1963 }
1969 }
1970 /* can't get here, but keep compiler happy */
1972 }
1975 /*
1976 * query_tree_mutator --- initiate modification of a Query's expressions
1977 *
1978 * This routine exists just to reduce the number of places that need to know
1979 * where all the expression subtrees of a Query are. Note it can be used
1980 * for starting a walk at top level of a Query regardless of whether the
1981 * mutator intends to descend into subqueries. It is also useful for
1982 * descending into subqueries within a mutator.
1983 *
1984 * Some callers want to suppress mutating of certain items in the Query,
1985 * typically because they need to process them specially, or don't actually
1986 * want to recurse into subqueries. This is supported by the flags argument,
1987 * which is the bitwise OR of flag values to suppress mutating of
1988 * indicated items. (More flag bits may be added as needed.)
1989 *
1990 * Normally the Query node itself is copied, but some callers want it to be
1991 * modified in-place; they must pass QTW_DONT_COPY_QUERY in flags. All
1992 * modified substructure is safely copied in any case.
1993 */
1994 Query *
1999 {
2003 {
2008 }
2024 }
2026 /*
2027 * range_table_mutator is just the part of query_tree_mutator that processes
2028 * a query's rangetable. This is split out since it can be useful on
2029 * its own.
2030 */
2031 List *
2036 {
2041 {
2047 {
2051 /* we don't bother to copy eref, aliases, etc; OK? */
2055 {
2058 }
2059 else
2060 {
2061 /* else, copy RT subqueries as-is */
2063 }
2068 else
2069 {
2070 /* else, copy join aliases as-is */
2072 }
2080 }
2082 }
2084 }
2086 /*
2087 * query_or_expression_tree_walker --- hybrid form
2088 *
2089 * This routine will invoke query_tree_walker if called on a Query node,
2090 * else will invoke the walker directly. This is a useful way of starting
2091 * the recursion when the walker's normal change of state is not appropriate
2092 * for the outermost Query node.
2093 */
2094 bool
2099 {
2102 walker,
2103 context,
2104 flags);
2105 else
2107 }
2109 /*
2110 * query_or_expression_tree_mutator --- hybrid form
2111 *
2112 * This routine will invoke query_tree_mutator if called on a Query node,
2113 * else will invoke the mutator directly. This is a useful way of starting
2114 * the recursion when the mutator's normal change of state is not appropriate
2115 * for the outermost Query node.
2116 */
2117 Node *
2122 {
2125 mutator,
2126 context,
2127 flags);
2128 else
2130 }
2133 /*
2134 * raw_expression_tree_walker --- walk raw parse trees
2135 *
2136 * This has exactly the same API as expression_tree_walker, but instead of
2137 * walking post-analysis parse trees, it knows how to walk the node types
2138 * found in raw grammar output. (There is not currently any need for a
2139 * combined walker, so we keep them separate in the name of efficiency.)
2140 * Unlike expression_tree_walker, there is no special rule about query
2141 * boundaries: we descend to everything that's possibly interesting.
2142 *
2143 * Currently, the node type coverage extends to SelectStmt and everything
2144 * that could appear under it, but not other statement types.
2145 */
2146 bool
2148 {
2151 /*
2152 * The walker has already visited the current node, and so we need only
2153 * recurse into any sub-nodes it has.
2154 */
2158 /* Guard against stack overflow due to overly complex expressions */
2162 {
2173 /* primitive node types with no subnodes */
2176 /* we assume the colnames list isn't interesting */
2181 {
2186 /* we assume the operName is not interesting */
2189 }
2192 {
2197 /* we assume walker doesn't care about CaseWhens, either */
2199 {
2207 }
2210 }
2213 /* Assume colnames isn't interesting */
2220 {
2225 /* we assume walker doesn't care about arg_names */
2228 }
2235 {
2246 /* using list is deemed uninteresting */
2247 }
2250 {
2255 /* colNames, options are deemed uninteresting */
2256 }
2260 {
2263 }
2266 {
2299 }
2302 {
2309 /* operator name is deemed uninteresting */
2310 }
2313 /* we assume the fields contain nothing interesting */
2316 {
2321 /* function name is deemed uninteresting */
2322 }
2325 {
2332 }
2335 {
2342 }
2347 {
2354 }
2357 {
2364 }
2369 {
2376 }
2379 {
2386 }
2389 {
2396 /* type name itself is deemed uninteresting */
2397 }
2400 {
2407 /* for now, constraints are ignored */
2408 }
2413 {
2420 }
2430 }
2432 }