home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / adaptor.zip / adapt.zip / adaptor / src / showdefs.c < prev    next >
Text File  |  1994-01-03  |  16KB  |  684 lines
  1. # include "ShowDefs.h"
  2. # include "yyShDefs.w"
  3. # include <stdio.h>
  4. # if defined __STDC__ | defined __cplusplus
  5. #  include <stdlib.h>
  6. # else
  7.    extern void exit ();
  8. # endif
  9. # include "Tree.h"
  10. # include "Definiti.h"
  11.  
  12. # ifndef NULL
  13. # define NULL 0L
  14. # endif
  15. # ifndef false
  16. # define false 0
  17. # endif
  18. # ifndef true
  19. # define true 1
  20. # endif
  21.  
  22. # ifdef yyInline
  23. # define yyALLOC(tree, free, max, alloc, nodesize, make, ptr, kind) \
  24.   if ((ptr = (tree) free) >= (tree) max) ptr = alloc (); \
  25.   free += nodesize [kind]; \
  26.   ptr->yyHead.yyMark = 0; \
  27.   ptr->Kind = kind;
  28. # else
  29. # define yyALLOC(tree, free, max, alloc, nodesize, make, ptr, kind) ptr = make (kind);
  30. # endif
  31.  
  32. # define yyWrite(s) (void) fputs (s, yyf)
  33. # define yyWriteNl (void) fputc ('\n', yyf)
  34.  
  35. # line 8 "ShowDefs.puma"
  36.  
  37. # include "Idents.h"
  38. # include "StringMe.h"
  39.  
  40. FILE *SemFile;
  41.  
  42.  
  43. static FILE * yyf = stdout;
  44.  
  45. static void yyAbort
  46. # ifdef __cplusplus
  47.  (char * yyFunction)
  48. # else
  49.  (yyFunction) char * yyFunction;
  50. # endif
  51. {
  52.  (void) fprintf (stderr, "Error: module ShowDefs, routine %s failed\n", yyFunction);
  53.  exit (1);
  54. }
  55.  
  56. void ShowDeclarations ARGS((tDefinitions d));
  57. static void ShowType ARGS((tTree t));
  58. static void ShowDistribution ARGS((tDefinitions distribution));
  59.  
  60. void ShowDeclarations
  61. # if defined __STDC__ | defined __cplusplus
  62. (register tDefinitions d)
  63. # else
  64. (d)
  65.  register tDefinitions d;
  66. # endif
  67. {
  68. # line 23 "ShowDefs.puma"
  69.  
  70. unsigned char string[256];
  71. int varrank;
  72.  
  73.   if (d == NoDefinitions) return;
  74.  
  75.   switch (d->Kind) {
  76.   case kSCOPE_LIST:
  77. # line 28 "ShowDefs.puma"
  78.   {
  79. # line 29 "ShowDefs.puma"
  80.    ShowDeclarations (d->SCOPE_LIST.Table);
  81. # line 30 "ShowDefs.puma"
  82.    ShowDeclarations (d->SCOPE_LIST.Hidden);
  83.   }
  84.    return;
  85.  
  86.   case kSCOPE_EMPTY:
  87. # line 33 "ShowDefs.puma"
  88.    return;
  89.  
  90.   case kENTRY_LIST:
  91. # line 36 "ShowDefs.puma"
  92.   {
  93. # line 37 "ShowDefs.puma"
  94.    ShowDeclarations (d->ENTRY_LIST.Next);
  95. # line 38 "ShowDefs.puma"
  96.    ShowDeclarations (d->ENTRY_LIST.Elem);
  97.   }
  98.    return;
  99.  
  100.   case kENTRY_EMPTY:
  101. # line 41 "ShowDefs.puma"
  102.    return;
  103.  
  104.   case kProcObject:
  105.   if (d->ProcObject.decl->Kind == kPROC_DECL) {
  106. # line 44 "ShowDefs.puma"
  107.   {
  108. # line 45 "ShowDefs.puma"
  109.    GetString (d->ProcObject.ident, string);
  110. # line 46 "ShowDefs.puma"
  111.    fprintf (SemFile, "User defined subroutine %s\n", string);
  112.   }
  113.    return;
  114.  
  115.   }
  116.   if (d->ProcObject.decl->Kind == kEXT_PROC_DECL) {
  117. # line 49 "ShowDefs.puma"
  118.   {
  119. # line 50 "ShowDefs.puma"
  120.    GetString (d->ProcObject.ident, string);
  121. # line 51 "ShowDefs.puma"
  122.    fprintf (SemFile, "External subroutine %s\n", string);
  123.   }
  124.    return;
  125.  
  126.   }
  127.   if (d->ProcObject.decl->Kind == kPROC_PARAM_DECL) {
  128. # line 54 "ShowDefs.puma"
  129.   {
  130. # line 55 "ShowDefs.puma"
  131.    GetString (d->ProcObject.ident, string);
  132. # line 56 "ShowDefs.puma"
  133.    fprintf (SemFile, "Parameter subroutine %s\n", string);
  134.   }
  135.    return;
  136.  
  137.   }
  138.   if (d->ProcObject.decl->Kind == kINTRINSIC_DECL) {
  139. # line 59 "ShowDefs.puma"
  140.   {
  141. # line 60 "ShowDefs.puma"
  142.    GetString (d->ProcObject.ident, string);
  143. # line 61 "ShowDefs.puma"
  144.    fprintf (SemFile, "Intrinsic subroutine %s\n", string);
  145.   }
  146.    return;
  147.  
  148.   }
  149.   break;
  150.   case kFuncObject:
  151.   if (d->FuncObject.decl->Kind == kFUNC_DECL) {
  152. # line 64 "ShowDefs.puma"
  153.   {
  154. # line 65 "ShowDefs.puma"
  155.    GetString (d->FuncObject.ident, string);
  156. # line 66 "ShowDefs.puma"
  157.    fprintf (SemFile, "User-defined Function %s\n", string);
  158.   }
  159.    return;
  160.  
  161.   }
  162.   if (d->FuncObject.decl->Kind == kSTMT_FUNC_DECL) {
  163. # line 69 "ShowDefs.puma"
  164.   {
  165. # line 70 "ShowDefs.puma"
  166.    GetString (d->FuncObject.ident, string);
  167. # line 71 "ShowDefs.puma"
  168.    fprintf (SemFile, "Statement Function %s\n", string);
  169.   }
  170.    return;
  171.  
  172.   }
  173.   if (d->FuncObject.decl->Kind == kEXT_FUNC_DECL) {
  174. # line 74 "ShowDefs.puma"
  175.   {
  176. # line 75 "ShowDefs.puma"
  177.    GetString (d->FuncObject.ident, string);
  178. # line 76 "ShowDefs.puma"
  179.    fprintf (SemFile, "External Function %s\n", string);
  180.   }
  181.    return;
  182.  
  183.   }
  184.   if (d->FuncObject.decl->Kind == kFUNC_PARAM_DECL) {
  185. # line 79 "ShowDefs.puma"
  186.   {
  187. # line 80 "ShowDefs.puma"
  188.    GetString (d->FuncObject.ident, string);
  189. # line 81 "ShowDefs.puma"
  190.    fprintf (SemFile, "Parameter Function %s\n", string);
  191.   }
  192.    return;
  193.  
  194.   }
  195.   if (d->FuncObject.decl->Kind == kINTRINSIC_DECL) {
  196. # line 84 "ShowDefs.puma"
  197.   {
  198. # line 85 "ShowDefs.puma"
  199.    GetString (d->FuncObject.ident, string);
  200. # line 86 "ShowDefs.puma"
  201.    fprintf (SemFile, "Intrinsic Function %s\n", string);
  202.   }
  203.    return;
  204.  
  205.   }
  206.   break;
  207.   case kBlockObject:
  208. # line 89 "ShowDefs.puma"
  209.   {
  210. # line 90 "ShowDefs.puma"
  211.    GetString (d->BlockObject.ident, string);
  212. # line 91 "ShowDefs.puma"
  213.    fprintf (SemFile, "Block Data %s\n", string);
  214.   }
  215.    return;
  216.  
  217.   case kVarObject:
  218.   if (d->VarObject.Kind->Kind == kVarDummy) {
  219. # line 94 "ShowDefs.puma"
  220.   {
  221. # line 95 "ShowDefs.puma"
  222.    GetString (d->VarObject.ident, string);
  223. # line 96 "ShowDefs.puma"
  224.    fprintf (SemFile, "Parameter %s, type = ", string);
  225. # line 97 "ShowDefs.puma"
  226.    ShowType (d->VarObject.decl);
  227. # line 98 "ShowDefs.puma"
  228.    varrank = VarRank (d);
  229. # line 99 "ShowDefs.puma"
  230.    fprintf (SemFile, " rank = %d", varrank);
  231. # line 100 "ShowDefs.puma"
  232.    fprintf (SemFile, " uses = %d ", d->VarObject.uses);
  233. # line 101 "ShowDefs.puma"
  234.    fprintf (SemFile, " optional = %d ", d->VarObject.Kind->VarDummy.optional);
  235. # line 102 "ShowDefs.puma"
  236.    ShowDistribution (d->VarObject.Dist);
  237. # line 103 "ShowDefs.puma"
  238.    fprintf (SemFile, "\n");
  239.   }
  240.    return;
  241.  
  242.   }
  243.   if (d->VarObject.Kind->Kind == kVarConstant) {
  244. # line 106 "ShowDefs.puma"
  245.   {
  246. # line 107 "ShowDefs.puma"
  247.    GetString (d->VarObject.ident, string);
  248. # line 108 "ShowDefs.puma"
  249.    fprintf (SemFile, "Constant %s, val = ", string);
  250. # line 109 "ShowDefs.puma"
  251.    FileUnparse (SemFile, d->VarObject.Kind->VarConstant.Val);
  252. # line 110 "ShowDefs.puma"
  253.    fprintf (SemFile, " type = ");
  254. # line 111 "ShowDefs.puma"
  255.    ShowType (d->VarObject.Kind->VarConstant.Type);
  256. # line 112 "ShowDefs.puma"
  257.    varrank = TreeRank (d->VarObject.Kind->VarConstant.Type);
  258. # line 113 "ShowDefs.puma"
  259.    fprintf (SemFile, " rank = %d", varrank);
  260. # line 114 "ShowDefs.puma"
  261.    fprintf (SemFile, " uses = %d ", d->VarObject.uses);
  262. # line 115 "ShowDefs.puma"
  263.    ShowDistribution (d->VarObject.Dist);
  264. # line 116 "ShowDefs.puma"
  265.    fprintf (SemFile, "\n");
  266.   }
  267.    return;
  268.  
  269.   }
  270.   if (d->VarObject.Kind->Kind == kVarLocal) {
  271. # line 119 "ShowDefs.puma"
  272.   {
  273. # line 120 "ShowDefs.puma"
  274.    GetString (d->VarObject.ident, string);
  275. # line 121 "ShowDefs.puma"
  276.    fprintf (SemFile, "Local variable %s, type = ", string);
  277. # line 122 "ShowDefs.puma"
  278.    ShowType (d->VarObject.decl);
  279. # line 123 "ShowDefs.puma"
  280.  if (d->VarObject.Kind->VarLocal.IsSave != 0) fprintf (SemFile, ", save ");
  281. # line 124 "ShowDefs.puma"
  282.    varrank = VarRank (d);
  283. # line 125 "ShowDefs.puma"
  284.    fprintf (SemFile, ", rank = %d", varrank);
  285. # line 126 "ShowDefs.puma"
  286.    fprintf (SemFile, ", uses = %d ", d->VarObject.uses);
  287. # line 127 "ShowDefs.puma"
  288.    ShowDistribution (d->VarObject.Dist);
  289. # line 128 "ShowDefs.puma"
  290.    fprintf (SemFile, "\n");
  291.   }
  292.    return;
  293.  
  294.   }
  295.   if (d->VarObject.Kind->Kind == kVarCommon) {
  296. # line 131 "ShowDefs.puma"
  297.   {
  298. # line 132 "ShowDefs.puma"
  299.    GetString (d->VarObject.ident, string);
  300. # line 133 "ShowDefs.puma"
  301.    fprintf (SemFile, "Common Variable %s (in ", string);
  302. # line 134 "ShowDefs.puma"
  303.    GetString (d->VarObject.Kind->VarCommon.Block, string);
  304. # line 135 "ShowDefs.puma"
  305.    fprintf (SemFile, "/%s/), type = ", string);
  306. # line 136 "ShowDefs.puma"
  307.    ShowType (d->VarObject.decl);
  308. # line 137 "ShowDefs.puma"
  309.    varrank = VarRank (d);
  310. # line 138 "ShowDefs.puma"
  311.    fprintf (SemFile, " rank = %d", varrank);
  312. # line 139 "ShowDefs.puma"
  313.    fprintf (SemFile, " uses = %d ", d->VarObject.uses);
  314. # line 140 "ShowDefs.puma"
  315.    ShowDistribution (d->VarObject.Dist);
  316. # line 141 "ShowDefs.puma"
  317.    fprintf (SemFile, "\n");
  318.   }
  319.    return;
  320.  
  321.   }
  322.   break;
  323.   }
  324.  
  325.   if (d->Kind == kTypeObject) {
  326. # line 144 "ShowDefs.puma"
  327.   {
  328. # line 145 "ShowDefs.puma"
  329.    GetString (d->TypeObject.ident, string);
  330. # line 146 "ShowDefs.puma"
  331.    fprintf (SemFile, "Type %s (derived)\n", string);
  332.   }
  333.    return;
  334.  
  335.   }
  336.   if (d->Kind == kTemplateObject) {
  337. # line 149 "ShowDefs.puma"
  338.   {
  339. # line 150 "ShowDefs.puma"
  340.    GetString (d->TemplateObject.ident, string);
  341. # line 151 "ShowDefs.puma"
  342.    fprintf (SemFile, "Template %s, dim = (", string);
  343. # line 152 "ShowDefs.puma"
  344.    ShowType (d->TemplateObject.decl);
  345. # line 153 "ShowDefs.puma"
  346.    fprintf (SemFile, ") ");
  347. # line 154 "ShowDefs.puma"
  348.    ShowDistribution (d->TemplateObject.Dist);
  349. # line 155 "ShowDefs.puma"
  350.    fprintf (SemFile, "\n");
  351.   }
  352.    return;
  353.  
  354.   }
  355.   if (d->Kind == kProcessorsObject) {
  356. # line 158 "ShowDefs.puma"
  357.   {
  358. # line 159 "ShowDefs.puma"
  359.    GetString (d->ProcessorsObject.ident, string);
  360. # line 160 "ShowDefs.puma"
  361.    fprintf (SemFile, "Processors %s, dim = (", string);
  362. # line 161 "ShowDefs.puma"
  363.    ShowType (d->ProcessorsObject.decl);
  364. # line 162 "ShowDefs.puma"
  365.    fprintf (SemFile, ")\n");
  366.   }
  367.    return;
  368.  
  369.   }
  370.   if (d->Kind == kNameListObject) {
  371. # line 165 "ShowDefs.puma"
  372.   {
  373. # line 166 "ShowDefs.puma"
  374.    GetString (d->NameListObject.ident, string);
  375. # line 167 "ShowDefs.puma"
  376.    fprintf (SemFile, "Namelist %s\n", string);
  377.   }
  378.    return;
  379.  
  380.   }
  381.   if (Definitions_IsType (d, kObject)) {
  382. # line 170 "ShowDefs.puma"
  383.   {
  384. # line 171 "ShowDefs.puma"
  385.    GetString (d->Object.ident, string);
  386. # line 172 "ShowDefs.puma"
  387.    fprintf (SemFile, "Object %s\n", string);
  388.   }
  389.    return;
  390.  
  391.   }
  392. ;
  393. }
  394.  
  395. static void ShowType
  396. # if defined __STDC__ | defined __cplusplus
  397. (register tTree t)
  398. # else
  399. (t)
  400.  register tTree t;
  401. # endif
  402. {
  403. # line 183 "ShowDefs.puma"
  404.  
  405. unsigned char string[256];
  406.  
  407.   if (t == NoTree) return;
  408.  
  409.   switch (t->Kind) {
  410.   case kDUMMY_TYPE:
  411. # line 187 "ShowDefs.puma"
  412.   {
  413. # line 187 "ShowDefs.puma"
  414.    fprintf (SemFile, "IMPLICIT");
  415.   }
  416.    return;
  417.  
  418.   case kINTEGER_TYPE:
  419. # line 189 "ShowDefs.puma"
  420.   {
  421. # line 189 "ShowDefs.puma"
  422.    fprintf (SemFile, "INTEGER*%d", t->INTEGER_TYPE.size);
  423.   }
  424.    return;
  425.  
  426.   case kBOOLEAN_TYPE:
  427. # line 191 "ShowDefs.puma"
  428.   {
  429. # line 191 "ShowDefs.puma"
  430.    fprintf (SemFile, "LOGICAL*%d", t->BOOLEAN_TYPE.size);
  431.   }
  432.    return;
  433.  
  434.   case kCOMPLEX_TYPE:
  435. # line 193 "ShowDefs.puma"
  436.   {
  437. # line 193 "ShowDefs.puma"
  438.    fprintf (SemFile, "COMPLEX*%d", t->COMPLEX_TYPE.size);
  439.   }
  440.    return;
  441.  
  442.   case kREAL_TYPE:
  443. # line 195 "ShowDefs.puma"
  444.   {
  445. # line 195 "ShowDefs.puma"
  446.    fprintf (SemFile, "REAL*%d", t->REAL_TYPE.size);
  447.   }
  448.    return;
  449.  
  450.   case kSTRING_TYPE:
  451. # line 197 "ShowDefs.puma"
  452.   {
  453. # line 198 "ShowDefs.puma"
  454.    fprintf (SemFile, "CHARACTER *");
  455. # line 199 "ShowDefs.puma"
  456.    FileUnparse (SemFile, t->STRING_TYPE.LENGTH);
  457.   }
  458.    return;
  459.  
  460.   case kARRAY_TYPE:
  461. # line 202 "ShowDefs.puma"
  462.   {
  463. # line 203 "ShowDefs.puma"
  464.    ShowType (t->ARRAY_TYPE.ARRAY_COMP_TYPE);
  465. # line 204 "ShowDefs.puma"
  466.    fprintf (SemFile, " (");
  467. # line 205 "ShowDefs.puma"
  468.    ShowType (t->ARRAY_TYPE.ARRAY_INDEX_TYPES);
  469. # line 206 "ShowDefs.puma"
  470.    fprintf (SemFile, ")");
  471.   }
  472.    return;
  473.  
  474.   case kTYPE_LIST:
  475.   if (t->TYPE_LIST.Next->Kind == kTYPE_LIST) {
  476. # line 209 "ShowDefs.puma"
  477.   {
  478. # line 210 "ShowDefs.puma"
  479.    ShowType (t->TYPE_LIST.Elem);
  480. # line 211 "ShowDefs.puma"
  481.    fprintf (SemFile, ",");
  482. # line 212 "ShowDefs.puma"
  483.    ShowType (t->TYPE_LIST.Next);
  484.   }
  485.    return;
  486.  
  487.   }
  488.   if (t->TYPE_LIST.Next->Kind == kTYPE_EMPTY) {
  489. # line 215 "ShowDefs.puma"
  490.   {
  491. # line 216 "ShowDefs.puma"
  492.    ShowType (t->TYPE_LIST.Elem);
  493.   }
  494.    return;
  495.  
  496.   }
  497.   break;
  498.   case kINDEX_TYPE:
  499.   if (equalint (t->INDEX_TYPE.left_overlap, 0)) {
  500.   if (equalint (t->INDEX_TYPE.right_overlap, 0)) {
  501. # line 219 "ShowDefs.puma"
  502.   {
  503. # line 220 "ShowDefs.puma"
  504.    FileUnparse (SemFile, t->INDEX_TYPE.LOWER);
  505. # line 221 "ShowDefs.puma"
  506.    fprintf (SemFile, ":");
  507. # line 222 "ShowDefs.puma"
  508.    FileUnparse (SemFile, t->INDEX_TYPE.UPPER);
  509.   }
  510.    return;
  511.  
  512.   }
  513.   }
  514. # line 225 "ShowDefs.puma"
  515.   {
  516. # line 226 "ShowDefs.puma"
  517.    FileUnparse (SemFile, t->INDEX_TYPE.LOWER);
  518. # line 227 "ShowDefs.puma"
  519.    fprintf (SemFile, ":");
  520. # line 228 "ShowDefs.puma"
  521.    FileUnparse (SemFile, t->INDEX_TYPE.UPPER);
  522. # line 229 "ShowDefs.puma"
  523.    fprintf (SemFile, "[%d:%d]", t->INDEX_TYPE.left_overlap, t->INDEX_TYPE.right_overlap);
  524.   }
  525.    return;
  526.  
  527.   case kDYNAMIC:
  528.   if (equalint (t->DYNAMIC.left_overlap, 0)) {
  529.   if (equalint (t->DYNAMIC.right_overlap, 0)) {
  530. # line 232 "ShowDefs.puma"
  531.   {
  532. # line 233 "ShowDefs.puma"
  533.    fprintf (SemFile, ":");
  534.   }
  535.    return;
  536.  
  537.   }
  538.   }
  539. # line 236 "ShowDefs.puma"
  540.   {
  541. # line 237 "ShowDefs.puma"
  542.    fprintf (SemFile, ":[%d:%d]", t->DYNAMIC.left_overlap, t->DYNAMIC.right_overlap);
  543.   }
  544.    return;
  545.  
  546.   case kVAR_DECL:
  547. # line 240 "ShowDefs.puma"
  548.   {
  549. # line 240 "ShowDefs.puma"
  550.    ShowType (t->VAR_DECL.VAL);
  551.   }
  552.    return;
  553.  
  554.   case kVAR_PARAM_DECL:
  555. # line 241 "ShowDefs.puma"
  556.   {
  557. # line 241 "ShowDefs.puma"
  558.    ShowType (t->VAR_PARAM_DECL.VAL);
  559.   }
  560.    return;
  561.  
  562.   case kTEMPLATE_DECL:
  563. # line 242 "ShowDefs.puma"
  564.   {
  565. # line 242 "ShowDefs.puma"
  566.    ShowType (t->TEMPLATE_DECL.DIMENSIONS);
  567.   }
  568.    return;
  569.  
  570.   case kPROCESSORS_DECL:
  571. # line 243 "ShowDefs.puma"
  572.   {
  573. # line 243 "ShowDefs.puma"
  574.    ShowType (t->PROCESSORS_DECL.DIMENSIONS);
  575.   }
  576.    return;
  577.  
  578.   }
  579.  
  580. ;
  581. }
  582.  
  583. static void ShowDistribution
  584. # if defined __STDC__ | defined __cplusplus
  585. (register tDefinitions distribution)
  586. # else
  587. (distribution)
  588.  register tDefinitions distribution;
  589. # endif
  590. {
  591.   if (distribution == NoDefinitions) return;
  592.   if (distribution->Kind == kDefaultDistribution) {
  593. # line 248 "ShowDefs.puma"
  594.   {
  595. # line 249 "ShowDefs.puma"
  596.    fprintf (SemFile, "default");
  597.   }
  598.    return;
  599.  
  600.   }
  601.   if (distribution->Kind == kHostDistribution) {
  602. # line 252 "ShowDefs.puma"
  603.   {
  604. # line 253 "ShowDefs.puma"
  605.    fprintf (SemFile, "only host");
  606.   }
  607.    return;
  608.  
  609.   }
  610.   if (distribution->Kind == kSerialDistribution) {
  611. # line 256 "ShowDefs.puma"
  612.   {
  613. # line 257 "ShowDefs.puma"
  614.    fprintf (SemFile, "replicated");
  615.   }
  616.    return;
  617.  
  618.   }
  619.   if (distribution->Kind == kNodeDistribution) {
  620. # line 260 "ShowDefs.puma"
  621.  {
  622.   int i;
  623.   {
  624. # line 261 "ShowDefs.puma"
  625.    fprintf (SemFile, "distributed(");
  626. # line 262 "ShowDefs.puma"
  627.  
  628. # line 263 "ShowDefs.puma"
  629.  for (i=0; i<distribution->NodeDistribution.dims.no_dims; i++)
  630.       { if (distribution->NodeDistribution.dims.DimsArray[i] == 0)
  631.            fprintf (SemFile,"*");
  632.          else if (distribution->NodeDistribution.dims.DimsArray[i] == 1)
  633.            fprintf (SemFile,"B");
  634.          else if (distribution->NodeDistribution.dims.DimsArray[i] == 2)
  635.            fprintf (SemFile,"C");
  636.          else
  637.            fprintf (SemFile,"-");
  638.        }
  639.  
  640. # line 274 "ShowDefs.puma"
  641.    fprintf (SemFile, ")");
  642.   }
  643.    return;
  644.  }
  645.  
  646.   }
  647.   if (distribution->Kind == kAlignDistribution) {
  648. # line 277 "ShowDefs.puma"
  649.  {
  650.   int i;
  651.   {
  652. # line 278 "ShowDefs.puma"
  653.    fprintf (SemFile, "aligned(");
  654. # line 279 "ShowDefs.puma"
  655.  
  656. # line 280 "ShowDefs.puma"
  657.  for (i=0; i<distribution->AlignDistribution.dims.no_dims; i++)
  658.       { if (distribution->AlignDistribution.dims.DimsArray[i] == 0)
  659.            fprintf (SemFile,"*");
  660.          else if (distribution->AlignDistribution.dims.DimsArray[i] == -1)
  661.            fprintf (SemFile,"#");
  662.          else
  663.            fprintf (SemFile,"%d", distribution->AlignDistribution.dims.DimsArray[i]);
  664.  
  665.       }
  666.  
  667. # line 290 "ShowDefs.puma"
  668.    fprintf (SemFile, ")");
  669.   }
  670.    return;
  671.  }
  672.  
  673.   }
  674. ;
  675. }
  676.  
  677. void BeginShowDefs ()
  678. {
  679. }
  680.  
  681. void CloseShowDefs ()
  682. {
  683. }
  684.