开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
istrat.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：18k
源码类别：

数据库系统

开发平台：

Unix_Linux

istrat.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * istrat.c
  4.  *   index scan strategy manipulation code and index strategy manipulation
  5.  *   operator code.
  6.  *
  7.  * Copyright (c) 1994, Regents of the University of California
  8.  *
  9.  *
  10.  * IDENTIFICATION
  11.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/access/index/istrat.c,v 1.33.2.2 1999/08/02 05:56:39 scrappy Exp $
  12.  *
  13.  *-------------------------------------------------------------------------
  14.  */
  16. #include "postgres.h"
  18. #include "access/heapam.h"
  19. #include "access/istrat.h"
  20. #include "catalog/catname.h"
  21. #include "catalog/pg_amop.h"
  22. #include "catalog/pg_amproc.h"
  23. #include "catalog/pg_index.h"
  24. #include "catalog/pg_operator.h"
  25. #include "miscadmin.h"
  26. #include "utils/syscache.h"
  28. #ifdef USE_ASSERT_CHECKING
  29. static bool StrategyEvaluationIsValid(StrategyEvaluation evaluation);
  30. static bool StrategyExpressionIsValid(StrategyExpression expression,
  31.   StrategyNumber maxStrategy);
  32. static ScanKey StrategyMapGetScanKeyEntry(StrategyMap map,
  33.    StrategyNumber strategyNumber);
  34. static bool StrategyOperatorIsValid(StrategyOperator operator,
  35. StrategyNumber maxStrategy);
  36. static bool StrategyTermIsValid(StrategyTerm term,
  37. StrategyNumber maxStrategy);
  39. #endif
  42. /* ----------------------------------------------------------------
  43.  *    misc strategy support routines
  44.  * ----------------------------------------------------------------
  45.  */
  47. /*
  48.  * StrategyNumberIsValid
  49.  * StrategyNumberIsInBounds
  50.  * StrategyMapIsValid
  51.  * StrategyTransformMapIsValid
  52.  * IndexStrategyIsValid
  53.  *
  54.  * ... are now macros in istrat.h -cim 4/27/91
  55.  */
  57. /*
  58.  * StrategyMapGetScanKeyEntry
  59.  * Returns a scan key entry of a index strategy mapping member.
  60.  *
  61.  * Note:
  62.  * Assumes that the index strategy mapping is valid.
  63.  * Assumes that the index strategy number is valid.
  64.  * Bounds checking should be done outside this routine.
  65.  */
  66. static ScanKey
  67. StrategyMapGetScanKeyEntry(StrategyMap map,
  68.    StrategyNumber strategyNumber)
  69. {
  70. Assert(StrategyMapIsValid(map));
  71. Assert(StrategyNumberIsValid(strategyNumber));
  72. return &map->entry[strategyNumber - 1];
  73. }
  75. /*
  76.  * IndexStrategyGetStrategyMap
  77.  * Returns an index strategy mapping of an index strategy.
  78.  *
  79.  * Note:
  80.  * Assumes that the index strategy is valid.
  81.  * Assumes that the number of index strategies is valid.
  82.  * Bounds checking should be done outside this routine.
  83.  */
  84. StrategyMap
  85. IndexStrategyGetStrategyMap(IndexStrategy indexStrategy,
  86. StrategyNumber maxStrategyNum,
  87. AttrNumber attrNum)
  88. {
  89. Assert(IndexStrategyIsValid(indexStrategy));
  90. Assert(StrategyNumberIsValid(maxStrategyNum));
  91. Assert(AttributeNumberIsValid(attrNum));
  93. maxStrategyNum = AMStrategies(maxStrategyNum); /* XXX */
  94. return &indexStrategy->strategyMapData[maxStrategyNum * (attrNum - 1)];
  95. }
  97. /*
  98.  * AttributeNumberGetIndexStrategySize
  99.  * Computes the size of an index strategy.
  100.  */
  101. Size
  102. AttributeNumberGetIndexStrategySize(AttrNumber maxAttributeNumber,
  103. StrategyNumber maxStrategyNumber)
  104. {
  105. maxStrategyNumber = AMStrategies(maxStrategyNumber); /* XXX */
  106. return maxAttributeNumber * maxStrategyNumber * sizeof(ScanKeyData);
  107. }
  109. #ifdef USE_ASSERT_CHECKING
  110. /*
  111.  * StrategyTransformMapIsValid is now a macro in istrat.h -cim 4/27/91
  112.  */
  114. /* ----------------
  115.  * StrategyOperatorIsValid
  116.  * ----------------
  117.  */
  118. static bool
  119. StrategyOperatorIsValid(StrategyOperator operator,
  120. StrategyNumber maxStrategy)
  121. {
  122. return (bool)
  123. (PointerIsValid(operator) &&
  124.  StrategyNumberIsInBounds(operator->strategy, maxStrategy) &&
  125.  !(operator->flags & ~(SK_NEGATE | SK_COMMUTE)));
  126. }
  128. /* ----------------
  129.  * StrategyTermIsValid
  130.  * ----------------
  131.  */
  132. static bool
  133. StrategyTermIsValid(StrategyTerm term,
  134. StrategyNumber maxStrategy)
  135. {
  136. Index index;
  138. if (!PointerIsValid(term) || term->degree == 0)
  139. return false;
  141. for (index = 0; index < term->degree; index += 1)
  142. {
  143. if (!StrategyOperatorIsValid(&term->operatorData[index],
  144.  maxStrategy))
  145. return false;
  146. }
  148. return true;
  149. }
  151. /* ----------------
  152.  * StrategyExpressionIsValid
  153.  * ----------------
  154.  */
  155. static bool
  156. StrategyExpressionIsValid(StrategyExpression expression,
  157.   StrategyNumber maxStrategy)
  158. {
  159. StrategyTerm *termP;
  161. if (!PointerIsValid(expression))
  162. return true;
  164. if (!StrategyTermIsValid(expression->term[0], maxStrategy))
  165. return false;
  167. termP = &expression->term[1];
  168. while (StrategyTermIsValid(*termP, maxStrategy))
  169. termP += 1;
  171. return (bool)
  172. (!PointerIsValid(*termP));
  173. }
  175. /* ----------------
  176.  * StrategyEvaluationIsValid
  177.  * ----------------
  178.  */
  179. static bool
  180. StrategyEvaluationIsValid(StrategyEvaluation evaluation)
  181. {
  182. Index index;
  184. if (!PointerIsValid(evaluation) ||
  185. !StrategyNumberIsValid(evaluation->maxStrategy) ||
  186. !StrategyTransformMapIsValid(evaluation->negateTransform) ||
  187. !StrategyTransformMapIsValid(evaluation->commuteTransform) ||
  188. !StrategyTransformMapIsValid(evaluation->negateCommuteTransform))
  189. {
  191. return false;
  192. }
  194. for (index = 0; index < evaluation->maxStrategy; index += 1)
  195. {
  196. if (!StrategyExpressionIsValid(evaluation->expression[index],
  197.    evaluation->maxStrategy))
  198. {
  200. return false;
  201. }
  202. }
  203. return true;
  204. }
  206. #endif
  208. /* ----------------
  209.  * StrategyTermEvaluate
  210.  * ----------------
  211.  */
  212. static bool
  213. StrategyTermEvaluate(StrategyTerm term,
  214.  StrategyMap map,
  215.  Datum left,
  216.  Datum right)
  217. {
  218. Index index;
  219. long tmpres = 0;
  220. bool result = 0;
  221. StrategyOperator operator;
  222. ScanKey entry;
  224. for (index = 0, operator = &term->operatorData[0];
  225.  index < term->degree; index += 1, operator += 1)
  226. {
  228. entry = &map->entry[operator->strategy - 1];
  230. Assert(RegProcedureIsValid(entry->sk_procedure));
  232. switch (operator->flags ^ entry->sk_flags)
  233. {
  234. case 0x0:
  235. tmpres = (long) FMGR_PTR2(&entry->sk_func,
  236.   left, right);
  237. break;
  239. case SK_NEGATE:
  240. tmpres = (long) !FMGR_PTR2(&entry->sk_func,
  241.    left, right);
  242. break;
  244. case SK_COMMUTE:
  245. tmpres = (long) FMGR_PTR2(&entry->sk_func,
  246.   right, left);
  247. break;
  249. case SK_NEGATE | SK_COMMUTE:
  250. tmpres = (long) !FMGR_PTR2(&entry->sk_func,
  251.    right, left);
  252. break;
  254. default:
  255. elog(FATAL, "StrategyTermEvaluate: impossible case %d",
  256.  operator->flags ^ entry->sk_flags);
  257. }
  259. result = (bool) tmpres;
  260. if (!result)
  261. return result;
  262. }
  264. return result;
  265. }
  268. /* ----------------
  269.  * RelationGetStrategy
  270.  * ----------------
  271.  */
  272. StrategyNumber
  273. RelationGetStrategy(Relation relation,
  274. AttrNumber attributeNumber,
  275. StrategyEvaluation evaluation,
  276. RegProcedure procedure)
  277. {
  278. StrategyNumber strategy;
  279. StrategyMap strategyMap;
  280. ScanKey entry;
  281. Index index;
  282. int numattrs;
  284. Assert(RelationIsValid(relation));
  285. numattrs = RelationGetNumberOfAttributes(relation);
  287. Assert(relation->rd_rel->relkind == RELKIND_INDEX); /* XXX use accessor */
  288. Assert(AttributeNumberIsValid(attributeNumber));
  289. Assert((attributeNumber >= 1) && (attributeNumber < 1 + numattrs));
  291. Assert(StrategyEvaluationIsValid(evaluation));
  292. Assert(RegProcedureIsValid(procedure));
  294. strategyMap = IndexStrategyGetStrategyMap(RelationGetIndexStrategy(relation),
  295.   evaluation->maxStrategy,
  296.   attributeNumber);
  298. /* get a strategy number for the procedure ignoring flags for now */
  299. for (index = 0; index < evaluation->maxStrategy; index += 1)
  300. {
  301. if (strategyMap->entry[index].sk_procedure == procedure)
  302. break;
  303. }
  305. if (index == evaluation->maxStrategy)
  306. return InvalidStrategy;
  308. strategy = 1 + index;
  309. entry = StrategyMapGetScanKeyEntry(strategyMap, strategy);
  311. Assert(!(entry->sk_flags & ~(SK_NEGATE | SK_COMMUTE)));
  313. switch (entry->sk_flags & (SK_NEGATE | SK_COMMUTE))
  314. {
  315. case 0x0:
  316. return strategy;
  318. case SK_NEGATE:
  319. strategy = evaluation->negateTransform->strategy[strategy - 1];
  320. break;
  322. case SK_COMMUTE:
  323. strategy = evaluation->commuteTransform->strategy[strategy - 1];
  324. break;
  326. case SK_NEGATE | SK_COMMUTE:
  327. strategy = evaluation->negateCommuteTransform->strategy[strategy - 1];
  328. break;
  330. default:
  331. elog(FATAL, "RelationGetStrategy: impossible case %d", entry->sk_flags);
  332. }
  335. if (!StrategyNumberIsInBounds(strategy, evaluation->maxStrategy))
  336. {
  337. if (!StrategyNumberIsValid(strategy))
  338. elog(ERROR, "RelationGetStrategy: corrupted evaluation");
  339. }
  341. return strategy;
  342. }
  344. /* ----------------
  345.  * RelationInvokeStrategy
  346.  * ----------------
  347.  */
  348. bool /* XXX someday, this may return Datum */
  349. RelationInvokeStrategy(Relation relation,
  350.    StrategyEvaluation evaluation,
  351.    AttrNumber attributeNumber,
  352.    StrategyNumber strategy,
  353.    Datum left,
  354.    Datum right)
  355. {
  356. StrategyNumber newStrategy;
  357. StrategyMap strategyMap;
  358. ScanKey entry;
  359. StrategyTermData termData;
  360. int numattrs;
  362. Assert(RelationIsValid(relation));
  363. Assert(relation->rd_rel->relkind == RELKIND_INDEX); /* XXX use accessor */
  364. numattrs = RelationGetNumberOfAttributes(relation);
  366. Assert(StrategyEvaluationIsValid(evaluation));
  367. Assert(AttributeNumberIsValid(attributeNumber));
  368. Assert((attributeNumber >= 1) && (attributeNumber < 1 + numattrs));
  370. Assert(StrategyNumberIsInBounds(strategy, evaluation->maxStrategy));
  372. termData.degree = 1;
  374. strategyMap = IndexStrategyGetStrategyMap(RelationGetIndexStrategy(relation),
  375.   evaluation->maxStrategy,
  376.   attributeNumber);
  378. entry = StrategyMapGetScanKeyEntry(strategyMap, strategy);
  380. if (RegProcedureIsValid(entry->sk_procedure))
  381. {
  382. termData.operatorData[0].strategy = strategy;
  383. termData.operatorData[0].flags = 0x0;
  385. return StrategyTermEvaluate(&termData, strategyMap, left, right);
  386. }
  389. newStrategy = evaluation->negateTransform->strategy[strategy - 1];
  390. if (newStrategy != strategy && StrategyNumberIsValid(newStrategy))
  391. {
  393. entry = StrategyMapGetScanKeyEntry(strategyMap, newStrategy);
  395. if (RegProcedureIsValid(entry->sk_procedure))
  396. {
  397. termData.operatorData[0].strategy = newStrategy;
  398. termData.operatorData[0].flags = SK_NEGATE;
  400. return StrategyTermEvaluate(&termData, strategyMap, left, right);
  401. }
  402. }
  404. newStrategy = evaluation->commuteTransform->strategy[strategy - 1];
  405. if (newStrategy != strategy && StrategyNumberIsValid(newStrategy))
  406. {
  408. entry = StrategyMapGetScanKeyEntry(strategyMap, newStrategy);
  410. if (RegProcedureIsValid(entry->sk_procedure))
  411. {
  412. termData.operatorData[0].strategy = newStrategy;
  413. termData.operatorData[0].flags = SK_COMMUTE;
  415. return StrategyTermEvaluate(&termData, strategyMap, left, right);
  416. }
  417. }
  419. newStrategy = evaluation->negateCommuteTransform->strategy[strategy - 1];
  420. if (newStrategy != strategy && StrategyNumberIsValid(newStrategy))
  421. {
  423. entry = StrategyMapGetScanKeyEntry(strategyMap, newStrategy);
  425. if (RegProcedureIsValid(entry->sk_procedure))
  426. {
  427. termData.operatorData[0].strategy = newStrategy;
  428. termData.operatorData[0].flags = SK_NEGATE | SK_COMMUTE;
  430. return StrategyTermEvaluate(&termData, strategyMap, left, right);
  431. }
  432. }
  434. if (PointerIsValid(evaluation->expression[strategy - 1]))
  435. {
  436. StrategyTerm *termP;
  438. termP = &evaluation->expression[strategy - 1]->term[0];
  439. while (PointerIsValid(*termP))
  440. {
  441. Index index;
  443. for (index = 0; index < (*termP)->degree; index += 1)
  444. {
  445. entry = StrategyMapGetScanKeyEntry(strategyMap,
  446.  (*termP)->operatorData[index].strategy);
  448. if (!RegProcedureIsValid(entry->sk_procedure))
  449. break;
  450. }
  452. if (index == (*termP)->degree)
  453. return StrategyTermEvaluate(*termP, strategyMap, left, right);
  455. termP += 1;
  456. }
  457. }
  459. elog(ERROR, "RelationInvokeStrategy: cannot evaluate strategy %d",
  460.  strategy);
  462. /* not reached, just to make compiler happy */
  463. return FALSE;
  466. }
  468. /* ----------------
  469.  * OperatorRelationFillScanKeyEntry
  470.  * ----------------
  471.  */
  472. static void
  473. OperatorRelationFillScanKeyEntry(Relation operatorRelation,
  474.  Oid operatorObjectId,
  475.  ScanKey entry)
  476. {
  477. HeapTuple tuple;
  478. HeapScanDesc scan = NULL;
  480. if (!IsBootstrapProcessingMode())
  481. {
  482. tuple = SearchSysCacheTuple(OPROID,
  483. ObjectIdGetDatum(operatorObjectId),
  484. 0, 0, 0);
  485. }
  486. else
  487. {
  488. ScanKeyData scanKeyData;
  490. ScanKeyEntryInitialize(&scanKeyData, 0,
  491.    ObjectIdAttributeNumber,
  492.    F_OIDEQ,
  493.    ObjectIdGetDatum(operatorObjectId));
  495. scan = heap_beginscan(operatorRelation, false, SnapshotNow,
  496.   1, &scanKeyData);
  498. tuple = heap_getnext(scan, 0);
  499. }
  501. if (!HeapTupleIsValid(tuple))
  502. {
  503. if (IsBootstrapProcessingMode())
  504. heap_endscan(scan);
  505. elog(ERROR, "OperatorObjectIdFillScanKeyEntry: unknown operator %lu",
  506.  (uint32) operatorObjectId);
  507. }
  509. entry->sk_flags = 0;
  510. entry->sk_procedure = ((Form_pg_operator) GETSTRUCT(tuple))->oprcode;
  511. fmgr_info(entry->sk_procedure, &entry->sk_func);
  512. entry->sk_nargs = entry->sk_func.fn_nargs;
  514. if (IsBootstrapProcessingMode())
  515. heap_endscan(scan);
  517. if (!RegProcedureIsValid(entry->sk_procedure))
  518. {
  519. elog(ERROR,
  520. "OperatorObjectIdFillScanKeyEntry: no procedure for operator %lu",
  521.  (uint32) operatorObjectId);
  522. }
  523. }
  526. /*
  527.  * IndexSupportInitialize
  528.  * Initializes an index strategy and associated support procedures.
  529.  */
  530. void
  531. IndexSupportInitialize(IndexStrategy indexStrategy,
  532.    RegProcedure *indexSupport,
  533.    Oid indexObjectId,
  534.    Oid accessMethodObjectId,
  535.    StrategyNumber maxStrategyNumber,
  536.    StrategyNumber maxSupportNumber,
  537.    AttrNumber maxAttributeNumber)
  538. {
  539. Relation relation = NULL;
  540. HeapScanDesc scan = NULL;
  541. ScanKeyData entry[2];
  542. Relation operatorRelation;
  543. HeapTuple tuple;
  544. StrategyMap map;
  545. AttrNumber attributeNumber;
  546. int attributeIndex;
  547. Oid operatorClassObjectId[MaxIndexAttributeNumber];
  549. if (!IsBootstrapProcessingMode())
  550. {
  551. tuple = SearchSysCacheTuple(INDEXRELID,
  552. ObjectIdGetDatum(indexObjectId),
  553. 0, 0, 0);
  554. }
  555. else
  556. {
  557. ScanKeyEntryInitialize(&entry[0], 0, Anum_pg_index_indexrelid,
  558.    F_OIDEQ,
  559.    ObjectIdGetDatum(indexObjectId));
  561. relation = heap_openr(IndexRelationName);
  562. scan = heap_beginscan(relation, false, SnapshotNow, 1, entry);
  563. tuple = heap_getnext(scan, 0);
  564. }
  566. if (!HeapTupleIsValid(tuple))
  567. elog(ERROR, "IndexSupportInitialize: corrupted catalogs");
  569. maxStrategyNumber = AMStrategies(maxStrategyNumber);
  571. /*
  572.  * XXX note that the following assumes the INDEX tuple is well formed
  573.  * and that the *key and *class are 0 terminated.
  574.  */
  575. for (attributeIndex = 0; attributeIndex < maxAttributeNumber; attributeIndex++)
  576. {
  577. Form_pg_index iform;
  579. iform = (Form_pg_index) GETSTRUCT(tuple);
  581. if (!OidIsValid(iform->indkey[attributeIndex]))
  582. {
  583. if (attributeIndex == InvalidAttrNumber)
  584. elog(ERROR, "IndexSupportInitialize: no pg_index tuple");
  585. break;
  586. }
  588. operatorClassObjectId[attributeIndex] = iform->indclass[attributeIndex];
  589. }
  591. if (IsBootstrapProcessingMode())
  592. {
  593. heap_endscan(scan);
  594. heap_close(relation);
  595. }
  597. /* if support routines exist for this access method, load them */
  598. if (maxSupportNumber > 0)
  599. {
  600. ScanKeyEntryInitialize(&entry[0], 0, Anum_pg_amproc_amid,
  601.    F_OIDEQ,
  602.    ObjectIdGetDatum(accessMethodObjectId));
  604. ScanKeyEntryInitialize(&entry[1], 0, Anum_pg_amproc_amopclaid,
  605.    F_OIDEQ, 0);
  607. relation = heap_openr(AccessMethodProcedureRelationName);
  609. for (attributeNumber = 1; attributeNumber <= maxAttributeNumber;
  610.  attributeNumber++)
  611. {
  612. int16 support;
  613. Form_pg_amproc aform;
  614. RegProcedure *loc;
  616. loc = &indexSupport[((attributeNumber - 1) * maxSupportNumber)];
  618. for (support = 0; support < maxSupportNumber; ++support)
  619. loc[support] = InvalidOid;
  621. entry[1].sk_argument =
  622. ObjectIdGetDatum(operatorClassObjectId[attributeNumber - 1]);
  624. scan = heap_beginscan(relation, false, SnapshotNow, 2, entry);
  626. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  627. {
  628. aform = (Form_pg_amproc) GETSTRUCT(tuple);
  629. loc[(aform->amprocnum - 1)] = aform->amproc;
  630. }
  632. heap_endscan(scan);
  633. }
  634. heap_close(relation);
  635. }
  637. ScanKeyEntryInitialize(&entry[0], 0,
  638.    Anum_pg_amop_amopid,
  639.    F_OIDEQ,
  640.    ObjectIdGetDatum(accessMethodObjectId));
  642. ScanKeyEntryInitialize(&entry[1], 0,
  643.    Anum_pg_amop_amopclaid,
  644.    F_OIDEQ, 0);
  646. relation = heap_openr(AccessMethodOperatorRelationName);
  647. operatorRelation = heap_openr(OperatorRelationName);
  649. for (attributeNumber = maxAttributeNumber; attributeNumber > 0;
  650.  attributeNumber--)
  651. {
  652. StrategyNumber strategy;
  654. entry[1].sk_argument =
  655. ObjectIdGetDatum(operatorClassObjectId[attributeNumber - 1]);
  657. map = IndexStrategyGetStrategyMap(indexStrategy,
  658.   maxStrategyNumber,
  659.   attributeNumber);
  661. for (strategy = 1; strategy <= maxStrategyNumber; strategy++)
  662. ScanKeyEntrySetIllegal(StrategyMapGetScanKeyEntry(map, strategy));
  664. scan = heap_beginscan(relation, false, SnapshotNow, 2, entry);
  666. while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
  667. {
  668. Form_pg_amop aform;
  670. aform = (Form_pg_amop) GETSTRUCT(tuple);
  671. OperatorRelationFillScanKeyEntry(operatorRelation,
  672.  aform->amopopr,
  673. StrategyMapGetScanKeyEntry(map, aform->amopstrategy));
  674. }
  676. heap_endscan(scan);
  677. }
  679. heap_close(operatorRelation);
  680. heap_close(relation);
  681. }
  683. /* ----------------
  684.  * IndexStrategyDisplay
  685.  * ----------------
  686.  */
  687. #ifdef ISTRATDEBUG
  688. int
  689. IndexStrategyDisplay(IndexStrategy indexStrategy,
  690.  StrategyNumber numberOfStrategies,
  691.  int numberOfAttributes)
  692. {
  693. StrategyMap strategyMap;
  694. AttrNumber attributeNumber;
  695. StrategyNumber strategyNumber;
  697. for (attributeNumber = 1; attributeNumber <= numberOfAttributes;
  698.  attributeNumber += 1)
  699. {
  701. strategyMap = IndexStrategyGetStrategyMap(indexStrategy,
  702.   numberOfStrategies,
  703.   attributeNumber);
  705. for (strategyNumber = 1;
  706.  strategyNumber <= AMStrategies(numberOfStrategies);
  707.  strategyNumber += 1)
  708. {
  710. printf(":att %dt:str %dt:opr 0x%x(%d)n",
  711.    attributeNumber, strategyNumber,
  712.    strategyMap->entry[strategyNumber - 1].sk_procedure,
  713.    strategyMap->entry[strategyNumber - 1].sk_procedure);
  714. }
  715. }
  716. }
  718. #endif  /* defined(ISTRATDEBUG) */