home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / prgramer / adaptor / src / callgrap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-03  |  15.1 KB  |  558 lines
  1. # include "CallGrap.h"
  2. # define yyALLOC(ptr, size)    if ((ptr = (tCallGraph) CallGraph_PoolFreePtr) >= (tCallGraph) CallGraph_PoolMaxPtr) \
  3.   ptr = CallGraph_Alloc (); \
  4.   CallGraph_PoolFreePtr += size;
  5. # define yyFREE(ptr, size)    
  6. # ifdef __cplusplus
  7. extern "C" {
  8. # include <stdio.h>
  9. # include "yyCGraph.w"
  10. # include "General.h"
  11. # include "Memory.h"
  12. # include "DynArray.h"
  13. # include "StringMe.h"
  14. # include "Idents.h"
  15. # include "Sets.h"
  16. }
  17. # else
  18. # include <stdio.h>
  19. # include "yyCGraph.w"
  20. # include "General.h"
  21. # include "Memory.h"
  22. # include "DynArray.h"
  23. # include "StringMe.h"
  24. # include "Idents.h"
  25. # include "Sets.h"
  26. # endif
  27.  
  28. /* line 43 "fortran.call" */
  29.  
  30.  
  31.  
  32.  
  33. # define yyBlockSize 20480
  34.  
  35. typedef struct yysBlock {
  36.  char yyBlock [yyBlockSize];
  37.  struct yysBlock * yySuccessor;
  38. } yytBlock, * yytBlockPtr;
  39.  
  40. tCallGraph CallGraphRoot;
  41. unsigned long CallGraph_HeapUsed = 0;
  42.  
  43. static yytBlockPtr yyBlockList    = (yytBlockPtr) NoCallGraph;
  44. char * CallGraph_PoolFreePtr    = (char *) NoCallGraph;
  45. char * CallGraph_PoolMaxPtr    = (char *) NoCallGraph;
  46. static unsigned short yyMaxSize    = 0;
  47. unsigned short CallGraph_NodeSize [4 + 1] = { 0,
  48.  sizeof (yCallGraph),
  49.  sizeof (yCallNode),
  50.  sizeof (yCallNodeList),
  51.  sizeof (yCallEdgeList),
  52. };
  53. char * CallGraph_NodeName [4 + 1] = {
  54.  "NoCallGraph",
  55.  "CallGraph",
  56.  "CallNode",
  57.  "CallNodeList",
  58.  "CallEdgeList",
  59. };
  60. static CallGraph_tKind yyTypeRange [4 + 1] = { 0,
  61.  kCallGraph,
  62.  kCallNode,
  63.  kCallNodeList,
  64.  kCallEdgeList,
  65. };
  66.  
  67. tCallGraph CallGraph_Alloc ()
  68. {
  69.  register yytBlockPtr yyBlockPtr = yyBlockList;
  70.  register int i;
  71.  
  72.  if (yyMaxSize == 0)
  73.   for (i = 1; i <= 4; i ++) {
  74.    CallGraph_NodeSize [i] = (CallGraph_NodeSize [i] + yyMaxAlign - 1) & yyAlignMasks [yyMaxAlign];
  75.    yyMaxSize = Max (CallGraph_NodeSize [i], yyMaxSize);
  76.   }
  77.  yyBlockList = (yytBlockPtr) Alloc (sizeof (yytBlock));
  78.  yyBlockList->yySuccessor = yyBlockPtr;
  79.  CallGraph_PoolFreePtr = yyBlockList->yyBlock;
  80.  CallGraph_PoolMaxPtr = CallGraph_PoolFreePtr + yyBlockSize - yyMaxSize + 1;
  81.  CallGraph_HeapUsed += yyBlockSize;
  82.  return (tCallGraph) CallGraph_PoolFreePtr;
  83. }
  84.  
  85. tCallGraph MakeCallGraph
  86. # if defined __STDC__ | defined __cplusplus
  87.  (CallGraph_tKind yyKind)
  88. # else
  89.  (yyKind) CallGraph_tKind yyKind;
  90. # endif
  91. {
  92.  register tCallGraph yyt;
  93.  yyALLOC (yyt, CallGraph_NodeSize [yyKind])
  94.  yyt->Kind = yyKind;
  95.  yyt->yyHead.yyMark = 0;
  96.  return yyt;
  97. }
  98.  
  99. bool CallGraph_IsType
  100. # if defined __STDC__ | defined __cplusplus
  101.  (register tCallGraph yyt, register CallGraph_tKind yyKind)
  102. # else
  103.  (yyt, yyKind) register tCallGraph yyt; register CallGraph_tKind yyKind;
  104. # endif
  105. {
  106.  return yyt != NoCallGraph && yyKind <= yyt->Kind && yyt->Kind <= yyTypeRange [yyKind];
  107. }
  108.  
  109.  
  110. tCallGraph mCallGraph
  111. # if defined __STDC__ | defined __cplusplus
  112. (tCallGraph pUserNodes, tCallGraph pIntrinsicNodes, tCallGraph pExternalNodes)
  113. # else
  114. (pUserNodes, pIntrinsicNodes, pExternalNodes)
  115. tCallGraph pUserNodes;
  116. tCallGraph pIntrinsicNodes;
  117. tCallGraph pExternalNodes;
  118. # endif
  119. {
  120.  register tCallGraph yyt;
  121.  yyALLOC (yyt, CallGraph_NodeSize [kCallGraph])
  122.  yyt->Kind = kCallGraph;
  123.  yyt->yyHead.yyMark = 0;
  124.  yyt->CallGraph.UserNodes = pUserNodes;
  125.  yyt->CallGraph.IntrinsicNodes = pIntrinsicNodes;
  126.  yyt->CallGraph.ExternalNodes = pExternalNodes;
  127.  return yyt;
  128. }
  129.  
  130. tCallGraph mCallNode
  131. # if defined __STDC__ | defined __cplusplus
  132. (tObject pval, int punitkind, tCallGraph pcalling, tCallGraph pcalled_by)
  133. # else
  134. (pval, punitkind, pcalling, pcalled_by)
  135. tObject pval;
  136. int punitkind;
  137. tCallGraph pcalling;
  138. tCallGraph pcalled_by;
  139. # endif
  140. {
  141.  register tCallGraph yyt;
  142.  yyALLOC (yyt, CallGraph_NodeSize [kCallNode])
  143.  yyt->Kind = kCallNode;
  144.  yyt->yyHead.yyMark = 0;
  145.  yyt->CallNode.val = pval;
  146.  yyt->CallNode.unitkind = punitkind;
  147.  yyt->CallNode.calling = pcalling;
  148.  yyt->CallNode.called_by = pcalled_by;
  149.  return yyt;
  150. }
  151.  
  152. tCallGraph mCallNodeList
  153. # if defined __STDC__ | defined __cplusplus
  154. (tCallGraph pElem, tCallGraph pNext)
  155. # else
  156. (pElem, pNext)
  157. tCallGraph pElem;
  158. tCallGraph pNext;
  159. # endif
  160. {
  161.  register tCallGraph yyt;
  162.  yyALLOC (yyt, CallGraph_NodeSize [kCallNodeList])
  163.  yyt->Kind = kCallNodeList;
  164.  yyt->yyHead.yyMark = 0;
  165.  yyt->CallNodeList.Elem = pElem;
  166.  yyt->CallNodeList.Next = pNext;
  167.  return yyt;
  168. }
  169.  
  170. tCallGraph mCallEdgeList
  171. # if defined __STDC__ | defined __cplusplus
  172. (tCallGraph pNode, int pcount, tCallGraph pNext)
  173. # else
  174. (pNode, pcount, pNext)
  175. tCallGraph pNode;
  176. int pcount;
  177. tCallGraph pNext;
  178. # endif
  179. {
  180.  register tCallGraph yyt;
  181.  yyALLOC (yyt, CallGraph_NodeSize [kCallEdgeList])
  182.  yyt->Kind = kCallEdgeList;
  183.  yyt->yyHead.yyMark = 0;
  184.  yyt->CallEdgeList.Node = pNode;
  185.  yyt->CallEdgeList.count = pcount;
  186.  yyt->CallEdgeList.Next = pNext;
  187.  return yyt;
  188. }
  189.  
  190. typedef tCallGraph * yyPtrtTree;
  191.  
  192. static FILE * yyf;
  193.  
  194. static void yyMark
  195. # if defined __STDC__ | defined __cplusplus
  196.  (register tCallGraph yyt)
  197. # else
  198.  (yyt) register tCallGraph yyt;
  199. # endif
  200. {
  201.  for (;;) {
  202.   if (yyt == NoCallGraph || ++ yyt->yyHead.yyMark > 1) return;
  203.  
  204.   switch (yyt->Kind) {
  205. case kCallGraph:
  206. yyMark (yyt->CallGraph.UserNodes);
  207. yyMark (yyt->CallGraph.IntrinsicNodes);
  208. yyt = yyt->CallGraph.ExternalNodes; break;
  209. case kCallNode:
  210. yyMark (yyt->CallNode.calling);
  211. yyt = yyt->CallNode.called_by; break;
  212. case kCallNodeList:
  213. yyMark (yyt->CallNodeList.Elem);
  214. yyt = yyt->CallNodeList.Next; break;
  215. case kCallEdgeList:
  216. yyMark (yyt->CallEdgeList.Node);
  217. yyt = yyt->CallEdgeList.Next; break;
  218.   default: return;
  219.   }
  220.  }
  221. }
  222.  
  223. # define yyInitTreeStoreSize 32
  224. # define yyMapToTree(yyLabel) yyTreeStorePtr [yyLabel]
  225.  
  226. static unsigned long yyTreeStoreSize = yyInitTreeStoreSize;
  227. static tCallGraph yyTreeStore [yyInitTreeStoreSize];
  228. static tCallGraph * yyTreeStorePtr = yyTreeStore;
  229. static int yyLabelCount;
  230. static short yyRecursionLevel = 0;
  231. extern void exit ();
  232.  
  233. static CallGraph_tLabel yyMapToLabel
  234. # if defined __STDC__ | defined __cplusplus
  235.  (tCallGraph yyt)
  236. # else
  237.  (yyt) tCallGraph yyt;
  238. # endif
  239. {
  240.  register int yyi;
  241.  for (yyi = 1; yyi <= yyLabelCount; yyi ++) if (yyTreeStorePtr [yyi] == yyt) return yyi;
  242.  if (++ yyLabelCount == yyTreeStoreSize)
  243.   ExtendArray ((char * *) & yyTreeStorePtr, & yyTreeStoreSize, sizeof (tCallGraph));
  244.  yyTreeStorePtr [yyLabelCount] = yyt;
  245.  return yyLabelCount;
  246. }
  247.  
  248. static void yyWriteCallGraph ();
  249.  
  250. static void yyWriteNl () { (void) putc ('\n', yyf); }
  251.  
  252. static void yyWriteSelector
  253. # if defined __STDC__ | defined __cplusplus
  254.  (char * yys)
  255. # else
  256.  (yys) char * yys;
  257. # endif
  258. {
  259.  register int yyi = 16 - strlen (yys);
  260.  (void) fputs (yys, yyf);
  261.  while (yyi -- > 0) (void) putc (' ', yyf);
  262.  (void) fputs (" = ", yyf);
  263. }
  264.  
  265. static void yyWriteHex
  266. # if defined __STDC__ | defined __cplusplus
  267.  (unsigned char * yyx, int yysize)
  268. # else
  269.  (yyx, yysize) unsigned char * yyx; int yysize;
  270. # endif
  271. { register int yyi; for (yyi = 0; yyi < yysize; yyi ++) (void) fprintf (yyf, "%02x ", yyx [yyi]); }
  272.  
  273. static void yyWriteAdr
  274. # if defined __STDC__ | defined __cplusplus
  275.  (tCallGraph yyt)
  276. # else
  277.  (yyt) tCallGraph yyt;
  278. # endif
  279. {
  280.  if (yyt == NoCallGraph) (void) fputs ("NoCallGraph", yyf);
  281.  else yyWriteHex ((unsigned char *) & yyt, sizeof (yyt));
  282.  yyWriteNl ();
  283. }
  284.  
  285. static void yWriteNodeCallGraph
  286. # if defined __STDC__ | defined __cplusplus
  287.  (tCallGraph yyt)
  288. # else
  289.  (yyt) tCallGraph yyt;
  290. # endif
  291. {
  292.  yyWriteSelector ("UserNodes"); yyWriteAdr (yyt->CallGraph.UserNodes);
  293.  yyWriteSelector ("IntrinsicNodes"); yyWriteAdr (yyt->CallGraph.IntrinsicNodes);
  294.  yyWriteSelector ("ExternalNodes"); yyWriteAdr (yyt->CallGraph.ExternalNodes);
  295. }
  296.  
  297. static void yWriteNodeCallNode
  298. # if defined __STDC__ | defined __cplusplus
  299.  (tCallGraph yyt)
  300. # else
  301.  (yyt) tCallGraph yyt;
  302. # endif
  303. {
  304.  yyWriteSelector ("val"); writetObject (yyt->CallNode.val) yyWriteNl ();
  305.  yyWriteSelector ("unitkind"); writeint (yyt->CallNode.unitkind) yyWriteNl ();
  306.  yyWriteSelector ("calling"); yyWriteAdr (yyt->CallNode.calling);
  307.  yyWriteSelector ("called_by"); yyWriteAdr (yyt->CallNode.called_by);
  308. }
  309.  
  310. static void yWriteNodeCallNodeList
  311. # if defined __STDC__ | defined __cplusplus
  312.  (tCallGraph yyt)
  313. # else
  314.  (yyt) tCallGraph yyt;
  315. # endif
  316. {
  317.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->CallNodeList.Elem);
  318.  yyWriteSelector ("Next"); yyWriteAdr (yyt->CallNodeList.Next);
  319. }
  320.  
  321. static void yWriteNodeCallEdgeList
  322. # if defined __STDC__ | defined __cplusplus
  323.  (tCallGraph yyt)
  324. # else
  325.  (yyt) tCallGraph yyt;
  326. # endif
  327. {
  328.  yyWriteSelector ("Node"); yyWriteAdr (yyt->CallEdgeList.Node);
  329.  yyWriteSelector ("count"); writeint (yyt->CallEdgeList.count) yyWriteNl ();
  330.  yyWriteSelector ("Next"); yyWriteAdr (yyt->CallEdgeList.Next);
  331. }
  332.  
  333. void WriteCallGraphNode
  334. # if defined __STDC__ | defined __cplusplus
  335.  (FILE * yyyf, tCallGraph yyt)
  336. # else
  337.  (yyyf, yyt) FILE * yyyf; tCallGraph yyt;
  338. # endif
  339. {
  340.  yyf = yyyf;
  341.  if (yyt == NoCallGraph) { (void) fputs ("NoCallGraph\n", yyf); return; }
  342.  
  343.  switch (yyt->Kind) {
  344. case kCallGraph: (void) fputs (CallGraph_NodeName [kCallGraph], yyf); (void) fputc ('\n', yyf);
  345.  yWriteNodeCallGraph (yyt); break;
  346. case kCallNode: (void) fputs (CallGraph_NodeName [kCallNode], yyf); (void) fputc ('\n', yyf);
  347.  yWriteNodeCallNode (yyt); break;
  348. case kCallNodeList: (void) fputs (CallGraph_NodeName [kCallNodeList], yyf); (void) fputc ('\n', yyf);
  349.  yWriteNodeCallNodeList (yyt); break;
  350. case kCallEdgeList: (void) fputs (CallGraph_NodeName [kCallEdgeList], yyf); (void) fputc ('\n', yyf);
  351.  yWriteNodeCallEdgeList (yyt); break;
  352.  default: ;
  353.  }
  354. }
  355.  
  356. static short yyIndentLevel;
  357.  
  358. void WriteCallGraph
  359. # if defined __STDC__ | defined __cplusplus
  360.  (FILE * yyyf, tCallGraph yyt)
  361. # else
  362.  (yyyf, yyt) FILE * yyyf; tCallGraph yyt;
  363. # endif
  364. {
  365.  short yySaveLevel = yyIndentLevel;
  366.  yyf = yyyf;
  367.  if (yyRecursionLevel ++ == 0) yyLabelCount = 0;
  368.  yyMark (yyt);
  369.  yyIndentLevel = 0;
  370.  yyWriteCallGraph (yyt);
  371.  yyIndentLevel = yySaveLevel;
  372.  yyRecursionLevel --;
  373. }
  374.  
  375. static void yyIndentSelector
  376. # if defined __STDC__ | defined __cplusplus
  377.  (char * yys)
  378. # else
  379.  (yys) char * yys;
  380. # endif
  381. {
  382.  register int yyi;
  383.  for (yyi = 1; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);
  384.  yyWriteSelector (yys);
  385. }
  386.  
  387. static void yyIndentSelectorTree
  388. # if defined __STDC__ | defined __cplusplus
  389.  (char * yys, tCallGraph yyt)
  390. # else
  391.  (yys, yyt) char * yys; tCallGraph yyt;
  392. # endif
  393. { yyIndentSelector (yys); writetCallGraph (yyt) }
  394.  
  395. static void yWriteCallGraph
  396. # if defined __STDC__ | defined __cplusplus
  397.  (tCallGraph yyt)
  398. # else
  399.  (yyt) tCallGraph yyt;
  400. # endif
  401. {
  402.  (void) fputs (CallGraph_NodeName [kCallGraph], yyf); (void) fputc ('\n', yyf);
  403.  yyIndentSelectorTree ("UserNodes", yyt->CallGraph.UserNodes);
  404.  yyIndentSelectorTree ("IntrinsicNodes", yyt->CallGraph.IntrinsicNodes);
  405. }
  406.  
  407. static void yWriteCallNode
  408. # if defined __STDC__ | defined __cplusplus
  409.  (tCallGraph yyt)
  410. # else
  411.  (yyt) tCallGraph yyt;
  412. # endif
  413. {
  414.  (void) fputs (CallGraph_NodeName [kCallNode], yyf); (void) fputc ('\n', yyf);
  415.  yyIndentSelector ("val"); writetObject (yyt->CallNode.val) yyWriteNl ();
  416.  yyIndentSelector ("unitkind"); writeint (yyt->CallNode.unitkind) yyWriteNl ();
  417.  yyIndentSelectorTree ("calling", yyt->CallNode.calling);
  418. }
  419.  
  420. static void yWriteCallNodeList
  421. # if defined __STDC__ | defined __cplusplus
  422.  (tCallGraph yyt)
  423. # else
  424.  (yyt) tCallGraph yyt;
  425. # endif
  426. {
  427.  (void) fputs (CallGraph_NodeName [kCallNodeList], yyf); (void) fputc ('\n', yyf);
  428.  yyIndentSelectorTree ("Elem", yyt->CallNodeList.Elem);
  429. }
  430.  
  431. static void yWriteCallEdgeList
  432. # if defined __STDC__ | defined __cplusplus
  433.  (tCallGraph yyt)
  434. # else
  435.  (yyt) tCallGraph yyt;
  436. # endif
  437. {
  438.  (void) fputs (CallGraph_NodeName [kCallEdgeList], yyf); (void) fputc ('\n', yyf);
  439.  yyIndentSelectorTree ("Node", yyt->CallEdgeList.Node);
  440.  yyIndentSelector ("count"); writeint (yyt->CallEdgeList.count) yyWriteNl ();
  441. }
  442.  
  443. static void yyWriteCallGraph
  444. # if defined __STDC__ | defined __cplusplus
  445.  (tCallGraph yyt)
  446. # else
  447.  (yyt) tCallGraph yyt;
  448. # endif
  449. { unsigned short yyLevel = yyIndentLevel;
  450.  for (;;) {
  451.   if (yyt == NoCallGraph) { (void) fputs (" NoCallGraph\n", yyf); goto yyExit;
  452.   } else if (yyt->yyHead.yyMark == 0) { (void) fprintf (yyf, "^%d\n", yyMapToLabel (yyt)); goto yyExit;
  453.   } else if (yyt->yyHead.yyMark > 1) {
  454.    register int yyi;
  455.    (void) fprintf (yyf, "\n%06d:", yyMapToLabel (yyt));
  456.    for (yyi = 8; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);
  457.   } else (void) putc (' ', yyf);
  458.   yyt->yyHead.yyMark = 0;
  459.   yyIndentLevel += 2;
  460.  
  461.   switch (yyt->Kind) {
  462. case kCallGraph: yWriteCallGraph (yyt); yyIndentSelector ("ExternalNodes"); yyt = yyt->CallGraph.ExternalNodes; break;
  463. case kCallNode: yWriteCallNode (yyt); yyIndentSelector ("called_by"); yyt = yyt->CallNode.called_by; break;
  464. case kCallNodeList: yWriteCallNodeList (yyt); yyIndentSelector ("Next"); yyt = yyt->CallNodeList.Next; break;
  465. case kCallEdgeList: yWriteCallEdgeList (yyt); yyIndentSelector ("Next"); yyt = yyt->CallEdgeList.Next; break;
  466.   default: goto yyExit;
  467.   }
  468.  }
  469. yyExit:
  470.  yyIndentLevel = yyLevel;
  471. }
  472.  
  473. # define yyNil    0374
  474. # define yyNoLabel    0375
  475. # define yyLabelDef    0376
  476. # define yyLabelUse    0377
  477.  
  478. static bool yyCheckCallGraph ARGS((tCallGraph yyt));
  479.  
  480. bool CheckCallGraph
  481. # if defined __STDC__ | defined __cplusplus
  482.  (tCallGraph yyt)
  483. # else
  484.  (yyt) tCallGraph yyt;
  485. # endif
  486. {
  487.  yyMark (yyt);
  488.  return yyCheckCallGraph (yyt);
  489. }
  490.  
  491. static bool yyCheckChild
  492. # if defined __STDC__ | defined __cplusplus
  493.  (tCallGraph yyParent, tCallGraph yyyChild, CallGraph_tKind yyType, char * yySelector)
  494. # else
  495.  (yyParent, yyyChild, yyType, yySelector)
  496.  tCallGraph yyParent, yyyChild;
  497.  CallGraph_tKind yyType;
  498.  char * yySelector;
  499. # endif
  500. {
  501.  bool yySuccess = CallGraph_IsType (yyyChild, yyType);
  502.  if (! yySuccess) {
  503.   (void) fputs ("CheckTree: parent = ", stderr);
  504.   WriteCallGraphNode (stderr, yyParent);
  505.   (void) fprintf (stderr, "\nselector: %s child = ", yySelector);
  506.   WriteCallGraphNode (stderr, yyyChild);
  507.   (void) fputc ('\n', stderr);
  508.  }
  509.  return yyCheckCallGraph (yyyChild) && yySuccess;
  510. }
  511.  
  512. static bool yyCheckCallGraph
  513. # if defined __STDC__ | defined __cplusplus
  514.  (tCallGraph yyt)
  515. # else
  516.  (yyt) tCallGraph yyt;
  517. # endif
  518. {
  519.  bool yyResult;
  520.  if (yyt == NoCallGraph) return false;
  521.  else if (yyt->yyHead.yyMark == 0) return true;
  522.  yyt->yyHead.yyMark = 0;
  523.  
  524.  yyResult = true;
  525.  switch (yyt->Kind) {
  526. case kCallGraph:
  527. yyResult = yyCheckChild (yyt, yyt->CallGraph.UserNodes, kCallNodeList, "UserNodes") && yyResult;
  528. yyResult = yyCheckChild (yyt, yyt->CallGraph.IntrinsicNodes, kCallNodeList, "IntrinsicNodes") && yyResult;
  529. yyResult = yyCheckChild (yyt, yyt->CallGraph.ExternalNodes, kCallNodeList, "ExternalNodes") && yyResult;
  530. break;
  531. case kCallNode:
  532. yyResult = yyCheckChild (yyt, yyt->CallNode.calling, kCallEdgeList, "calling") && yyResult;
  533. yyResult = yyCheckChild (yyt, yyt->CallNode.called_by, kCallEdgeList, "called_by") && yyResult;
  534. break;
  535. case kCallNodeList:
  536. yyResult = yyCheckChild (yyt, yyt->CallNodeList.Elem, kCallNode, "Elem") && yyResult;
  537. yyResult = yyCheckChild (yyt, yyt->CallNodeList.Next, kCallNodeList, "Next") && yyResult;
  538. break;
  539. case kCallEdgeList:
  540. yyResult = yyCheckChild (yyt, yyt->CallEdgeList.Node, kCallNode, "Node") && yyResult;
  541. yyResult = yyCheckChild (yyt, yyt->CallEdgeList.Next, kCallEdgeList, "Next") && yyResult;
  542. break;
  543.  default: ;
  544.  }
  545.  return yyResult;
  546. }
  547.  
  548. void BeginCallGraph ()
  549. {
  550. }
  551.  
  552. void CloseCallGraph ()
  553. {
  554. /* line 47 "fortran.call" */
  555.  
  556.  
  557. }
  558.