home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / prgramer / adaptor / src / tree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-03  |  376.8 KB  |  12,596 lines
  1. # include "Tree.h"
  2. # define yyALLOC(ptr, size)    if ((ptr = (tTree) Tree_PoolFreePtr) >= (tTree) Tree_PoolMaxPtr) \
  3.   ptr = Tree_Alloc (); \
  4.   Tree_PoolFreePtr += size;
  5. # define yyFREE(ptr, size)    
  6. # ifdef __cplusplus
  7. extern "C" {
  8. # include <stdio.h>
  9. # include "yyTree.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 "yyTree.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 52 "ast.cg" */
  29.  
  30.  
  31. tIdent DefaultId ()
  32. { return (MakeIdent (" ", 1)); }
  33.  
  34.  
  35.  
  36. # define yyBlockSize 20480
  37.  
  38. typedef struct yysBlock {
  39.  char yyBlock [yyBlockSize];
  40.  struct yysBlock * yySuccessor;
  41. } yytBlock, * yytBlockPtr;
  42.  
  43. tTree TreeRoot;
  44. unsigned long Tree_HeapUsed = 0;
  45.  
  46. static yytBlockPtr yyBlockList    = (yytBlockPtr) NoTree;
  47. char * Tree_PoolFreePtr    = (char *) NoTree;
  48. char * Tree_PoolMaxPtr    = (char *) NoTree;
  49. static unsigned short yyMaxSize    = 0;
  50. unsigned short Tree_NodeSize [249 + 1] = { 0,
  51.  sizeof (yCOMP_UNIT),
  52.  sizeof (yBODY_NODE),
  53.  sizeof (yTYPE_NODE),
  54.  sizeof (yDUMMY_TYPE),
  55.  sizeof (yVOID_TYPE),
  56.  sizeof (yINTEGER_TYPE),
  57.  sizeof (yCARDINAL_TYPE),
  58.  sizeof (yREAL_TYPE),
  59.  sizeof (yBOOLEAN_TYPE),
  60.  sizeof (yCOMPLEX_TYPE),
  61.  sizeof (yCHAR_TYPE),
  62.  sizeof (ySTRING_TYPE),
  63.  sizeof (yINDEX_TYPE),
  64.  sizeof (yTYPE_ID),
  65.  sizeof (yARRAY_TYPE),
  66.  sizeof (yRECORD_TYPE),
  67.  sizeof (yUNION_TYPE),
  68.  sizeof (yENUM_TYPE),
  69.  sizeof (yDYNAMIC),
  70.  sizeof (yPOINTER_TYPE),
  71.  sizeof (yARRAY1_TYPE),
  72.  sizeof (yFUNCTION_TYPE),
  73.  sizeof (yTYPE_NODE_LIST),
  74.  sizeof (yTYPE_EMPTY),
  75.  sizeof (yTYPE_LIST),
  76.  sizeof (yDECL_NODE),
  77.  sizeof (yMODULE_DECL),
  78.  sizeof (yPROGRAM_DECL),
  79.  sizeof (yPROC_DECL),
  80.  sizeof (yFUNC_DECL),
  81.  sizeof (yBLOCK_DATA_DECL),
  82.  sizeof (yTYPE_DECL),
  83.  sizeof (yNAME_DECL),
  84.  sizeof (yRENAME_DECL),
  85.  sizeof (yENTITY_DECL),
  86.  sizeof (yVAR_DECL),
  87.  sizeof (yCOMMON_DECL),
  88.  sizeof (yNAMELIST_DECL),
  89.  sizeof (yTEMPLATE_DECL),
  90.  sizeof (yPROCESSORS_DECL),
  91.  sizeof (yINHERIT_DECL),
  92.  sizeof (ySTMT_FUNC_DECL),
  93.  sizeof (yINTERFACE_DECL),
  94.  sizeof (yEXT_PROC_DECL),
  95.  sizeof (yEXT_FUNC_DECL),
  96.  sizeof (yVAL_PARAM_DECL),
  97.  sizeof (yVAR_PARAM_DECL),
  98.  sizeof (yPROC_PARAM_DECL),
  99.  sizeof (yFUNC_PARAM_DECL),
  100.  sizeof (yELIPSIS_PARAM_DECL),
  101.  sizeof (yRET_PARAM_DECL),
  102.  sizeof (yIMPLICIT_DECL),
  103.  sizeof (yUSE_DECL),
  104.  sizeof (yONLY_USE_DECL),
  105.  sizeof (yEQV_DECL),
  106.  sizeof (yDATA_DECL),
  107.  sizeof (yDIMENSION_DECL),
  108.  sizeof (yINIT_DATA_DECL),
  109.  sizeof (yTYPESPEC_DECL),
  110.  sizeof (yALLOCATABLE_DECL),
  111.  sizeof (yEXTERNAL_DECL),
  112.  sizeof (yINTENT_DECL),
  113.  sizeof (yINTRINSIC_DECL),
  114.  sizeof (yOPTIONAL_DECL),
  115.  sizeof (yPOINTER_DECL),
  116.  sizeof (ySAVE_DECL),
  117.  sizeof (yTARGET_DECL),
  118.  sizeof (yPARAMETER_DECL),
  119.  sizeof (yPUBLIC_DECL),
  120.  sizeof (yPRIVATE_DECL),
  121.  sizeof (yDISTRIBUTE_DECL),
  122.  sizeof (yALIGN_DECL),
  123.  sizeof (yDYNAMIC_DECL),
  124.  sizeof (ySEQUENCE_DECL),
  125.  sizeof (yNOSEQUENCE_DECL),
  126.  sizeof (yDECL_NODE_LIST),
  127.  sizeof (yDECL_EMPTY),
  128.  sizeof (yDECL_LIST),
  129.  sizeof (yDISTRIBUTION_SPEC),
  130.  sizeof (yHOST_DISTRIBUTION),
  131.  sizeof (yREPL_DISTRIBUTION),
  132.  sizeof (yNODE_DISTRIBUTION),
  133.  sizeof (yDISTRIBUTION_FORMAT),
  134.  sizeof (yBLOCK_DISTRIBUTION),
  135.  sizeof (yCYCLIC_DISTRIBUTION),
  136.  sizeof (ySERIAL_DISTRIBUTION),
  137.  sizeof (yDIST_FORMAT_LIST),
  138.  sizeof (yDIST_EMPTY),
  139.  sizeof (yDIST_LIST),
  140.  sizeof (yGENERIC_SPEC),
  141.  sizeof (yNO_GENERIC_SPEC),
  142.  sizeof (yID_GENERIC_SPEC),
  143.  sizeof (yOP_GENERIC_SPEC),
  144.  sizeof (yASSIGN_GENERIC_SPEC),
  145.  sizeof (yACF_NODE_LIST),
  146.  sizeof (yACF_EMPTY),
  147.  sizeof (yACF_LIST),
  148.  sizeof (yACF_NODE),
  149.  sizeof (yACF_DUMMY),
  150.  sizeof (yACF_BASIC),
  151.  sizeof (yACF_IF),
  152.  sizeof (yACF_WHERE),
  153.  sizeof (yACF_SWITCH),
  154.  sizeof (yACF_ALTER),
  155.  sizeof (yACF_CASE),
  156.  sizeof (yACF_WHILE),
  157.  sizeof (yACF_REPEAT),
  158.  sizeof (yACF_WITH),
  159.  sizeof (yACF_LOOP),
  160.  sizeof (yACF_DO),
  161.  sizeof (yACF_DOLOCAL),
  162.  sizeof (yACF_DOVEC),
  163.  sizeof (yACF_DOALL),
  164.  sizeof (yACF_FORALL),
  165.  sizeof (yACF_ON),
  166.  sizeof (yACF_BODY),
  167.  sizeof (yACF_FLOW_GRAPH),
  168.  sizeof (yACF_ENTRY),
  169.  sizeof (yACF_FLOW_KIND),
  170.  sizeof (yACF_COMPLEX_FLOW),
  171.  sizeof (yACF_INTERVAL_FLOW),
  172.  sizeof (yACF_SIMPLE_FLOW),
  173.  sizeof (ySELECTED_ACF_NODE_LIST),
  174.  sizeof (ySELECTED_ACF_EMPTY),
  175.  sizeof (ySELECTED_ACF_LIST),
  176.  sizeof (ySELECTED_ACF_NODE),
  177.  sizeof (yBT_STMT),
  178.  sizeof (yEXP_STMT),
  179.  sizeof (yASSIGN_STMT),
  180.  sizeof (yPTR_ASSIGN_STMT),
  181.  sizeof (yLABEL_ASSIGN_STMT),
  182.  sizeof (yCALL_STMT),
  183.  sizeof (yIO_STMT),
  184.  sizeof (yGOTO_STMT),
  185.  sizeof (yASS_GOTO_STMT),
  186.  sizeof (yCOMP_GOTO_STMT),
  187.  sizeof (yCOMP_IF_STMT),
  188.  sizeof (yRETURN_STMT),
  189.  sizeof (yPAUSE_STMT),
  190.  sizeof (yEXIT_STMT),
  191.  sizeof (yCYCLE_STMT),
  192.  sizeof (ySTOP_STMT),
  193.  sizeof (yFORMAT_STMT),
  194.  sizeof (yALLOCATE_STMT),
  195.  sizeof (yDEALLOCATE_STMT),
  196.  sizeof (yNULLIFY_STMT),
  197.  sizeof (yREDUCE_STMT),
  198.  sizeof (yGLOBAL_STMT),
  199.  sizeof (yALIGN_STMT),
  200.  sizeof (yDISTRIBUTE_STMT),
  201.  sizeof (yLABEL_USE_LIST),
  202.  sizeof (yLABEL_EMPTY),
  203.  sizeof (yLABEL_LIST),
  204.  sizeof (yOP),
  205.  sizeof (yOP_EQ),
  206.  sizeof (yOP_NE),
  207.  sizeof (yOP_LT),
  208.  sizeof (yOP_GT),
  209.  sizeof (yOP_GE),
  210.  sizeof (yOP_LE),
  211.  sizeof (yOP_PLUS),
  212.  sizeof (yOP_MINUS),
  213.  sizeof (yOP_XOR),
  214.  sizeof (yOP_OR),
  215.  sizeof (yOP_CONCAT),
  216.  sizeof (yOP_TIMES),
  217.  sizeof (yOP_DIVIDE),
  218.  sizeof (yOP_DIV),
  219.  sizeof (yOP_AND),
  220.  sizeof (yOP_EQV),
  221.  sizeof (yOP_NEQV),
  222.  sizeof (yOP_EXPO),
  223.  sizeof (yOP_MOD),
  224.  sizeof (yOP_IN),
  225.  sizeof (yOP_DEFINED),
  226.  sizeof (yOP_ASSIGN),
  227.  sizeof (yOP_LEFT),
  228.  sizeof (yOP_RIGHT),
  229.  sizeof (yOP_LIST),
  230.  sizeof (yOP_IOR),
  231.  sizeof (yOP_IXOR),
  232.  sizeof (yOP_IAND),
  233.  sizeof (yOP1_NOT),
  234.  sizeof (yOP1_SIGN),
  235.  sizeof (yOP1_INOT),
  236.  sizeof (yOP1_SIZE),
  237.  sizeof (yOP1_DEC),
  238.  sizeof (yOP1_INC),
  239.  sizeof (yOP1_ADDRESS),
  240.  sizeof (yOP1_DEREF),
  241.  sizeof (yBT_EXP),
  242.  sizeof (yDUMMY_EXP),
  243.  sizeof (yCONST_EXP),
  244.  sizeof (yOP_EXP),
  245.  sizeof (yOP1_EXP),
  246.  sizeof (ySLICE_EXP),
  247.  sizeof (yPOSTFIX_EXP),
  248.  sizeof (yCALL_EXP),
  249.  sizeof (yCAST_EXP),
  250.  sizeof (yINDEXED_EXP),
  251.  sizeof (ySELECTED_EXP),
  252.  sizeof (yASSIGN_EXP),
  253.  sizeof (yUSED_EXP),
  254.  sizeof (yCOND_EXP),
  255.  sizeof (yVAR_EXP),
  256.  sizeof (yFUNC_CALL_EXP),
  257.  sizeof (yNAMED_EXP),
  258.  sizeof (yDO_EXP),
  259.  sizeof (yTYPE_EXP),
  260.  sizeof (yARRAY_EXP),
  261.  sizeof (yBT_EXP_LIST),
  262.  sizeof (yBTE_EMPTY),
  263.  sizeof (yBTE_LIST),
  264.  sizeof (yBT_VAR),
  265.  sizeof (yDUMMY_VAR),
  266.  sizeof (yUSED_VAR),
  267.  sizeof (yINDEXED_VAR),
  268.  sizeof (ySUBSTRING_VAR),
  269.  sizeof (ySELECTED_VAR),
  270.  sizeof (yLOOP_VAR),
  271.  sizeof (yADDR),
  272.  sizeof (yDO_VAR),
  273.  sizeof (yBT_VAR_LIST),
  274.  sizeof (yBTV_EMPTY),
  275.  sizeof (yBTV_LIST),
  276.  sizeof (yBT_PARAM),
  277.  sizeof (yVAR_PARAM),
  278.  sizeof (yVALUE_PARAM),
  279.  sizeof (yNAMED_PARAM),
  280.  sizeof (yPROC_PARAM),
  281.  sizeof (yFUNC_PARAM),
  282.  sizeof (yFORMAT_PARAM),
  283.  sizeof (yRETURN_PARAM),
  284.  sizeof (yNO_PARAM),
  285.  sizeof (yBT_PARAM_LIST),
  286.  sizeof (yBTP_EMPTY),
  287.  sizeof (yBTP_LIST),
  288.  sizeof (yCONSTANT),
  289.  sizeof (yBOOL_CONSTANT),
  290.  sizeof (yINT_CONSTANT),
  291.  sizeof (yREAL_CONSTANT),
  292.  sizeof (yDREAL_CONSTANT),
  293.  sizeof (yCHAR_CONSTANT),
  294.  sizeof (ySTRING_CONSTANT),
  295.  sizeof (yCOMPLEX_CONSTANT),
  296.  sizeof (yPROC_OBJ),
  297.  sizeof (yVAR_OBJ),
  298.  sizeof (yTYPE_OBJ),
  299.  sizeof (yREC_COMP),
  300. };
  301. char * Tree_NodeName [249 + 1] = {
  302.  "NoTree",
  303.  "COMP_UNIT",
  304.  "BODY_NODE",
  305.  "TYPE_NODE",
  306.  "DUMMY_TYPE",
  307.  "VOID_TYPE",
  308.  "INTEGER_TYPE",
  309.  "CARDINAL_TYPE",
  310.  "REAL_TYPE",
  311.  "BOOLEAN_TYPE",
  312.  "COMPLEX_TYPE",
  313.  "CHAR_TYPE",
  314.  "STRING_TYPE",
  315.  "INDEX_TYPE",
  316.  "TYPE_ID",
  317.  "ARRAY_TYPE",
  318.  "RECORD_TYPE",
  319.  "UNION_TYPE",
  320.  "ENUM_TYPE",
  321.  "DYNAMIC",
  322.  "POINTER_TYPE",
  323.  "ARRAY1_TYPE",
  324.  "FUNCTION_TYPE",
  325.  "TYPE_NODE_LIST",
  326.  "TYPE_EMPTY",
  327.  "TYPE_LIST",
  328.  "DECL_NODE",
  329.  "MODULE_DECL",
  330.  "PROGRAM_DECL",
  331.  "PROC_DECL",
  332.  "FUNC_DECL",
  333.  "BLOCK_DATA_DECL",
  334.  "TYPE_DECL",
  335.  "NAME_DECL",
  336.  "RENAME_DECL",
  337.  "ENTITY_DECL",
  338.  "VAR_DECL",
  339.  "COMMON_DECL",
  340.  "NAMELIST_DECL",
  341.  "TEMPLATE_DECL",
  342.  "PROCESSORS_DECL",
  343.  "INHERIT_DECL",
  344.  "STMT_FUNC_DECL",
  345.  "INTERFACE_DECL",
  346.  "EXT_PROC_DECL",
  347.  "EXT_FUNC_DECL",
  348.  "VAL_PARAM_DECL",
  349.  "VAR_PARAM_DECL",
  350.  "PROC_PARAM_DECL",
  351.  "FUNC_PARAM_DECL",
  352.  "ELIPSIS_PARAM_DECL",
  353.  "RET_PARAM_DECL",
  354.  "IMPLICIT_DECL",
  355.  "USE_DECL",
  356.  "ONLY_USE_DECL",
  357.  "EQV_DECL",
  358.  "DATA_DECL",
  359.  "DIMENSION_DECL",
  360.  "INIT_DATA_DECL",
  361.  "TYPESPEC_DECL",
  362.  "ALLOCATABLE_DECL",
  363.  "EXTERNAL_DECL",
  364.  "INTENT_DECL",
  365.  "INTRINSIC_DECL",
  366.  "OPTIONAL_DECL",
  367.  "POINTER_DECL",
  368.  "SAVE_DECL",
  369.  "TARGET_DECL",
  370.  "PARAMETER_DECL",
  371.  "PUBLIC_DECL",
  372.  "PRIVATE_DECL",
  373.  "DISTRIBUTE_DECL",
  374.  "ALIGN_DECL",
  375.  "DYNAMIC_DECL",
  376.  "SEQUENCE_DECL",
  377.  "NOSEQUENCE_DECL",
  378.  "DECL_NODE_LIST",
  379.  "DECL_EMPTY",
  380.  "DECL_LIST",
  381.  "DISTRIBUTION_SPEC",
  382.  "HOST_DISTRIBUTION",
  383.  "REPL_DISTRIBUTION",
  384.  "NODE_DISTRIBUTION",
  385.  "DISTRIBUTION_FORMAT",
  386.  "BLOCK_DISTRIBUTION",
  387.  "CYCLIC_DISTRIBUTION",
  388.  "SERIAL_DISTRIBUTION",
  389.  "DIST_FORMAT_LIST",
  390.  "DIST_EMPTY",
  391.  "DIST_LIST",
  392.  "GENERIC_SPEC",
  393.  "NO_GENERIC_SPEC",
  394.  "ID_GENERIC_SPEC",
  395.  "OP_GENERIC_SPEC",
  396.  "ASSIGN_GENERIC_SPEC",
  397.  "ACF_NODE_LIST",
  398.  "ACF_EMPTY",
  399.  "ACF_LIST",
  400.  "ACF_NODE",
  401.  "ACF_DUMMY",
  402.  "ACF_BASIC",
  403.  "ACF_IF",
  404.  "ACF_WHERE",
  405.  "ACF_SWITCH",
  406.  "ACF_ALTER",
  407.  "ACF_CASE",
  408.  "ACF_WHILE",
  409.  "ACF_REPEAT",
  410.  "ACF_WITH",
  411.  "ACF_LOOP",
  412.  "ACF_DO",
  413.  "ACF_DOLOCAL",
  414.  "ACF_DOVEC",
  415.  "ACF_DOALL",
  416.  "ACF_FORALL",
  417.  "ACF_ON",
  418.  "ACF_BODY",
  419.  "ACF_FLOW_GRAPH",
  420.  "ACF_ENTRY",
  421.  "ACF_FLOW_KIND",
  422.  "ACF_COMPLEX_FLOW",
  423.  "ACF_INTERVAL_FLOW",
  424.  "ACF_SIMPLE_FLOW",
  425.  "SELECTED_ACF_NODE_LIST",
  426.  "SELECTED_ACF_EMPTY",
  427.  "SELECTED_ACF_LIST",
  428.  "SELECTED_ACF_NODE",
  429.  "BT_STMT",
  430.  "EXP_STMT",
  431.  "ASSIGN_STMT",
  432.  "PTR_ASSIGN_STMT",
  433.  "LABEL_ASSIGN_STMT",
  434.  "CALL_STMT",
  435.  "IO_STMT",
  436.  "GOTO_STMT",
  437.  "ASS_GOTO_STMT",
  438.  "COMP_GOTO_STMT",
  439.  "COMP_IF_STMT",
  440.  "RETURN_STMT",
  441.  "PAUSE_STMT",
  442.  "EXIT_STMT",
  443.  "CYCLE_STMT",
  444.  "STOP_STMT",
  445.  "FORMAT_STMT",
  446.  "ALLOCATE_STMT",
  447.  "DEALLOCATE_STMT",
  448.  "NULLIFY_STMT",
  449.  "REDUCE_STMT",
  450.  "GLOBAL_STMT",
  451.  "ALIGN_STMT",
  452.  "DISTRIBUTE_STMT",
  453.  "LABEL_USE_LIST",
  454.  "LABEL_EMPTY",
  455.  "LABEL_LIST",
  456.  "OP",
  457.  "OP_EQ",
  458.  "OP_NE",
  459.  "OP_LT",
  460.  "OP_GT",
  461.  "OP_GE",
  462.  "OP_LE",
  463.  "OP_PLUS",
  464.  "OP_MINUS",
  465.  "OP_XOR",
  466.  "OP_OR",
  467.  "OP_CONCAT",
  468.  "OP_TIMES",
  469.  "OP_DIVIDE",
  470.  "OP_DIV",
  471.  "OP_AND",
  472.  "OP_EQV",
  473.  "OP_NEQV",
  474.  "OP_EXPO",
  475.  "OP_MOD",
  476.  "OP_IN",
  477.  "OP_DEFINED",
  478.  "OP_ASSIGN",
  479.  "OP_LEFT",
  480.  "OP_RIGHT",
  481.  "OP_LIST",
  482.  "OP_IOR",
  483.  "OP_IXOR",
  484.  "OP_IAND",
  485.  "OP1_NOT",
  486.  "OP1_SIGN",
  487.  "OP1_INOT",
  488.  "OP1_SIZE",
  489.  "OP1_DEC",
  490.  "OP1_INC",
  491.  "OP1_ADDRESS",
  492.  "OP1_DEREF",
  493.  "BT_EXP",
  494.  "DUMMY_EXP",
  495.  "CONST_EXP",
  496.  "OP_EXP",
  497.  "OP1_EXP",
  498.  "SLICE_EXP",
  499.  "POSTFIX_EXP",
  500.  "CALL_EXP",
  501.  "CAST_EXP",
  502.  "INDEXED_EXP",
  503.  "SELECTED_EXP",
  504.  "ASSIGN_EXP",
  505.  "USED_EXP",
  506.  "COND_EXP",
  507.  "VAR_EXP",
  508.  "FUNC_CALL_EXP",
  509.  "NAMED_EXP",
  510.  "DO_EXP",
  511.  "TYPE_EXP",
  512.  "ARRAY_EXP",
  513.  "BT_EXP_LIST",
  514.  "BTE_EMPTY",
  515.  "BTE_LIST",
  516.  "BT_VAR",
  517.  "DUMMY_VAR",
  518.  "USED_VAR",
  519.  "INDEXED_VAR",
  520.  "SUBSTRING_VAR",
  521.  "SELECTED_VAR",
  522.  "LOOP_VAR",
  523.  "ADDR",
  524.  "DO_VAR",
  525.  "BT_VAR_LIST",
  526.  "BTV_EMPTY",
  527.  "BTV_LIST",
  528.  "BT_PARAM",
  529.  "VAR_PARAM",
  530.  "VALUE_PARAM",
  531.  "NAMED_PARAM",
  532.  "PROC_PARAM",
  533.  "FUNC_PARAM",
  534.  "FORMAT_PARAM",
  535.  "RETURN_PARAM",
  536.  "NO_PARAM",
  537.  "BT_PARAM_LIST",
  538.  "BTP_EMPTY",
  539.  "BTP_LIST",
  540.  "CONSTANT",
  541.  "BOOL_CONSTANT",
  542.  "INT_CONSTANT",
  543.  "REAL_CONSTANT",
  544.  "DREAL_CONSTANT",
  545.  "CHAR_CONSTANT",
  546.  "STRING_CONSTANT",
  547.  "COMPLEX_CONSTANT",
  548.  "PROC_OBJ",
  549.  "VAR_OBJ",
  550.  "TYPE_OBJ",
  551.  "REC_COMP",
  552. };
  553. static Tree_tKind yyTypeRange [249 + 1] = { 0,
  554.  kCOMP_UNIT,
  555.  kBODY_NODE,
  556.  kFUNCTION_TYPE,
  557.  kDUMMY_TYPE,
  558.  kVOID_TYPE,
  559.  kINTEGER_TYPE,
  560.  kCARDINAL_TYPE,
  561.  kREAL_TYPE,
  562.  kBOOLEAN_TYPE,
  563.  kCOMPLEX_TYPE,
  564.  kCHAR_TYPE,
  565.  kSTRING_TYPE,
  566.  kINDEX_TYPE,
  567.  kTYPE_ID,
  568.  kARRAY_TYPE,
  569.  kRECORD_TYPE,
  570.  kUNION_TYPE,
  571.  kENUM_TYPE,
  572.  kDYNAMIC,
  573.  kPOINTER_TYPE,
  574.  kARRAY1_TYPE,
  575.  kFUNCTION_TYPE,
  576.  kTYPE_LIST,
  577.  kTYPE_EMPTY,
  578.  kTYPE_LIST,
  579.  kNOSEQUENCE_DECL,
  580.  kMODULE_DECL,
  581.  kPROGRAM_DECL,
  582.  kPROC_DECL,
  583.  kFUNC_DECL,
  584.  kBLOCK_DATA_DECL,
  585.  kTYPE_DECL,
  586.  kNAME_DECL,
  587.  kRENAME_DECL,
  588.  kENTITY_DECL,
  589.  kVAR_DECL,
  590.  kCOMMON_DECL,
  591.  kNAMELIST_DECL,
  592.  kTEMPLATE_DECL,
  593.  kPROCESSORS_DECL,
  594.  kINHERIT_DECL,
  595.  kSTMT_FUNC_DECL,
  596.  kINTERFACE_DECL,
  597.  kEXT_PROC_DECL,
  598.  kEXT_FUNC_DECL,
  599.  kVAL_PARAM_DECL,
  600.  kVAR_PARAM_DECL,
  601.  kPROC_PARAM_DECL,
  602.  kFUNC_PARAM_DECL,
  603.  kELIPSIS_PARAM_DECL,
  604.  kRET_PARAM_DECL,
  605.  kIMPLICIT_DECL,
  606.  kUSE_DECL,
  607.  kONLY_USE_DECL,
  608.  kEQV_DECL,
  609.  kDATA_DECL,
  610.  kDIMENSION_DECL,
  611.  kINIT_DATA_DECL,
  612.  kTYPESPEC_DECL,
  613.  kALLOCATABLE_DECL,
  614.  kEXTERNAL_DECL,
  615.  kINTENT_DECL,
  616.  kINTRINSIC_DECL,
  617.  kOPTIONAL_DECL,
  618.  kPOINTER_DECL,
  619.  kSAVE_DECL,
  620.  kTARGET_DECL,
  621.  kPARAMETER_DECL,
  622.  kPUBLIC_DECL,
  623.  kPRIVATE_DECL,
  624.  kDISTRIBUTE_DECL,
  625.  kALIGN_DECL,
  626.  kDYNAMIC_DECL,
  627.  kSEQUENCE_DECL,
  628.  kNOSEQUENCE_DECL,
  629.  kDECL_LIST,
  630.  kDECL_EMPTY,
  631.  kDECL_LIST,
  632.  kNODE_DISTRIBUTION,
  633.  kHOST_DISTRIBUTION,
  634.  kREPL_DISTRIBUTION,
  635.  kNODE_DISTRIBUTION,
  636.  kSERIAL_DISTRIBUTION,
  637.  kBLOCK_DISTRIBUTION,
  638.  kCYCLIC_DISTRIBUTION,
  639.  kSERIAL_DISTRIBUTION,
  640.  kDIST_LIST,
  641.  kDIST_EMPTY,
  642.  kDIST_LIST,
  643.  kASSIGN_GENERIC_SPEC,
  644.  kNO_GENERIC_SPEC,
  645.  kID_GENERIC_SPEC,
  646.  kOP_GENERIC_SPEC,
  647.  kASSIGN_GENERIC_SPEC,
  648.  kACF_LIST,
  649.  kACF_EMPTY,
  650.  kACF_LIST,
  651.  kACF_ENTRY,
  652.  kACF_DUMMY,
  653.  kACF_BASIC,
  654.  kACF_IF,
  655.  kACF_WHERE,
  656.  kACF_SWITCH,
  657.  kACF_ALTER,
  658.  kACF_CASE,
  659.  kACF_WHILE,
  660.  kACF_REPEAT,
  661.  kACF_WITH,
  662.  kACF_LOOP,
  663.  kACF_DO,
  664.  kACF_DOLOCAL,
  665.  kACF_DOVEC,
  666.  kACF_DOALL,
  667.  kACF_FORALL,
  668.  kACF_ON,
  669.  kACF_BODY,
  670.  kACF_FLOW_GRAPH,
  671.  kACF_ENTRY,
  672.  kACF_SIMPLE_FLOW,
  673.  kACF_COMPLEX_FLOW,
  674.  kACF_INTERVAL_FLOW,
  675.  kACF_SIMPLE_FLOW,
  676.  kSELECTED_ACF_LIST,
  677.  kSELECTED_ACF_EMPTY,
  678.  kSELECTED_ACF_LIST,
  679.  kSELECTED_ACF_NODE,
  680.  kDISTRIBUTE_STMT,
  681.  kEXP_STMT,
  682.  kASSIGN_STMT,
  683.  kPTR_ASSIGN_STMT,
  684.  kLABEL_ASSIGN_STMT,
  685.  kCALL_STMT,
  686.  kIO_STMT,
  687.  kGOTO_STMT,
  688.  kASS_GOTO_STMT,
  689.  kCOMP_GOTO_STMT,
  690.  kCOMP_IF_STMT,
  691.  kRETURN_STMT,
  692.  kPAUSE_STMT,
  693.  kEXIT_STMT,
  694.  kCYCLE_STMT,
  695.  kSTOP_STMT,
  696.  kFORMAT_STMT,
  697.  kALLOCATE_STMT,
  698.  kDEALLOCATE_STMT,
  699.  kNULLIFY_STMT,
  700.  kREDUCE_STMT,
  701.  kGLOBAL_STMT,
  702.  kALIGN_STMT,
  703.  kDISTRIBUTE_STMT,
  704.  kLABEL_LIST,
  705.  kLABEL_EMPTY,
  706.  kLABEL_LIST,
  707.  kOP1_DEREF,
  708.  kOP_EQ,
  709.  kOP_NE,
  710.  kOP_LT,
  711.  kOP_GT,
  712.  kOP_GE,
  713.  kOP_LE,
  714.  kOP_PLUS,
  715.  kOP_MINUS,
  716.  kOP_XOR,
  717.  kOP_OR,
  718.  kOP_CONCAT,
  719.  kOP_TIMES,
  720.  kOP_DIVIDE,
  721.  kOP_DIV,
  722.  kOP_AND,
  723.  kOP_EQV,
  724.  kOP_NEQV,
  725.  kOP_EXPO,
  726.  kOP_MOD,
  727.  kOP_IN,
  728.  kOP_DEFINED,
  729.  kOP_ASSIGN,
  730.  kOP_LEFT,
  731.  kOP_RIGHT,
  732.  kOP_LIST,
  733.  kOP_IOR,
  734.  kOP_IXOR,
  735.  kOP_IAND,
  736.  kOP1_NOT,
  737.  kOP1_SIGN,
  738.  kOP1_INOT,
  739.  kOP1_SIZE,
  740.  kOP1_DEC,
  741.  kOP1_INC,
  742.  kOP1_ADDRESS,
  743.  kOP1_DEREF,
  744.  kARRAY_EXP,
  745.  kDUMMY_EXP,
  746.  kCONST_EXP,
  747.  kOP_EXP,
  748.  kOP1_EXP,
  749.  kSLICE_EXP,
  750.  kPOSTFIX_EXP,
  751.  kCALL_EXP,
  752.  kCAST_EXP,
  753.  kINDEXED_EXP,
  754.  kSELECTED_EXP,
  755.  kASSIGN_EXP,
  756.  kUSED_EXP,
  757.  kCOND_EXP,
  758.  kVAR_EXP,
  759.  kFUNC_CALL_EXP,
  760.  kNAMED_EXP,
  761.  kDO_EXP,
  762.  kTYPE_EXP,
  763.  kARRAY_EXP,
  764.  kBTE_LIST,
  765.  kBTE_EMPTY,
  766.  kBTE_LIST,
  767.  kDO_VAR,
  768.  kDUMMY_VAR,
  769.  kUSED_VAR,
  770.  kINDEXED_VAR,
  771.  kSUBSTRING_VAR,
  772.  kSELECTED_VAR,
  773.  kLOOP_VAR,
  774.  kADDR,
  775.  kDO_VAR,
  776.  kBTV_LIST,
  777.  kBTV_EMPTY,
  778.  kBTV_LIST,
  779.  kNO_PARAM,
  780.  kVAR_PARAM,
  781.  kVALUE_PARAM,
  782.  kNAMED_PARAM,
  783.  kPROC_PARAM,
  784.  kFUNC_PARAM,
  785.  kFORMAT_PARAM,
  786.  kRETURN_PARAM,
  787.  kNO_PARAM,
  788.  kBTP_LIST,
  789.  kBTP_EMPTY,
  790.  kBTP_LIST,
  791.  kCOMPLEX_CONSTANT,
  792.  kBOOL_CONSTANT,
  793.  kINT_CONSTANT,
  794.  kREAL_CONSTANT,
  795.  kDREAL_CONSTANT,
  796.  kCHAR_CONSTANT,
  797.  kSTRING_CONSTANT,
  798.  kCOMPLEX_CONSTANT,
  799.  kPROC_OBJ,
  800.  kVAR_OBJ,
  801.  kTYPE_OBJ,
  802.  kREC_COMP,
  803. };
  804.  
  805. tTree Tree_Alloc ()
  806. {
  807.  register yytBlockPtr yyBlockPtr = yyBlockList;
  808.  register int i;
  809.  
  810.  if (yyMaxSize == 0)
  811.   for (i = 1; i <= 249; i ++) {
  812.    Tree_NodeSize [i] = (Tree_NodeSize [i] + yyMaxAlign - 1) & yyAlignMasks [yyMaxAlign];
  813.    yyMaxSize = Max (Tree_NodeSize [i], yyMaxSize);
  814.   }
  815.  yyBlockList = (yytBlockPtr) Alloc (sizeof (yytBlock));
  816.  yyBlockList->yySuccessor = yyBlockPtr;
  817.  Tree_PoolFreePtr = yyBlockList->yyBlock;
  818.  Tree_PoolMaxPtr = Tree_PoolFreePtr + yyBlockSize - yyMaxSize + 1;
  819.  Tree_HeapUsed += yyBlockSize;
  820.  return (tTree) Tree_PoolFreePtr;
  821. }
  822.  
  823. tTree MakeTree
  824. # if defined __STDC__ | defined __cplusplus
  825.  (Tree_tKind yyKind)
  826. # else
  827.  (yyKind) Tree_tKind yyKind;
  828. # endif
  829. {
  830.  register tTree yyt;
  831.  yyALLOC (yyt, Tree_NodeSize [yyKind])
  832.  yyt->Kind = yyKind;
  833.  yyt->yyHead.yyMark = 0;
  834.  yyt->yyHead.yyParent = NoTree;
  835.  return yyt;
  836. }
  837.  
  838. bool Tree_IsType
  839. # if defined __STDC__ | defined __cplusplus
  840.  (register tTree yyt, register Tree_tKind yyKind)
  841. # else
  842.  (yyt, yyKind) register tTree yyt; register Tree_tKind yyKind;
  843. # endif
  844. {
  845.  return yyt != NoTree && yyKind <= yyt->Kind && yyt->Kind <= yyTypeRange [yyKind];
  846. }
  847.  
  848.  
  849. tTree mCOMP_UNIT
  850. # if defined __STDC__ | defined __cplusplus
  851. (tTree pCOMP_ELEMENTS)
  852. # else
  853. (pCOMP_ELEMENTS)
  854. tTree pCOMP_ELEMENTS;
  855. # endif
  856. {
  857.  register tTree yyt;
  858.  yyALLOC (yyt, Tree_NodeSize [kCOMP_UNIT])
  859.  yyt->Kind = kCOMP_UNIT;
  860.  yyt->yyHead.yyMark = 0;
  861.  yyt->yyHead.yyParent = NoTree;
  862.  yyt->COMP_UNIT.COMP_ELEMENTS = pCOMP_ELEMENTS;
  863.  return yyt;
  864. }
  865.  
  866. tTree mBODY_NODE
  867. # if defined __STDC__ | defined __cplusplus
  868. (tTree pDECLS, tTree pSTATS, tTree pINTERNALS)
  869. # else
  870. (pDECLS, pSTATS, pINTERNALS)
  871. tTree pDECLS;
  872. tTree pSTATS;
  873. tTree pINTERNALS;
  874. # endif
  875. {
  876.  register tTree yyt;
  877.  yyALLOC (yyt, Tree_NodeSize [kBODY_NODE])
  878.  yyt->Kind = kBODY_NODE;
  879.  yyt->yyHead.yyMark = 0;
  880.  yyt->yyHead.yyParent = NoTree;
  881.  yyt->BODY_NODE.DECLS = pDECLS;
  882.  yyt->BODY_NODE.STATS = pSTATS;
  883.  yyt->BODY_NODE.INTERNALS = pINTERNALS;
  884.  return yyt;
  885. }
  886.  
  887. tTree mTYPE_NODE
  888. # if defined __STDC__ | defined __cplusplus
  889. ()
  890. # else
  891. ()
  892. # endif
  893. {
  894.  register tTree yyt;
  895.  yyALLOC (yyt, Tree_NodeSize [kTYPE_NODE])
  896.  yyt->Kind = kTYPE_NODE;
  897.  yyt->yyHead.yyMark = 0;
  898.  yyt->yyHead.yyParent = NoTree;
  899.  return yyt;
  900. }
  901.  
  902. tTree mDUMMY_TYPE
  903. # if defined __STDC__ | defined __cplusplus
  904. ()
  905. # else
  906. ()
  907. # endif
  908. {
  909.  register tTree yyt;
  910.  yyALLOC (yyt, Tree_NodeSize [kDUMMY_TYPE])
  911.  yyt->Kind = kDUMMY_TYPE;
  912.  yyt->yyHead.yyMark = 0;
  913.  yyt->yyHead.yyParent = NoTree;
  914.  return yyt;
  915. }
  916.  
  917. tTree mVOID_TYPE
  918. # if defined __STDC__ | defined __cplusplus
  919. ()
  920. # else
  921. ()
  922. # endif
  923. {
  924.  register tTree yyt;
  925.  yyALLOC (yyt, Tree_NodeSize [kVOID_TYPE])
  926.  yyt->Kind = kVOID_TYPE;
  927.  yyt->yyHead.yyMark = 0;
  928.  yyt->yyHead.yyParent = NoTree;
  929.  return yyt;
  930. }
  931.  
  932. tTree mINTEGER_TYPE
  933. # if defined __STDC__ | defined __cplusplus
  934. (int psize)
  935. # else
  936. (psize)
  937. int psize;
  938. # endif
  939. {
  940.  register tTree yyt;
  941.  yyALLOC (yyt, Tree_NodeSize [kINTEGER_TYPE])
  942.  yyt->Kind = kINTEGER_TYPE;
  943.  yyt->yyHead.yyMark = 0;
  944.  yyt->yyHead.yyParent = NoTree;
  945.  yyt->INTEGER_TYPE.size = psize;
  946.  return yyt;
  947. }
  948.  
  949. tTree mCARDINAL_TYPE
  950. # if defined __STDC__ | defined __cplusplus
  951. (int psize)
  952. # else
  953. (psize)
  954. int psize;
  955. # endif
  956. {
  957.  register tTree yyt;
  958.  yyALLOC (yyt, Tree_NodeSize [kCARDINAL_TYPE])
  959.  yyt->Kind = kCARDINAL_TYPE;
  960.  yyt->yyHead.yyMark = 0;
  961.  yyt->yyHead.yyParent = NoTree;
  962.  yyt->CARDINAL_TYPE.size = psize;
  963.  return yyt;
  964. }
  965.  
  966. tTree mREAL_TYPE
  967. # if defined __STDC__ | defined __cplusplus
  968. (int psize)
  969. # else
  970. (psize)
  971. int psize;
  972. # endif
  973. {
  974.  register tTree yyt;
  975.  yyALLOC (yyt, Tree_NodeSize [kREAL_TYPE])
  976.  yyt->Kind = kREAL_TYPE;
  977.  yyt->yyHead.yyMark = 0;
  978.  yyt->yyHead.yyParent = NoTree;
  979.  yyt->REAL_TYPE.size = psize;
  980.  return yyt;
  981. }
  982.  
  983. tTree mBOOLEAN_TYPE
  984. # if defined __STDC__ | defined __cplusplus
  985. (int psize)
  986. # else
  987. (psize)
  988. int psize;
  989. # endif
  990. {
  991.  register tTree yyt;
  992.  yyALLOC (yyt, Tree_NodeSize [kBOOLEAN_TYPE])
  993.  yyt->Kind = kBOOLEAN_TYPE;
  994.  yyt->yyHead.yyMark = 0;
  995.  yyt->yyHead.yyParent = NoTree;
  996.  yyt->BOOLEAN_TYPE.size = psize;
  997.  return yyt;
  998. }
  999.  
  1000. tTree mCOMPLEX_TYPE
  1001. # if defined __STDC__ | defined __cplusplus
  1002. (int psize)
  1003. # else
  1004. (psize)
  1005. int psize;
  1006. # endif
  1007. {
  1008.  register tTree yyt;
  1009.  yyALLOC (yyt, Tree_NodeSize [kCOMPLEX_TYPE])
  1010.  yyt->Kind = kCOMPLEX_TYPE;
  1011.  yyt->yyHead.yyMark = 0;
  1012.  yyt->yyHead.yyParent = NoTree;
  1013.  yyt->COMPLEX_TYPE.size = psize;
  1014.  return yyt;
  1015. }
  1016.  
  1017. tTree mCHAR_TYPE
  1018. # if defined __STDC__ | defined __cplusplus
  1019. ()
  1020. # else
  1021. ()
  1022. # endif
  1023. {
  1024.  register tTree yyt;
  1025.  yyALLOC (yyt, Tree_NodeSize [kCHAR_TYPE])
  1026.  yyt->Kind = kCHAR_TYPE;
  1027.  yyt->yyHead.yyMark = 0;
  1028.  yyt->yyHead.yyParent = NoTree;
  1029.  return yyt;
  1030. }
  1031.  
  1032. tTree mSTRING_TYPE
  1033. # if defined __STDC__ | defined __cplusplus
  1034. (tTree pLENGTH)
  1035. # else
  1036. (pLENGTH)
  1037. tTree pLENGTH;
  1038. # endif
  1039. {
  1040.  register tTree yyt;
  1041.  yyALLOC (yyt, Tree_NodeSize [kSTRING_TYPE])
  1042.  yyt->Kind = kSTRING_TYPE;
  1043.  yyt->yyHead.yyMark = 0;
  1044.  yyt->yyHead.yyParent = NoTree;
  1045.  yyt->STRING_TYPE.LENGTH = pLENGTH;
  1046.  return yyt;
  1047. }
  1048.  
  1049. tTree mINDEX_TYPE
  1050. # if defined __STDC__ | defined __cplusplus
  1051. (tTree pLOWER, tTree pUPPER)
  1052. # else
  1053. (pLOWER, pUPPER)
  1054. tTree pLOWER;
  1055. tTree pUPPER;
  1056. # endif
  1057. {
  1058.  register tTree yyt;
  1059.  yyALLOC (yyt, Tree_NodeSize [kINDEX_TYPE])
  1060.  yyt->Kind = kINDEX_TYPE;
  1061.  yyt->yyHead.yyMark = 0;
  1062.  yyt->yyHead.yyParent = NoTree;
  1063.  yyt->INDEX_TYPE.LOWER = pLOWER;
  1064.  yyt->INDEX_TYPE.UPPER = pUPPER;
  1065.  beginint(yyt->INDEX_TYPE.left_overlap)
  1066.  beginint(yyt->INDEX_TYPE.right_overlap)
  1067.  return yyt;
  1068. }
  1069.  
  1070. tTree mTYPE_ID
  1071. # if defined __STDC__ | defined __cplusplus
  1072. (tTree pID)
  1073. # else
  1074. (pID)
  1075. tTree pID;
  1076. # endif
  1077. {
  1078.  register tTree yyt;
  1079.  yyALLOC (yyt, Tree_NodeSize [kTYPE_ID])
  1080.  yyt->Kind = kTYPE_ID;
  1081.  yyt->yyHead.yyMark = 0;
  1082.  yyt->yyHead.yyParent = NoTree;
  1083.  yyt->TYPE_ID.ID = pID;
  1084.  return yyt;
  1085. }
  1086.  
  1087. tTree mARRAY_TYPE
  1088. # if defined __STDC__ | defined __cplusplus
  1089. (tTree pARRAY_INDEX_TYPES, tTree pARRAY_COMP_TYPE)
  1090. # else
  1091. (pARRAY_INDEX_TYPES, pARRAY_COMP_TYPE)
  1092. tTree pARRAY_INDEX_TYPES;
  1093. tTree pARRAY_COMP_TYPE;
  1094. # endif
  1095. {
  1096.  register tTree yyt;
  1097.  yyALLOC (yyt, Tree_NodeSize [kARRAY_TYPE])
  1098.  yyt->Kind = kARRAY_TYPE;
  1099.  yyt->yyHead.yyMark = 0;
  1100.  yyt->yyHead.yyParent = NoTree;
  1101.  yyt->ARRAY_TYPE.ARRAY_INDEX_TYPES = pARRAY_INDEX_TYPES;
  1102.  yyt->ARRAY_TYPE.ARRAY_COMP_TYPE = pARRAY_COMP_TYPE;
  1103.  return yyt;
  1104. }
  1105.  
  1106. tTree mRECORD_TYPE
  1107. # if defined __STDC__ | defined __cplusplus
  1108. (tIdent pName, tTree pCOMPONENTS)
  1109. # else
  1110. (pName, pCOMPONENTS)
  1111. tIdent pName;
  1112. tTree pCOMPONENTS;
  1113. # endif
  1114. {
  1115.  register tTree yyt;
  1116.  yyALLOC (yyt, Tree_NodeSize [kRECORD_TYPE])
  1117.  yyt->Kind = kRECORD_TYPE;
  1118.  yyt->yyHead.yyMark = 0;
  1119.  yyt->yyHead.yyParent = NoTree;
  1120.  yyt->RECORD_TYPE.Name = pName;
  1121.  yyt->RECORD_TYPE.COMPONENTS = pCOMPONENTS;
  1122.  return yyt;
  1123. }
  1124.  
  1125. tTree mUNION_TYPE
  1126. # if defined __STDC__ | defined __cplusplus
  1127. (tIdent pName, tTree pCOMPONENTS)
  1128. # else
  1129. (pName, pCOMPONENTS)
  1130. tIdent pName;
  1131. tTree pCOMPONENTS;
  1132. # endif
  1133. {
  1134.  register tTree yyt;
  1135.  yyALLOC (yyt, Tree_NodeSize [kUNION_TYPE])
  1136.  yyt->Kind = kUNION_TYPE;
  1137.  yyt->yyHead.yyMark = 0;
  1138.  yyt->yyHead.yyParent = NoTree;
  1139.  yyt->UNION_TYPE.Name = pName;
  1140.  yyt->UNION_TYPE.COMPONENTS = pCOMPONENTS;
  1141.  return yyt;
  1142. }
  1143.  
  1144. tTree mENUM_TYPE
  1145. # if defined __STDC__ | defined __cplusplus
  1146. (tIdent pName, tTree pCOMPONENTS)
  1147. # else
  1148. (pName, pCOMPONENTS)
  1149. tIdent pName;
  1150. tTree pCOMPONENTS;
  1151. # endif
  1152. {
  1153.  register tTree yyt;
  1154.  yyALLOC (yyt, Tree_NodeSize [kENUM_TYPE])
  1155.  yyt->Kind = kENUM_TYPE;
  1156.  yyt->yyHead.yyMark = 0;
  1157.  yyt->yyHead.yyParent = NoTree;
  1158.  yyt->ENUM_TYPE.Name = pName;
  1159.  yyt->ENUM_TYPE.COMPONENTS = pCOMPONENTS;
  1160.  return yyt;
  1161. }
  1162.  
  1163. tTree mDYNAMIC
  1164. # if defined __STDC__ | defined __cplusplus
  1165. ()
  1166. # else
  1167. ()
  1168. # endif
  1169. {
  1170.  register tTree yyt;
  1171.  yyALLOC (yyt, Tree_NodeSize [kDYNAMIC])
  1172.  yyt->Kind = kDYNAMIC;
  1173.  yyt->yyHead.yyMark = 0;
  1174.  yyt->yyHead.yyParent = NoTree;
  1175.  begintTree(yyt->DYNAMIC.Shape)
  1176.  beginint(yyt->DYNAMIC.left_overlap)
  1177.  beginint(yyt->DYNAMIC.right_overlap)
  1178.  return yyt;
  1179. }
  1180.  
  1181. tTree mPOINTER_TYPE
  1182. # if defined __STDC__ | defined __cplusplus
  1183. (tTree pPTR_COMP)
  1184. # else
  1185. (pPTR_COMP)
  1186. tTree pPTR_COMP;
  1187. # endif
  1188. {
  1189.  register tTree yyt;
  1190.  yyALLOC (yyt, Tree_NodeSize [kPOINTER_TYPE])
  1191.  yyt->Kind = kPOINTER_TYPE;
  1192.  yyt->yyHead.yyMark = 0;
  1193.  yyt->yyHead.yyParent = NoTree;
  1194.  yyt->POINTER_TYPE.PTR_COMP = pPTR_COMP;
  1195.  return yyt;
  1196. }
  1197.  
  1198. tTree mARRAY1_TYPE
  1199. # if defined __STDC__ | defined __cplusplus
  1200. (tTree pSIZE, tTree pARRAY1_COMP_TYPE)
  1201. # else
  1202. (pSIZE, pARRAY1_COMP_TYPE)
  1203. tTree pSIZE;
  1204. tTree pARRAY1_COMP_TYPE;
  1205. # endif
  1206. {
  1207.  register tTree yyt;
  1208.  yyALLOC (yyt, Tree_NodeSize [kARRAY1_TYPE])
  1209.  yyt->Kind = kARRAY1_TYPE;
  1210.  yyt->yyHead.yyMark = 0;
  1211.  yyt->yyHead.yyParent = NoTree;
  1212.  yyt->ARRAY1_TYPE.SIZE = pSIZE;
  1213.  yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE = pARRAY1_COMP_TYPE;
  1214.  return yyt;
  1215. }
  1216.  
  1217. tTree mFUNCTION_TYPE
  1218. # if defined __STDC__ | defined __cplusplus
  1219. (tTree pFORMALS, tTree pRESULT_TYPE)
  1220. # else
  1221. (pFORMALS, pRESULT_TYPE)
  1222. tTree pFORMALS;
  1223. tTree pRESULT_TYPE;
  1224. # endif
  1225. {
  1226.  register tTree yyt;
  1227.  yyALLOC (yyt, Tree_NodeSize [kFUNCTION_TYPE])
  1228.  yyt->Kind = kFUNCTION_TYPE;
  1229.  yyt->yyHead.yyMark = 0;
  1230.  yyt->yyHead.yyParent = NoTree;
  1231.  yyt->FUNCTION_TYPE.FORMALS = pFORMALS;
  1232.  yyt->FUNCTION_TYPE.RESULT_TYPE = pRESULT_TYPE;
  1233.  return yyt;
  1234. }
  1235.  
  1236. tTree mTYPE_NODE_LIST
  1237. # if defined __STDC__ | defined __cplusplus
  1238. ()
  1239. # else
  1240. ()
  1241. # endif
  1242. {
  1243.  register tTree yyt;
  1244.  yyALLOC (yyt, Tree_NodeSize [kTYPE_NODE_LIST])
  1245.  yyt->Kind = kTYPE_NODE_LIST;
  1246.  yyt->yyHead.yyMark = 0;
  1247.  yyt->yyHead.yyParent = NoTree;
  1248.  return yyt;
  1249. }
  1250.  
  1251. tTree mTYPE_EMPTY
  1252. # if defined __STDC__ | defined __cplusplus
  1253. ()
  1254. # else
  1255. ()
  1256. # endif
  1257. {
  1258.  register tTree yyt;
  1259.  yyALLOC (yyt, Tree_NodeSize [kTYPE_EMPTY])
  1260.  yyt->Kind = kTYPE_EMPTY;
  1261.  yyt->yyHead.yyMark = 0;
  1262.  yyt->yyHead.yyParent = NoTree;
  1263.  return yyt;
  1264. }
  1265.  
  1266. tTree mTYPE_LIST
  1267. # if defined __STDC__ | defined __cplusplus
  1268. (tTree pElem, tTree pNext)
  1269. # else
  1270. (pElem, pNext)
  1271. tTree pElem;
  1272. tTree pNext;
  1273. # endif
  1274. {
  1275.  register tTree yyt;
  1276.  yyALLOC (yyt, Tree_NodeSize [kTYPE_LIST])
  1277.  yyt->Kind = kTYPE_LIST;
  1278.  yyt->yyHead.yyMark = 0;
  1279.  yyt->yyHead.yyParent = NoTree;
  1280.  yyt->TYPE_LIST.Elem = pElem;
  1281.  yyt->TYPE_LIST.Next = pNext;
  1282.  return yyt;
  1283. }
  1284.  
  1285. tTree mDECL_NODE
  1286. # if defined __STDC__ | defined __cplusplus
  1287. (tIdent pName, int pPos)
  1288. # else
  1289. (pName, pPos)
  1290. tIdent pName;
  1291. int pPos;
  1292. # endif
  1293. {
  1294.  register tTree yyt;
  1295.  yyALLOC (yyt, Tree_NodeSize [kDECL_NODE])
  1296.  yyt->Kind = kDECL_NODE;
  1297.  yyt->yyHead.yyMark = 0;
  1298.  yyt->yyHead.yyParent = NoTree;
  1299.  yyt->DECL_NODE.Name = pName;
  1300.  yyt->DECL_NODE.Pos = pPos;
  1301.  return yyt;
  1302. }
  1303.  
  1304. tTree mMODULE_DECL
  1305. # if defined __STDC__ | defined __cplusplus
  1306. (tIdent pName, int pPos, tTree pMODULE_BODY)
  1307. # else
  1308. (pName, pPos, pMODULE_BODY)
  1309. tIdent pName;
  1310. int pPos;
  1311. tTree pMODULE_BODY;
  1312. # endif
  1313. {
  1314.  register tTree yyt;
  1315.  yyALLOC (yyt, Tree_NodeSize [kMODULE_DECL])
  1316.  yyt->Kind = kMODULE_DECL;
  1317.  yyt->yyHead.yyMark = 0;
  1318.  yyt->yyHead.yyParent = NoTree;
  1319.  yyt->MODULE_DECL.Name = pName;
  1320.  yyt->MODULE_DECL.Pos = pPos;
  1321.  yyt->MODULE_DECL.MODULE_BODY = pMODULE_BODY;
  1322.  return yyt;
  1323. }
  1324.  
  1325. tTree mPROGRAM_DECL
  1326. # if defined __STDC__ | defined __cplusplus
  1327. (tIdent pName, int pPos, tTree pFORMALS, tTree pPROGRAM_BODY)
  1328. # else
  1329. (pName, pPos, pFORMALS, pPROGRAM_BODY)
  1330. tIdent pName;
  1331. int pPos;
  1332. tTree pFORMALS;
  1333. tTree pPROGRAM_BODY;
  1334. # endif
  1335. {
  1336.  register tTree yyt;
  1337.  yyALLOC (yyt, Tree_NodeSize [kPROGRAM_DECL])
  1338.  yyt->Kind = kPROGRAM_DECL;
  1339.  yyt->yyHead.yyMark = 0;
  1340.  yyt->yyHead.yyParent = NoTree;
  1341.  yyt->PROGRAM_DECL.Name = pName;
  1342.  yyt->PROGRAM_DECL.Pos = pPos;
  1343.  yyt->PROGRAM_DECL.FORMALS = pFORMALS;
  1344.  yyt->PROGRAM_DECL.PROGRAM_BODY = pPROGRAM_BODY;
  1345.  return yyt;
  1346. }
  1347.  
  1348. tTree mPROC_DECL
  1349. # if defined __STDC__ | defined __cplusplus
  1350. (tIdent pName, int pPos, tTree pFORMALS, tTree pPROC_BODY)
  1351. # else
  1352. (pName, pPos, pFORMALS, pPROC_BODY)
  1353. tIdent pName;
  1354. int pPos;
  1355. tTree pFORMALS;
  1356. tTree pPROC_BODY;
  1357. # endif
  1358. {
  1359.  register tTree yyt;
  1360.  yyALLOC (yyt, Tree_NodeSize [kPROC_DECL])
  1361.  yyt->Kind = kPROC_DECL;
  1362.  yyt->yyHead.yyMark = 0;
  1363.  yyt->yyHead.yyParent = NoTree;
  1364.  yyt->PROC_DECL.Name = pName;
  1365.  yyt->PROC_DECL.Pos = pPos;
  1366.  yyt->PROC_DECL.FORMALS = pFORMALS;
  1367.  yyt->PROC_DECL.PROC_BODY = pPROC_BODY;
  1368.  beginbool(yyt->PROC_DECL.IsRecursive)
  1369.  beginbool(yyt->PROC_DECL.IsPure)
  1370.  beginint(yyt->PROC_DECL.HPFExtrinsic)
  1371.  return yyt;
  1372. }
  1373.  
  1374. tTree mFUNC_DECL
  1375. # if defined __STDC__ | defined __cplusplus
  1376. (tIdent pName, int pPos, tTree pFORMALS, tTree pFUNC_BODY, tTree pRESULT_TYPE, tIdent pRESULT_ID)
  1377. # else
  1378. (pName, pPos, pFORMALS, pFUNC_BODY, pRESULT_TYPE, pRESULT_ID)
  1379. tIdent pName;
  1380. int pPos;
  1381. tTree pFORMALS;
  1382. tTree pFUNC_BODY;
  1383. tTree pRESULT_TYPE;
  1384. tIdent pRESULT_ID;
  1385. # endif
  1386. {
  1387.  register tTree yyt;
  1388.  yyALLOC (yyt, Tree_NodeSize [kFUNC_DECL])
  1389.  yyt->Kind = kFUNC_DECL;
  1390.  yyt->yyHead.yyMark = 0;
  1391.  yyt->yyHead.yyParent = NoTree;
  1392.  yyt->FUNC_DECL.Name = pName;
  1393.  yyt->FUNC_DECL.Pos = pPos;
  1394.  yyt->FUNC_DECL.FORMALS = pFORMALS;
  1395.  yyt->FUNC_DECL.FUNC_BODY = pFUNC_BODY;
  1396.  yyt->FUNC_DECL.RESULT_TYPE = pRESULT_TYPE;
  1397.  yyt->FUNC_DECL.RESULT_ID = pRESULT_ID;
  1398.  beginbool(yyt->FUNC_DECL.IsRecursive)
  1399.  beginbool(yyt->FUNC_DECL.IsPure)
  1400.  beginint(yyt->FUNC_DECL.HPFExtrinsic)
  1401.  return yyt;
  1402. }
  1403.  
  1404. tTree mBLOCK_DATA_DECL
  1405. # if defined __STDC__ | defined __cplusplus
  1406. (tIdent pName, int pPos, tTree pDATA_BODY)
  1407. # else
  1408. (pName, pPos, pDATA_BODY)
  1409. tIdent pName;
  1410. int pPos;
  1411. tTree pDATA_BODY;
  1412. # endif
  1413. {
  1414.  register tTree yyt;
  1415.  yyALLOC (yyt, Tree_NodeSize [kBLOCK_DATA_DECL])
  1416.  yyt->Kind = kBLOCK_DATA_DECL;
  1417.  yyt->yyHead.yyMark = 0;
  1418.  yyt->yyHead.yyParent = NoTree;
  1419.  yyt->BLOCK_DATA_DECL.Name = pName;
  1420.  yyt->BLOCK_DATA_DECL.Pos = pPos;
  1421.  yyt->BLOCK_DATA_DECL.DATA_BODY = pDATA_BODY;
  1422.  return yyt;
  1423. }
  1424.  
  1425. tTree mTYPE_DECL
  1426. # if defined __STDC__ | defined __cplusplus
  1427. (tIdent pName, int pPos, tTree pVAL)
  1428. # else
  1429. (pName, pPos, pVAL)
  1430. tIdent pName;
  1431. int pPos;
  1432. tTree pVAL;
  1433. # endif
  1434. {
  1435.  register tTree yyt;
  1436.  yyALLOC (yyt, Tree_NodeSize [kTYPE_DECL])
  1437.  yyt->Kind = kTYPE_DECL;
  1438.  yyt->yyHead.yyMark = 0;
  1439.  yyt->yyHead.yyParent = NoTree;
  1440.  yyt->TYPE_DECL.Name = pName;
  1441.  yyt->TYPE_DECL.Pos = pPos;
  1442.  yyt->TYPE_DECL.VAL = pVAL;
  1443.  return yyt;
  1444. }
  1445.  
  1446. tTree mNAME_DECL
  1447. # if defined __STDC__ | defined __cplusplus
  1448. (tIdent pName, int pPos)
  1449. # else
  1450. (pName, pPos)
  1451. tIdent pName;
  1452. int pPos;
  1453. # endif
  1454. {
  1455.  register tTree yyt;
  1456.  yyALLOC (yyt, Tree_NodeSize [kNAME_DECL])
  1457.  yyt->Kind = kNAME_DECL;
  1458.  yyt->yyHead.yyMark = 0;
  1459.  yyt->yyHead.yyParent = NoTree;
  1460.  yyt->NAME_DECL.Name = pName;
  1461.  yyt->NAME_DECL.Pos = pPos;
  1462.  return yyt;
  1463. }
  1464.  
  1465. tTree mRENAME_DECL
  1466. # if defined __STDC__ | defined __cplusplus
  1467. (tIdent pName, int pPos, tIdent poldname)
  1468. # else
  1469. (pName, pPos, poldname)
  1470. tIdent pName;
  1471. int pPos;
  1472. tIdent poldname;
  1473. # endif
  1474. {
  1475.  register tTree yyt;
  1476.  yyALLOC (yyt, Tree_NodeSize [kRENAME_DECL])
  1477.  yyt->Kind = kRENAME_DECL;
  1478.  yyt->yyHead.yyMark = 0;
  1479.  yyt->yyHead.yyParent = NoTree;
  1480.  yyt->RENAME_DECL.Name = pName;
  1481.  yyt->RENAME_DECL.Pos = pPos;
  1482.  yyt->RENAME_DECL.oldname = poldname;
  1483.  return yyt;
  1484. }
  1485.  
  1486. tTree mENTITY_DECL
  1487. # if defined __STDC__ | defined __cplusplus
  1488. (tIdent pName, int pPos, tTree pATTRIBUTES)
  1489. # else
  1490. (pName, pPos, pATTRIBUTES)
  1491. tIdent pName;
  1492. int pPos;
  1493. tTree pATTRIBUTES;
  1494. # endif
  1495. {
  1496.  register tTree yyt;
  1497.  yyALLOC (yyt, Tree_NodeSize [kENTITY_DECL])
  1498.  yyt->Kind = kENTITY_DECL;
  1499.  yyt->yyHead.yyMark = 0;
  1500.  yyt->yyHead.yyParent = NoTree;
  1501.  yyt->ENTITY_DECL.Name = pName;
  1502.  yyt->ENTITY_DECL.Pos = pPos;
  1503.  yyt->ENTITY_DECL.ATTRIBUTES = pATTRIBUTES;
  1504.  return yyt;
  1505. }
  1506.  
  1507. tTree mVAR_DECL
  1508. # if defined __STDC__ | defined __cplusplus
  1509. (tIdent pName, int pPos, tTree pVAL)
  1510. # else
  1511. (pName, pPos, pVAL)
  1512. tIdent pName;
  1513. int pPos;
  1514. tTree pVAL;
  1515. # endif
  1516. {
  1517.  register tTree yyt;
  1518.  yyALLOC (yyt, Tree_NodeSize [kVAR_DECL])
  1519.  yyt->Kind = kVAR_DECL;
  1520.  yyt->yyHead.yyMark = 0;
  1521.  yyt->yyHead.yyParent = NoTree;
  1522.  yyt->VAR_DECL.Name = pName;
  1523.  yyt->VAR_DECL.Pos = pPos;
  1524.  yyt->VAR_DECL.VAL = pVAL;
  1525.  return yyt;
  1526. }
  1527.  
  1528. tTree mCOMMON_DECL
  1529. # if defined __STDC__ | defined __cplusplus
  1530. (tIdent pName, int pPos, tTree pIDS)
  1531. # else
  1532. (pName, pPos, pIDS)
  1533. tIdent pName;
  1534. int pPos;
  1535. tTree pIDS;
  1536. # endif
  1537. {
  1538.  register tTree yyt;
  1539.  yyALLOC (yyt, Tree_NodeSize [kCOMMON_DECL])
  1540.  yyt->Kind = kCOMMON_DECL;
  1541.  yyt->yyHead.yyMark = 0;
  1542.  yyt->yyHead.yyParent = NoTree;
  1543.  yyt->COMMON_DECL.Name = pName;
  1544.  yyt->COMMON_DECL.Pos = pPos;
  1545.  yyt->COMMON_DECL.IDS = pIDS;
  1546.  return yyt;
  1547. }
  1548.  
  1549. tTree mNAMELIST_DECL
  1550. # if defined __STDC__ | defined __cplusplus
  1551. (tIdent pName, int pPos, tTree pIDS)
  1552. # else
  1553. (pName, pPos, pIDS)
  1554. tIdent pName;
  1555. int pPos;
  1556. tTree pIDS;
  1557. # endif
  1558. {
  1559.  register tTree yyt;
  1560.  yyALLOC (yyt, Tree_NodeSize [kNAMELIST_DECL])
  1561.  yyt->Kind = kNAMELIST_DECL;
  1562.  yyt->yyHead.yyMark = 0;
  1563.  yyt->yyHead.yyParent = NoTree;
  1564.  yyt->NAMELIST_DECL.Name = pName;
  1565.  yyt->NAMELIST_DECL.Pos = pPos;
  1566.  yyt->NAMELIST_DECL.IDS = pIDS;
  1567.  return yyt;
  1568. }
  1569.  
  1570. tTree mTEMPLATE_DECL
  1571. # if defined __STDC__ | defined __cplusplus
  1572. (tIdent pName, int pPos, tTree pDIMENSIONS)
  1573. # else
  1574. (pName, pPos, pDIMENSIONS)
  1575. tIdent pName;
  1576. int pPos;
  1577. tTree pDIMENSIONS;
  1578. # endif
  1579. {
  1580.  register tTree yyt;
  1581.  yyALLOC (yyt, Tree_NodeSize [kTEMPLATE_DECL])
  1582.  yyt->Kind = kTEMPLATE_DECL;
  1583.  yyt->yyHead.yyMark = 0;
  1584.  yyt->yyHead.yyParent = NoTree;
  1585.  yyt->TEMPLATE_DECL.Name = pName;
  1586.  yyt->TEMPLATE_DECL.Pos = pPos;
  1587.  yyt->TEMPLATE_DECL.DIMENSIONS = pDIMENSIONS;
  1588.  return yyt;
  1589. }
  1590.  
  1591. tTree mPROCESSORS_DECL
  1592. # if defined __STDC__ | defined __cplusplus
  1593. (tIdent pName, int pPos, tTree pDIMENSIONS)
  1594. # else
  1595. (pName, pPos, pDIMENSIONS)
  1596. tIdent pName;
  1597. int pPos;
  1598. tTree pDIMENSIONS;
  1599. # endif
  1600. {
  1601.  register tTree yyt;
  1602.  yyALLOC (yyt, Tree_NodeSize [kPROCESSORS_DECL])
  1603.  yyt->Kind = kPROCESSORS_DECL;
  1604.  yyt->yyHead.yyMark = 0;
  1605.  yyt->yyHead.yyParent = NoTree;
  1606.  yyt->PROCESSORS_DECL.Name = pName;
  1607.  yyt->PROCESSORS_DECL.Pos = pPos;
  1608.  yyt->PROCESSORS_DECL.DIMENSIONS = pDIMENSIONS;
  1609.  return yyt;
  1610. }
  1611.  
  1612. tTree mINHERIT_DECL
  1613. # if defined __STDC__ | defined __cplusplus
  1614. (tIdent pName, int pPos)
  1615. # else
  1616. (pName, pPos)
  1617. tIdent pName;
  1618. int pPos;
  1619. # endif
  1620. {
  1621.  register tTree yyt;
  1622.  yyALLOC (yyt, Tree_NodeSize [kINHERIT_DECL])
  1623.  yyt->Kind = kINHERIT_DECL;
  1624.  yyt->yyHead.yyMark = 0;
  1625.  yyt->yyHead.yyParent = NoTree;
  1626.  yyt->INHERIT_DECL.Name = pName;
  1627.  yyt->INHERIT_DECL.Pos = pPos;
  1628.  return yyt;
  1629. }
  1630.  
  1631. tTree mSTMT_FUNC_DECL
  1632. # if defined __STDC__ | defined __cplusplus
  1633. (tIdent pName, int pPos, tTree pFORMALS, tTree pRESULT_TYPE, tTree pFFUNC_BODY)
  1634. # else
  1635. (pName, pPos, pFORMALS, pRESULT_TYPE, pFFUNC_BODY)
  1636. tIdent pName;
  1637. int pPos;
  1638. tTree pFORMALS;
  1639. tTree pRESULT_TYPE;
  1640. tTree pFFUNC_BODY;
  1641. # endif
  1642. {
  1643.  register tTree yyt;
  1644.  yyALLOC (yyt, Tree_NodeSize [kSTMT_FUNC_DECL])
  1645.  yyt->Kind = kSTMT_FUNC_DECL;
  1646.  yyt->yyHead.yyMark = 0;
  1647.  yyt->yyHead.yyParent = NoTree;
  1648.  yyt->STMT_FUNC_DECL.Name = pName;
  1649.  yyt->STMT_FUNC_DECL.Pos = pPos;
  1650.  yyt->STMT_FUNC_DECL.FORMALS = pFORMALS;
  1651.  yyt->STMT_FUNC_DECL.RESULT_TYPE = pRESULT_TYPE;
  1652.  yyt->STMT_FUNC_DECL.FFUNC_BODY = pFFUNC_BODY;
  1653.  return yyt;
  1654. }
  1655.  
  1656. tTree mINTERFACE_DECL
  1657. # if defined __STDC__ | defined __cplusplus
  1658. (tIdent pName, int pPos, tTree pSPEC, tTree pITEMS)
  1659. # else
  1660. (pName, pPos, pSPEC, pITEMS)
  1661. tIdent pName;
  1662. int pPos;
  1663. tTree pSPEC;
  1664. tTree pITEMS;
  1665. # endif
  1666. {
  1667.  register tTree yyt;
  1668.  yyALLOC (yyt, Tree_NodeSize [kINTERFACE_DECL])
  1669.  yyt->Kind = kINTERFACE_DECL;
  1670.  yyt->yyHead.yyMark = 0;
  1671.  yyt->yyHead.yyParent = NoTree;
  1672.  yyt->INTERFACE_DECL.Name = pName;
  1673.  yyt->INTERFACE_DECL.Pos = pPos;
  1674.  yyt->INTERFACE_DECL.SPEC = pSPEC;
  1675.  yyt->INTERFACE_DECL.ITEMS = pITEMS;
  1676.  return yyt;
  1677. }
  1678.  
  1679. tTree mEXT_PROC_DECL
  1680. # if defined __STDC__ | defined __cplusplus
  1681. (tIdent pName, int pPos, tTree pFORMALS)
  1682. # else
  1683. (pName, pPos, pFORMALS)
  1684. tIdent pName;
  1685. int pPos;
  1686. tTree pFORMALS;
  1687. # endif
  1688. {
  1689.  register tTree yyt;
  1690.  yyALLOC (yyt, Tree_NodeSize [kEXT_PROC_DECL])
  1691.  yyt->Kind = kEXT_PROC_DECL;
  1692.  yyt->yyHead.yyMark = 0;
  1693.  yyt->yyHead.yyParent = NoTree;
  1694.  yyt->EXT_PROC_DECL.Name = pName;
  1695.  yyt->EXT_PROC_DECL.Pos = pPos;
  1696.  yyt->EXT_PROC_DECL.FORMALS = pFORMALS;
  1697.  return yyt;
  1698. }
  1699.  
  1700. tTree mEXT_FUNC_DECL
  1701. # if defined __STDC__ | defined __cplusplus
  1702. (tIdent pName, int pPos, tTree pFORMALS, tTree pRESULT_TYPE)
  1703. # else
  1704. (pName, pPos, pFORMALS, pRESULT_TYPE)
  1705. tIdent pName;
  1706. int pPos;
  1707. tTree pFORMALS;
  1708. tTree pRESULT_TYPE;
  1709. # endif
  1710. {
  1711.  register tTree yyt;
  1712.  yyALLOC (yyt, Tree_NodeSize [kEXT_FUNC_DECL])
  1713.  yyt->Kind = kEXT_FUNC_DECL;
  1714.  yyt->yyHead.yyMark = 0;
  1715.  yyt->yyHead.yyParent = NoTree;
  1716.  yyt->EXT_FUNC_DECL.Name = pName;
  1717.  yyt->EXT_FUNC_DECL.Pos = pPos;
  1718.  yyt->EXT_FUNC_DECL.FORMALS = pFORMALS;
  1719.  yyt->EXT_FUNC_DECL.RESULT_TYPE = pRESULT_TYPE;
  1720.  return yyt;
  1721. }
  1722.  
  1723. tTree mVAL_PARAM_DECL
  1724. # if defined __STDC__ | defined __cplusplus
  1725. (tIdent pName, int pPos, tTree pVAL)
  1726. # else
  1727. (pName, pPos, pVAL)
  1728. tIdent pName;
  1729. int pPos;
  1730. tTree pVAL;
  1731. # endif
  1732. {
  1733.  register tTree yyt;
  1734.  yyALLOC (yyt, Tree_NodeSize [kVAL_PARAM_DECL])
  1735.  yyt->Kind = kVAL_PARAM_DECL;
  1736.  yyt->yyHead.yyMark = 0;
  1737.  yyt->yyHead.yyParent = NoTree;
  1738.  yyt->VAL_PARAM_DECL.Name = pName;
  1739.  yyt->VAL_PARAM_DECL.Pos = pPos;
  1740.  yyt->VAL_PARAM_DECL.VAL = pVAL;
  1741.  return yyt;
  1742. }
  1743.  
  1744. tTree mVAR_PARAM_DECL
  1745. # if defined __STDC__ | defined __cplusplus
  1746. (tIdent pName, int pPos, tTree pVAL)
  1747. # else
  1748. (pName, pPos, pVAL)
  1749. tIdent pName;
  1750. int pPos;
  1751. tTree pVAL;
  1752. # endif
  1753. {
  1754.  register tTree yyt;
  1755.  yyALLOC (yyt, Tree_NodeSize [kVAR_PARAM_DECL])
  1756.  yyt->Kind = kVAR_PARAM_DECL;
  1757.  yyt->yyHead.yyMark = 0;
  1758.  yyt->yyHead.yyParent = NoTree;
  1759.  yyt->VAR_PARAM_DECL.Name = pName;
  1760.  yyt->VAR_PARAM_DECL.Pos = pPos;
  1761.  yyt->VAR_PARAM_DECL.VAL = pVAL;
  1762.  return yyt;
  1763. }
  1764.  
  1765. tTree mPROC_PARAM_DECL
  1766. # if defined __STDC__ | defined __cplusplus
  1767. (tIdent pName, int pPos, tTree pFORMAL)
  1768. # else
  1769. (pName, pPos, pFORMAL)
  1770. tIdent pName;
  1771. int pPos;
  1772. tTree pFORMAL;
  1773. # endif
  1774. {
  1775.  register tTree yyt;
  1776.  yyALLOC (yyt, Tree_NodeSize [kPROC_PARAM_DECL])
  1777.  yyt->Kind = kPROC_PARAM_DECL;
  1778.  yyt->yyHead.yyMark = 0;
  1779.  yyt->yyHead.yyParent = NoTree;
  1780.  yyt->PROC_PARAM_DECL.Name = pName;
  1781.  yyt->PROC_PARAM_DECL.Pos = pPos;
  1782.  yyt->PROC_PARAM_DECL.FORMAL = pFORMAL;
  1783.  return yyt;
  1784. }
  1785.  
  1786. tTree mFUNC_PARAM_DECL
  1787. # if defined __STDC__ | defined __cplusplus
  1788. (tIdent pName, int pPos, tTree pFORMAL, tTree pRESULT_TYPE)
  1789. # else
  1790. (pName, pPos, pFORMAL, pRESULT_TYPE)
  1791. tIdent pName;
  1792. int pPos;
  1793. tTree pFORMAL;
  1794. tTree pRESULT_TYPE;
  1795. # endif
  1796. {
  1797.  register tTree yyt;
  1798.  yyALLOC (yyt, Tree_NodeSize [kFUNC_PARAM_DECL])
  1799.  yyt->Kind = kFUNC_PARAM_DECL;
  1800.  yyt->yyHead.yyMark = 0;
  1801.  yyt->yyHead.yyParent = NoTree;
  1802.  yyt->FUNC_PARAM_DECL.Name = pName;
  1803.  yyt->FUNC_PARAM_DECL.Pos = pPos;
  1804.  yyt->FUNC_PARAM_DECL.FORMAL = pFORMAL;
  1805.  yyt->FUNC_PARAM_DECL.RESULT_TYPE = pRESULT_TYPE;
  1806.  return yyt;
  1807. }
  1808.  
  1809. tTree mELIPSIS_PARAM_DECL
  1810. # if defined __STDC__ | defined __cplusplus
  1811. (tIdent pName, int pPos)
  1812. # else
  1813. (pName, pPos)
  1814. tIdent pName;
  1815. int pPos;
  1816. # endif
  1817. {
  1818.  register tTree yyt;
  1819.  yyALLOC (yyt, Tree_NodeSize [kELIPSIS_PARAM_DECL])
  1820.  yyt->Kind = kELIPSIS_PARAM_DECL;
  1821.  yyt->yyHead.yyMark = 0;
  1822.  yyt->yyHead.yyParent = NoTree;
  1823.  yyt->ELIPSIS_PARAM_DECL.Name = pName;
  1824.  yyt->ELIPSIS_PARAM_DECL.Pos = pPos;
  1825.  return yyt;
  1826. }
  1827.  
  1828. tTree mRET_PARAM_DECL
  1829. # if defined __STDC__ | defined __cplusplus
  1830. (tIdent pName, int pPos)
  1831. # else
  1832. (pName, pPos)
  1833. tIdent pName;
  1834. int pPos;
  1835. # endif
  1836. {
  1837.  register tTree yyt;
  1838.  yyALLOC (yyt, Tree_NodeSize [kRET_PARAM_DECL])
  1839.  yyt->Kind = kRET_PARAM_DECL;
  1840.  yyt->yyHead.yyMark = 0;
  1841.  yyt->yyHead.yyParent = NoTree;
  1842.  yyt->RET_PARAM_DECL.Name = pName;
  1843.  yyt->RET_PARAM_DECL.Pos = pPos;
  1844.  return yyt;
  1845. }
  1846.  
  1847. tTree mIMPLICIT_DECL
  1848. # if defined __STDC__ | defined __cplusplus
  1849. (tIdent pName, int pPos, tIdent pfirst, tIdent plast, tTree pVAL)
  1850. # else
  1851. (pName, pPos, pfirst, plast, pVAL)
  1852. tIdent pName;
  1853. int pPos;
  1854. tIdent pfirst;
  1855. tIdent plast;
  1856. tTree pVAL;
  1857. # endif
  1858. {
  1859.  register tTree yyt;
  1860.  yyALLOC (yyt, Tree_NodeSize [kIMPLICIT_DECL])
  1861.  yyt->Kind = kIMPLICIT_DECL;
  1862.  yyt->yyHead.yyMark = 0;
  1863.  yyt->yyHead.yyParent = NoTree;
  1864.  yyt->IMPLICIT_DECL.Name = pName;
  1865.  yyt->IMPLICIT_DECL.Pos = pPos;
  1866.  yyt->IMPLICIT_DECL.first = pfirst;
  1867.  yyt->IMPLICIT_DECL.last = plast;
  1868.  yyt->IMPLICIT_DECL.VAL = pVAL;
  1869.  return yyt;
  1870. }
  1871.  
  1872. tTree mUSE_DECL
  1873. # if defined __STDC__ | defined __cplusplus
  1874. (tIdent pName, int pPos, tIdent puse, tTree pRENAMINGS)
  1875. # else
  1876. (pName, pPos, puse, pRENAMINGS)
  1877. tIdent pName;
  1878. int pPos;
  1879. tIdent puse;
  1880. tTree pRENAMINGS;
  1881. # endif
  1882. {
  1883.  register tTree yyt;
  1884.  yyALLOC (yyt, Tree_NodeSize [kUSE_DECL])
  1885.  yyt->Kind = kUSE_DECL;
  1886.  yyt->yyHead.yyMark = 0;
  1887.  yyt->yyHead.yyParent = NoTree;
  1888.  yyt->USE_DECL.Name = pName;
  1889.  yyt->USE_DECL.Pos = pPos;
  1890.  yyt->USE_DECL.use = puse;
  1891.  yyt->USE_DECL.RENAMINGS = pRENAMINGS;
  1892.  return yyt;
  1893. }
  1894.  
  1895. tTree mONLY_USE_DECL
  1896. # if defined __STDC__ | defined __cplusplus
  1897. (tIdent pName, int pPos, tIdent puse, tTree pNAMES)
  1898. # else
  1899. (pName, pPos, puse, pNAMES)
  1900. tIdent pName;
  1901. int pPos;
  1902. tIdent puse;
  1903. tTree pNAMES;
  1904. # endif
  1905. {
  1906.  register tTree yyt;
  1907.  yyALLOC (yyt, Tree_NodeSize [kONLY_USE_DECL])
  1908.  yyt->Kind = kONLY_USE_DECL;
  1909.  yyt->yyHead.yyMark = 0;
  1910.  yyt->yyHead.yyParent = NoTree;
  1911.  yyt->ONLY_USE_DECL.Name = pName;
  1912.  yyt->ONLY_USE_DECL.Pos = pPos;
  1913.  yyt->ONLY_USE_DECL.use = puse;
  1914.  yyt->ONLY_USE_DECL.NAMES = pNAMES;
  1915.  return yyt;
  1916. }
  1917.  
  1918. tTree mEQV_DECL
  1919. # if defined __STDC__ | defined __cplusplus
  1920. (tIdent pName, int pPos, tTree pVARS)
  1921. # else
  1922. (pName, pPos, pVARS)
  1923. tIdent pName;
  1924. int pPos;
  1925. tTree pVARS;
  1926. # endif
  1927. {
  1928.  register tTree yyt;
  1929.  yyALLOC (yyt, Tree_NodeSize [kEQV_DECL])
  1930.  yyt->Kind = kEQV_DECL;
  1931.  yyt->yyHead.yyMark = 0;
  1932.  yyt->yyHead.yyParent = NoTree;
  1933.  yyt->EQV_DECL.Name = pName;
  1934.  yyt->EQV_DECL.Pos = pPos;
  1935.  yyt->EQV_DECL.VARS = pVARS;
  1936.  return yyt;
  1937. }
  1938.  
  1939. tTree mDATA_DECL
  1940. # if defined __STDC__ | defined __cplusplus
  1941. (tIdent pName, int pPos, tTree pVARS, tTree pVALS)
  1942. # else
  1943. (pName, pPos, pVARS, pVALS)
  1944. tIdent pName;
  1945. int pPos;
  1946. tTree pVARS;
  1947. tTree pVALS;
  1948. # endif
  1949. {
  1950.  register tTree yyt;
  1951.  yyALLOC (yyt, Tree_NodeSize [kDATA_DECL])
  1952.  yyt->Kind = kDATA_DECL;
  1953.  yyt->yyHead.yyMark = 0;
  1954.  yyt->yyHead.yyParent = NoTree;
  1955.  yyt->DATA_DECL.Name = pName;
  1956.  yyt->DATA_DECL.Pos = pPos;
  1957.  yyt->DATA_DECL.VARS = pVARS;
  1958.  yyt->DATA_DECL.VALS = pVALS;
  1959.  return yyt;
  1960. }
  1961.  
  1962. tTree mDIMENSION_DECL
  1963. # if defined __STDC__ | defined __cplusplus
  1964. (tIdent pName, int pPos, tTree pINDEXES)
  1965. # else
  1966. (pName, pPos, pINDEXES)
  1967. tIdent pName;
  1968. int pPos;
  1969. tTree pINDEXES;
  1970. # endif
  1971. {
  1972.  register tTree yyt;
  1973.  yyALLOC (yyt, Tree_NodeSize [kDIMENSION_DECL])
  1974.  yyt->Kind = kDIMENSION_DECL;
  1975.  yyt->yyHead.yyMark = 0;
  1976.  yyt->yyHead.yyParent = NoTree;
  1977.  yyt->DIMENSION_DECL.Name = pName;
  1978.  yyt->DIMENSION_DECL.Pos = pPos;
  1979.  yyt->DIMENSION_DECL.INDEXES = pINDEXES;
  1980.  return yyt;
  1981. }
  1982.  
  1983. tTree mINIT_DATA_DECL
  1984. # if defined __STDC__ | defined __cplusplus
  1985. (tIdent pName, int pPos, tTree pVAL)
  1986. # else
  1987. (pName, pPos, pVAL)
  1988. tIdent pName;
  1989. int pPos;
  1990. tTree pVAL;
  1991. # endif
  1992. {
  1993.  register tTree yyt;
  1994.  yyALLOC (yyt, Tree_NodeSize [kINIT_DATA_DECL])
  1995.  yyt->Kind = kINIT_DATA_DECL;
  1996.  yyt->yyHead.yyMark = 0;
  1997.  yyt->yyHead.yyParent = NoTree;
  1998.  yyt->INIT_DATA_DECL.Name = pName;
  1999.  yyt->INIT_DATA_DECL.Pos = pPos;
  2000.  yyt->INIT_DATA_DECL.VAL = pVAL;
  2001.  return yyt;
  2002. }
  2003.  
  2004. tTree mTYPESPEC_DECL
  2005. # if defined __STDC__ | defined __cplusplus
  2006. (tIdent pName, int pPos, tTree pVAL)
  2007. # else
  2008. (pName, pPos, pVAL)
  2009. tIdent pName;
  2010. int pPos;
  2011. tTree pVAL;
  2012. # endif
  2013. {
  2014.  register tTree yyt;
  2015.  yyALLOC (yyt, Tree_NodeSize [kTYPESPEC_DECL])
  2016.  yyt->Kind = kTYPESPEC_DECL;
  2017.  yyt->yyHead.yyMark = 0;
  2018.  yyt->yyHead.yyParent = NoTree;
  2019.  yyt->TYPESPEC_DECL.Name = pName;
  2020.  yyt->TYPESPEC_DECL.Pos = pPos;
  2021.  yyt->TYPESPEC_DECL.VAL = pVAL;
  2022.  return yyt;
  2023. }
  2024.  
  2025. tTree mALLOCATABLE_DECL
  2026. # if defined __STDC__ | defined __cplusplus
  2027. (tIdent pName, int pPos)
  2028. # else
  2029. (pName, pPos)
  2030. tIdent pName;
  2031. int pPos;
  2032. # endif
  2033. {
  2034.  register tTree yyt;
  2035.  yyALLOC (yyt, Tree_NodeSize [kALLOCATABLE_DECL])
  2036.  yyt->Kind = kALLOCATABLE_DECL;
  2037.  yyt->yyHead.yyMark = 0;
  2038.  yyt->yyHead.yyParent = NoTree;
  2039.  yyt->ALLOCATABLE_DECL.Name = pName;
  2040.  yyt->ALLOCATABLE_DECL.Pos = pPos;
  2041.  return yyt;
  2042. }
  2043.  
  2044. tTree mEXTERNAL_DECL
  2045. # if defined __STDC__ | defined __cplusplus
  2046. (tIdent pName, int pPos)
  2047. # else
  2048. (pName, pPos)
  2049. tIdent pName;
  2050. int pPos;
  2051. # endif
  2052. {
  2053.  register tTree yyt;
  2054.  yyALLOC (yyt, Tree_NodeSize [kEXTERNAL_DECL])
  2055.  yyt->Kind = kEXTERNAL_DECL;
  2056.  yyt->yyHead.yyMark = 0;
  2057.  yyt->yyHead.yyParent = NoTree;
  2058.  yyt->EXTERNAL_DECL.Name = pName;
  2059.  yyt->EXTERNAL_DECL.Pos = pPos;
  2060.  return yyt;
  2061. }
  2062.  
  2063. tTree mINTENT_DECL
  2064. # if defined __STDC__ | defined __cplusplus
  2065. (tIdent pName, int pPos, int pintent)
  2066. # else
  2067. (pName, pPos, pintent)
  2068. tIdent pName;
  2069. int pPos;
  2070. int pintent;
  2071. # endif
  2072. {
  2073.  register tTree yyt;
  2074.  yyALLOC (yyt, Tree_NodeSize [kINTENT_DECL])
  2075.  yyt->Kind = kINTENT_DECL;
  2076.  yyt->yyHead.yyMark = 0;
  2077.  yyt->yyHead.yyParent = NoTree;
  2078.  yyt->INTENT_DECL.Name = pName;
  2079.  yyt->INTENT_DECL.Pos = pPos;
  2080.  yyt->INTENT_DECL.intent = pintent;
  2081.  return yyt;
  2082. }
  2083.  
  2084. tTree mINTRINSIC_DECL
  2085. # if defined __STDC__ | defined __cplusplus
  2086. (tIdent pName, int pPos)
  2087. # else
  2088. (pName, pPos)
  2089. tIdent pName;
  2090. int pPos;
  2091. # endif
  2092. {
  2093.  register tTree yyt;
  2094.  yyALLOC (yyt, Tree_NodeSize [kINTRINSIC_DECL])
  2095.  yyt->Kind = kINTRINSIC_DECL;
  2096.  yyt->yyHead.yyMark = 0;
  2097.  yyt->yyHead.yyParent = NoTree;
  2098.  yyt->INTRINSIC_DECL.Name = pName;
  2099.  yyt->INTRINSIC_DECL.Pos = pPos;
  2100.  return yyt;
  2101. }
  2102.  
  2103. tTree mOPTIONAL_DECL
  2104. # if defined __STDC__ | defined __cplusplus
  2105. (tIdent pName, int pPos)
  2106. # else
  2107. (pName, pPos)
  2108. tIdent pName;
  2109. int pPos;
  2110. # endif
  2111. {
  2112.  register tTree yyt;
  2113.  yyALLOC (yyt, Tree_NodeSize [kOPTIONAL_DECL])
  2114.  yyt->Kind = kOPTIONAL_DECL;
  2115.  yyt->yyHead.yyMark = 0;
  2116.  yyt->yyHead.yyParent = NoTree;
  2117.  yyt->OPTIONAL_DECL.Name = pName;
  2118.  yyt->OPTIONAL_DECL.Pos = pPos;
  2119.  return yyt;
  2120. }
  2121.  
  2122. tTree mPOINTER_DECL
  2123. # if defined __STDC__ | defined __cplusplus
  2124. (tIdent pName, int pPos)
  2125. # else
  2126. (pName, pPos)
  2127. tIdent pName;
  2128. int pPos;
  2129. # endif
  2130. {
  2131.  register tTree yyt;
  2132.  yyALLOC (yyt, Tree_NodeSize [kPOINTER_DECL])
  2133.  yyt->Kind = kPOINTER_DECL;
  2134.  yyt->yyHead.yyMark = 0;
  2135.  yyt->yyHead.yyParent = NoTree;
  2136.  yyt->POINTER_DECL.Name = pName;
  2137.  yyt->POINTER_DECL.Pos = pPos;
  2138.  return yyt;
  2139. }
  2140.  
  2141. tTree mSAVE_DECL
  2142. # if defined __STDC__ | defined __cplusplus
  2143. (tIdent pName, int pPos)
  2144. # else
  2145. (pName, pPos)
  2146. tIdent pName;
  2147. int pPos;
  2148. # endif
  2149. {
  2150.  register tTree yyt;
  2151.  yyALLOC (yyt, Tree_NodeSize [kSAVE_DECL])
  2152.  yyt->Kind = kSAVE_DECL;
  2153.  yyt->yyHead.yyMark = 0;
  2154.  yyt->yyHead.yyParent = NoTree;
  2155.  yyt->SAVE_DECL.Name = pName;
  2156.  yyt->SAVE_DECL.Pos = pPos;
  2157.  return yyt;
  2158. }
  2159.  
  2160. tTree mTARGET_DECL
  2161. # if defined __STDC__ | defined __cplusplus
  2162. (tIdent pName, int pPos)
  2163. # else
  2164. (pName, pPos)
  2165. tIdent pName;
  2166. int pPos;
  2167. # endif
  2168. {
  2169.  register tTree yyt;
  2170.  yyALLOC (yyt, Tree_NodeSize [kTARGET_DECL])
  2171.  yyt->Kind = kTARGET_DECL;
  2172.  yyt->yyHead.yyMark = 0;
  2173.  yyt->yyHead.yyParent = NoTree;
  2174.  yyt->TARGET_DECL.Name = pName;
  2175.  yyt->TARGET_DECL.Pos = pPos;
  2176.  return yyt;
  2177. }
  2178.  
  2179. tTree mPARAMETER_DECL
  2180. # if defined __STDC__ | defined __cplusplus
  2181. (tIdent pName, int pPos, tTree pVAL)
  2182. # else
  2183. (pName, pPos, pVAL)
  2184. tIdent pName;
  2185. int pPos;
  2186. tTree pVAL;
  2187. # endif
  2188. {
  2189.  register tTree yyt;
  2190.  yyALLOC (yyt, Tree_NodeSize [kPARAMETER_DECL])
  2191.  yyt->Kind = kPARAMETER_DECL;
  2192.  yyt->yyHead.yyMark = 0;
  2193.  yyt->yyHead.yyParent = NoTree;
  2194.  yyt->PARAMETER_DECL.Name = pName;
  2195.  yyt->PARAMETER_DECL.Pos = pPos;
  2196.  yyt->PARAMETER_DECL.VAL = pVAL;
  2197.  return yyt;
  2198. }
  2199.  
  2200. tTree mPUBLIC_DECL
  2201. # if defined __STDC__ | defined __cplusplus
  2202. (tIdent pName, int pPos)
  2203. # else
  2204. (pName, pPos)
  2205. tIdent pName;
  2206. int pPos;
  2207. # endif
  2208. {
  2209.  register tTree yyt;
  2210.  yyALLOC (yyt, Tree_NodeSize [kPUBLIC_DECL])
  2211.  yyt->Kind = kPUBLIC_DECL;
  2212.  yyt->yyHead.yyMark = 0;
  2213.  yyt->yyHead.yyParent = NoTree;
  2214.  yyt->PUBLIC_DECL.Name = pName;
  2215.  yyt->PUBLIC_DECL.Pos = pPos;
  2216.  return yyt;
  2217. }
  2218.  
  2219. tTree mPRIVATE_DECL
  2220. # if defined __STDC__ | defined __cplusplus
  2221. (tIdent pName, int pPos)
  2222. # else
  2223. (pName, pPos)
  2224. tIdent pName;
  2225. int pPos;
  2226. # endif
  2227. {
  2228.  register tTree yyt;
  2229.  yyALLOC (yyt, Tree_NodeSize [kPRIVATE_DECL])
  2230.  yyt->Kind = kPRIVATE_DECL;
  2231.  yyt->yyHead.yyMark = 0;
  2232.  yyt->yyHead.yyParent = NoTree;
  2233.  yyt->PRIVATE_DECL.Name = pName;
  2234.  yyt->PRIVATE_DECL.Pos = pPos;
  2235.  return yyt;
  2236. }
  2237.  
  2238. tTree mDISTRIBUTE_DECL
  2239. # if defined __STDC__ | defined __cplusplus
  2240. (tIdent pName, int pPos, tTree pDISTRIBUTION, tIdent ptarget)
  2241. # else
  2242. (pName, pPos, pDISTRIBUTION, ptarget)
  2243. tIdent pName;
  2244. int pPos;
  2245. tTree pDISTRIBUTION;
  2246. tIdent ptarget;
  2247. # endif
  2248. {
  2249.  register tTree yyt;
  2250.  yyALLOC (yyt, Tree_NodeSize [kDISTRIBUTE_DECL])
  2251.  yyt->Kind = kDISTRIBUTE_DECL;
  2252.  yyt->yyHead.yyMark = 0;
  2253.  yyt->yyHead.yyParent = NoTree;
  2254.  yyt->DISTRIBUTE_DECL.Name = pName;
  2255.  yyt->DISTRIBUTE_DECL.Pos = pPos;
  2256.  yyt->DISTRIBUTE_DECL.DISTRIBUTION = pDISTRIBUTION;
  2257.  yyt->DISTRIBUTE_DECL.target = ptarget;
  2258.  return yyt;
  2259. }
  2260.  
  2261. tTree mALIGN_DECL
  2262. # if defined __STDC__ | defined __cplusplus
  2263. (tIdent pName, int pPos, tTree pALIGN_SOURCE, tTree pALIGN_SPEC)
  2264. # else
  2265. (pName, pPos, pALIGN_SOURCE, pALIGN_SPEC)
  2266. tIdent pName;
  2267. int pPos;
  2268. tTree pALIGN_SOURCE;
  2269. tTree pALIGN_SPEC;
  2270. # endif
  2271. {
  2272.  register tTree yyt;
  2273.  yyALLOC (yyt, Tree_NodeSize [kALIGN_DECL])
  2274.  yyt->Kind = kALIGN_DECL;
  2275.  yyt->yyHead.yyMark = 0;
  2276.  yyt->yyHead.yyParent = NoTree;
  2277.  yyt->ALIGN_DECL.Name = pName;
  2278.  yyt->ALIGN_DECL.Pos = pPos;
  2279.  yyt->ALIGN_DECL.ALIGN_SOURCE = pALIGN_SOURCE;
  2280.  yyt->ALIGN_DECL.ALIGN_SPEC = pALIGN_SPEC;
  2281.  return yyt;
  2282. }
  2283.  
  2284. tTree mDYNAMIC_DECL
  2285. # if defined __STDC__ | defined __cplusplus
  2286. (tIdent pName, int pPos)
  2287. # else
  2288. (pName, pPos)
  2289. tIdent pName;
  2290. int pPos;
  2291. # endif
  2292. {
  2293.  register tTree yyt;
  2294.  yyALLOC (yyt, Tree_NodeSize [kDYNAMIC_DECL])
  2295.  yyt->Kind = kDYNAMIC_DECL;
  2296.  yyt->yyHead.yyMark = 0;
  2297.  yyt->yyHead.yyParent = NoTree;
  2298.  yyt->DYNAMIC_DECL.Name = pName;
  2299.  yyt->DYNAMIC_DECL.Pos = pPos;
  2300.  return yyt;
  2301. }
  2302.  
  2303. tTree mSEQUENCE_DECL
  2304. # if defined __STDC__ | defined __cplusplus
  2305. (tIdent pName, int pPos)
  2306. # else
  2307. (pName, pPos)
  2308. tIdent pName;
  2309. int pPos;
  2310. # endif
  2311. {
  2312.  register tTree yyt;
  2313.  yyALLOC (yyt, Tree_NodeSize [kSEQUENCE_DECL])
  2314.  yyt->Kind = kSEQUENCE_DECL;
  2315.  yyt->yyHead.yyMark = 0;
  2316.  yyt->yyHead.yyParent = NoTree;
  2317.  yyt->SEQUENCE_DECL.Name = pName;
  2318.  yyt->SEQUENCE_DECL.Pos = pPos;
  2319.  return yyt;
  2320. }
  2321.  
  2322. tTree mNOSEQUENCE_DECL
  2323. # if defined __STDC__ | defined __cplusplus
  2324. (tIdent pName, int pPos)
  2325. # else
  2326. (pName, pPos)
  2327. tIdent pName;
  2328. int pPos;
  2329. # endif
  2330. {
  2331.  register tTree yyt;
  2332.  yyALLOC (yyt, Tree_NodeSize [kNOSEQUENCE_DECL])
  2333.  yyt->Kind = kNOSEQUENCE_DECL;
  2334.  yyt->yyHead.yyMark = 0;
  2335.  yyt->yyHead.yyParent = NoTree;
  2336.  yyt->NOSEQUENCE_DECL.Name = pName;
  2337.  yyt->NOSEQUENCE_DECL.Pos = pPos;
  2338.  return yyt;
  2339. }
  2340.  
  2341. tTree mDECL_NODE_LIST
  2342. # if defined __STDC__ | defined __cplusplus
  2343. ()
  2344. # else
  2345. ()
  2346. # endif
  2347. {
  2348.  register tTree yyt;
  2349.  yyALLOC (yyt, Tree_NodeSize [kDECL_NODE_LIST])
  2350.  yyt->Kind = kDECL_NODE_LIST;
  2351.  yyt->yyHead.yyMark = 0;
  2352.  yyt->yyHead.yyParent = NoTree;
  2353.  return yyt;
  2354. }
  2355.  
  2356. tTree mDECL_EMPTY
  2357. # if defined __STDC__ | defined __cplusplus
  2358. ()
  2359. # else
  2360. ()
  2361. # endif
  2362. {
  2363.  register tTree yyt;
  2364.  yyALLOC (yyt, Tree_NodeSize [kDECL_EMPTY])
  2365.  yyt->Kind = kDECL_EMPTY;
  2366.  yyt->yyHead.yyMark = 0;
  2367.  yyt->yyHead.yyParent = NoTree;
  2368.  return yyt;
  2369. }
  2370.  
  2371. tTree mDECL_LIST
  2372. # if defined __STDC__ | defined __cplusplus
  2373. (tTree pElem, tTree pNext)
  2374. # else
  2375. (pElem, pNext)
  2376. tTree pElem;
  2377. tTree pNext;
  2378. # endif
  2379. {
  2380.  register tTree yyt;
  2381.  yyALLOC (yyt, Tree_NodeSize [kDECL_LIST])
  2382.  yyt->Kind = kDECL_LIST;
  2383.  yyt->yyHead.yyMark = 0;
  2384.  yyt->yyHead.yyParent = NoTree;
  2385.  yyt->DECL_LIST.Elem = pElem;
  2386.  yyt->DECL_LIST.Next = pNext;
  2387.  return yyt;
  2388. }
  2389.  
  2390. tTree mDISTRIBUTION_SPEC
  2391. # if defined __STDC__ | defined __cplusplus
  2392. ()
  2393. # else
  2394. ()
  2395. # endif
  2396. {
  2397.  register tTree yyt;
  2398.  yyALLOC (yyt, Tree_NodeSize [kDISTRIBUTION_SPEC])
  2399.  yyt->Kind = kDISTRIBUTION_SPEC;
  2400.  yyt->yyHead.yyMark = 0;
  2401.  yyt->yyHead.yyParent = NoTree;
  2402.  return yyt;
  2403. }
  2404.  
  2405. tTree mHOST_DISTRIBUTION
  2406. # if defined __STDC__ | defined __cplusplus
  2407. ()
  2408. # else
  2409. ()
  2410. # endif
  2411. {
  2412.  register tTree yyt;
  2413.  yyALLOC (yyt, Tree_NodeSize [kHOST_DISTRIBUTION])
  2414.  yyt->Kind = kHOST_DISTRIBUTION;
  2415.  yyt->yyHead.yyMark = 0;
  2416.  yyt->yyHead.yyParent = NoTree;
  2417.  return yyt;
  2418. }
  2419.  
  2420. tTree mREPL_DISTRIBUTION
  2421. # if defined __STDC__ | defined __cplusplus
  2422. ()
  2423. # else
  2424. ()
  2425. # endif
  2426. {
  2427.  register tTree yyt;
  2428.  yyALLOC (yyt, Tree_NodeSize [kREPL_DISTRIBUTION])
  2429.  yyt->Kind = kREPL_DISTRIBUTION;
  2430.  yyt->yyHead.yyMark = 0;
  2431.  yyt->yyHead.yyParent = NoTree;
  2432.  return yyt;
  2433. }
  2434.  
  2435. tTree mNODE_DISTRIBUTION
  2436. # if defined __STDC__ | defined __cplusplus
  2437. (tTree pMAPPING)
  2438. # else
  2439. (pMAPPING)
  2440. tTree pMAPPING;
  2441. # endif
  2442. {
  2443.  register tTree yyt;
  2444.  yyALLOC (yyt, Tree_NodeSize [kNODE_DISTRIBUTION])
  2445.  yyt->Kind = kNODE_DISTRIBUTION;
  2446.  yyt->yyHead.yyMark = 0;
  2447.  yyt->yyHead.yyParent = NoTree;
  2448.  yyt->NODE_DISTRIBUTION.MAPPING = pMAPPING;
  2449.  return yyt;
  2450. }
  2451.  
  2452. tTree mDISTRIBUTION_FORMAT
  2453. # if defined __STDC__ | defined __cplusplus
  2454. ()
  2455. # else
  2456. ()
  2457. # endif
  2458. {
  2459.  register tTree yyt;
  2460.  yyALLOC (yyt, Tree_NodeSize [kDISTRIBUTION_FORMAT])
  2461.  yyt->Kind = kDISTRIBUTION_FORMAT;
  2462.  yyt->yyHead.yyMark = 0;
  2463.  yyt->yyHead.yyParent = NoTree;
  2464.  return yyt;
  2465. }
  2466.  
  2467. tTree mBLOCK_DISTRIBUTION
  2468. # if defined __STDC__ | defined __cplusplus
  2469. (tTree pSIZE)
  2470. # else
  2471. (pSIZE)
  2472. tTree pSIZE;
  2473. # endif
  2474. {
  2475.  register tTree yyt;
  2476.  yyALLOC (yyt, Tree_NodeSize [kBLOCK_DISTRIBUTION])
  2477.  yyt->Kind = kBLOCK_DISTRIBUTION;
  2478.  yyt->yyHead.yyMark = 0;
  2479.  yyt->yyHead.yyParent = NoTree;
  2480.  yyt->BLOCK_DISTRIBUTION.SIZE = pSIZE;
  2481.  return yyt;
  2482. }
  2483.  
  2484. tTree mCYCLIC_DISTRIBUTION
  2485. # if defined __STDC__ | defined __cplusplus
  2486. (tTree pSIZE)
  2487. # else
  2488. (pSIZE)
  2489. tTree pSIZE;
  2490. # endif
  2491. {
  2492.  register tTree yyt;
  2493.  yyALLOC (yyt, Tree_NodeSize [kCYCLIC_DISTRIBUTION])
  2494.  yyt->Kind = kCYCLIC_DISTRIBUTION;
  2495.  yyt->yyHead.yyMark = 0;
  2496.  yyt->yyHead.yyParent = NoTree;
  2497.  yyt->CYCLIC_DISTRIBUTION.SIZE = pSIZE;
  2498.  return yyt;
  2499. }
  2500.  
  2501. tTree mSERIAL_DISTRIBUTION
  2502. # if defined __STDC__ | defined __cplusplus
  2503. ()
  2504. # else
  2505. ()
  2506. # endif
  2507. {
  2508.  register tTree yyt;
  2509.  yyALLOC (yyt, Tree_NodeSize [kSERIAL_DISTRIBUTION])
  2510.  yyt->Kind = kSERIAL_DISTRIBUTION;
  2511.  yyt->yyHead.yyMark = 0;
  2512.  yyt->yyHead.yyParent = NoTree;
  2513.  return yyt;
  2514. }
  2515.  
  2516. tTree mDIST_FORMAT_LIST
  2517. # if defined __STDC__ | defined __cplusplus
  2518. ()
  2519. # else
  2520. ()
  2521. # endif
  2522. {
  2523.  register tTree yyt;
  2524.  yyALLOC (yyt, Tree_NodeSize [kDIST_FORMAT_LIST])
  2525.  yyt->Kind = kDIST_FORMAT_LIST;
  2526.  yyt->yyHead.yyMark = 0;
  2527.  yyt->yyHead.yyParent = NoTree;
  2528.  return yyt;
  2529. }
  2530.  
  2531. tTree mDIST_EMPTY
  2532. # if defined __STDC__ | defined __cplusplus
  2533. ()
  2534. # else
  2535. ()
  2536. # endif
  2537. {
  2538.  register tTree yyt;
  2539.  yyALLOC (yyt, Tree_NodeSize [kDIST_EMPTY])
  2540.  yyt->Kind = kDIST_EMPTY;
  2541.  yyt->yyHead.yyMark = 0;
  2542.  yyt->yyHead.yyParent = NoTree;
  2543.  return yyt;
  2544. }
  2545.  
  2546. tTree mDIST_LIST
  2547. # if defined __STDC__ | defined __cplusplus
  2548. (tTree pElem, tTree pNext)
  2549. # else
  2550. (pElem, pNext)
  2551. tTree pElem;
  2552. tTree pNext;
  2553. # endif
  2554. {
  2555.  register tTree yyt;
  2556.  yyALLOC (yyt, Tree_NodeSize [kDIST_LIST])
  2557.  yyt->Kind = kDIST_LIST;
  2558.  yyt->yyHead.yyMark = 0;
  2559.  yyt->yyHead.yyParent = NoTree;
  2560.  yyt->DIST_LIST.Elem = pElem;
  2561.  yyt->DIST_LIST.Next = pNext;
  2562.  return yyt;
  2563. }
  2564.  
  2565. tTree mGENERIC_SPEC
  2566. # if defined __STDC__ | defined __cplusplus
  2567. ()
  2568. # else
  2569. ()
  2570. # endif
  2571. {
  2572.  register tTree yyt;
  2573.  yyALLOC (yyt, Tree_NodeSize [kGENERIC_SPEC])
  2574.  yyt->Kind = kGENERIC_SPEC;
  2575.  yyt->yyHead.yyMark = 0;
  2576.  yyt->yyHead.yyParent = NoTree;
  2577.  return yyt;
  2578. }
  2579.  
  2580. tTree mNO_GENERIC_SPEC
  2581. # if defined __STDC__ | defined __cplusplus
  2582. ()
  2583. # else
  2584. ()
  2585. # endif
  2586. {
  2587.  register tTree yyt;
  2588.  yyALLOC (yyt, Tree_NodeSize [kNO_GENERIC_SPEC])
  2589.  yyt->Kind = kNO_GENERIC_SPEC;
  2590.  yyt->yyHead.yyMark = 0;
  2591.  yyt->yyHead.yyParent = NoTree;
  2592.  return yyt;
  2593. }
  2594.  
  2595. tTree mID_GENERIC_SPEC
  2596. # if defined __STDC__ | defined __cplusplus
  2597. (tIdent pname)
  2598. # else
  2599. (pname)
  2600. tIdent pname;
  2601. # endif
  2602. {
  2603.  register tTree yyt;
  2604.  yyALLOC (yyt, Tree_NodeSize [kID_GENERIC_SPEC])
  2605.  yyt->Kind = kID_GENERIC_SPEC;
  2606.  yyt->yyHead.yyMark = 0;
  2607.  yyt->yyHead.yyParent = NoTree;
  2608.  yyt->ID_GENERIC_SPEC.name = pname;
  2609.  return yyt;
  2610. }
  2611.  
  2612. tTree mOP_GENERIC_SPEC
  2613. # if defined __STDC__ | defined __cplusplus
  2614. (tTree pOPERATOR)
  2615. # else
  2616. (pOPERATOR)
  2617. tTree pOPERATOR;
  2618. # endif
  2619. {
  2620.  register tTree yyt;
  2621.  yyALLOC (yyt, Tree_NodeSize [kOP_GENERIC_SPEC])
  2622.  yyt->Kind = kOP_GENERIC_SPEC;
  2623.  yyt->yyHead.yyMark = 0;
  2624.  yyt->yyHead.yyParent = NoTree;
  2625.  yyt->OP_GENERIC_SPEC.OPERATOR = pOPERATOR;
  2626.  return yyt;
  2627. }
  2628.  
  2629. tTree mASSIGN_GENERIC_SPEC
  2630. # if defined __STDC__ | defined __cplusplus
  2631. ()
  2632. # else
  2633. ()
  2634. # endif
  2635. {
  2636.  register tTree yyt;
  2637.  yyALLOC (yyt, Tree_NodeSize [kASSIGN_GENERIC_SPEC])
  2638.  yyt->Kind = kASSIGN_GENERIC_SPEC;
  2639.  yyt->yyHead.yyMark = 0;
  2640.  yyt->yyHead.yyParent = NoTree;
  2641.  return yyt;
  2642. }
  2643.  
  2644. tTree mACF_NODE_LIST
  2645. # if defined __STDC__ | defined __cplusplus
  2646. ()
  2647. # else
  2648. ()
  2649. # endif
  2650. {
  2651.  register tTree yyt;
  2652.  yyALLOC (yyt, Tree_NodeSize [kACF_NODE_LIST])
  2653.  yyt->Kind = kACF_NODE_LIST;
  2654.  yyt->yyHead.yyMark = 0;
  2655.  yyt->yyHead.yyParent = NoTree;
  2656.  return yyt;
  2657. }
  2658.  
  2659. tTree mACF_EMPTY
  2660. # if defined __STDC__ | defined __cplusplus
  2661. ()
  2662. # else
  2663. ()
  2664. # endif
  2665. {
  2666.  register tTree yyt;
  2667.  yyALLOC (yyt, Tree_NodeSize [kACF_EMPTY])
  2668.  yyt->Kind = kACF_EMPTY;
  2669.  yyt->yyHead.yyMark = 0;
  2670.  yyt->yyHead.yyParent = NoTree;
  2671.  return yyt;
  2672. }
  2673.  
  2674. tTree mACF_LIST
  2675. # if defined __STDC__ | defined __cplusplus
  2676. (tTree pElem, tTree pNext)
  2677. # else
  2678. (pElem, pNext)
  2679. tTree pElem;
  2680. tTree pNext;
  2681. # endif
  2682. {
  2683.  register tTree yyt;
  2684.  yyALLOC (yyt, Tree_NodeSize [kACF_LIST])
  2685.  yyt->Kind = kACF_LIST;
  2686.  yyt->yyHead.yyMark = 0;
  2687.  yyt->yyHead.yyParent = NoTree;
  2688.  yyt->ACF_LIST.Elem = pElem;
  2689.  yyt->ACF_LIST.Next = pNext;
  2690.  return yyt;
  2691. }
  2692.  
  2693. tTree mACF_NODE
  2694. # if defined __STDC__ | defined __cplusplus
  2695. ()
  2696. # else
  2697. ()
  2698. # endif
  2699. {
  2700.  register tTree yyt;
  2701.  yyALLOC (yyt, Tree_NodeSize [kACF_NODE])
  2702.  yyt->Kind = kACF_NODE;
  2703.  yyt->yyHead.yyMark = 0;
  2704.  yyt->yyHead.yyParent = NoTree;
  2705.  beginint(yyt->ACF_NODE.Label)
  2706.  beginint(yyt->ACF_NODE.Line)
  2707.  return yyt;
  2708. }
  2709.  
  2710. tTree mACF_DUMMY
  2711. # if defined __STDC__ | defined __cplusplus
  2712. ()
  2713. # else
  2714. ()
  2715. # endif
  2716. {
  2717.  register tTree yyt;
  2718.  yyALLOC (yyt, Tree_NodeSize [kACF_DUMMY])
  2719.  yyt->Kind = kACF_DUMMY;
  2720.  yyt->yyHead.yyMark = 0;
  2721.  yyt->yyHead.yyParent = NoTree;
  2722.  beginint(yyt->ACF_DUMMY.Label)
  2723.  beginint(yyt->ACF_DUMMY.Line)
  2724.  return yyt;
  2725. }
  2726.  
  2727. tTree mACF_BASIC
  2728. # if defined __STDC__ | defined __cplusplus
  2729. (tTree pBASIC_STMT)
  2730. # else
  2731. (pBASIC_STMT)
  2732. tTree pBASIC_STMT;
  2733. # endif
  2734. {
  2735.  register tTree yyt;
  2736.  yyALLOC (yyt, Tree_NodeSize [kACF_BASIC])
  2737.  yyt->Kind = kACF_BASIC;
  2738.  yyt->yyHead.yyMark = 0;
  2739.  yyt->yyHead.yyParent = NoTree;
  2740.  beginint(yyt->ACF_BASIC.Label)
  2741.  beginint(yyt->ACF_BASIC.Line)
  2742.  yyt->ACF_BASIC.BASIC_STMT = pBASIC_STMT;
  2743.  return yyt;
  2744. }
  2745.  
  2746. tTree mACF_IF
  2747. # if defined __STDC__ | defined __cplusplus
  2748. (tTree pIF_EXP, tTree pTHEN_PART, tTree pELSE_PART)
  2749. # else
  2750. (pIF_EXP, pTHEN_PART, pELSE_PART)
  2751. tTree pIF_EXP;
  2752. tTree pTHEN_PART;
  2753. tTree pELSE_PART;
  2754. # endif
  2755. {
  2756.  register tTree yyt;
  2757.  yyALLOC (yyt, Tree_NodeSize [kACF_IF])
  2758.  yyt->Kind = kACF_IF;
  2759.  yyt->yyHead.yyMark = 0;
  2760.  yyt->yyHead.yyParent = NoTree;
  2761.  beginint(yyt->ACF_IF.Label)
  2762.  beginint(yyt->ACF_IF.Line)
  2763.  yyt->ACF_IF.IF_EXP = pIF_EXP;
  2764.  yyt->ACF_IF.THEN_PART = pTHEN_PART;
  2765.  yyt->ACF_IF.ELSE_PART = pELSE_PART;
  2766.  return yyt;
  2767. }
  2768.  
  2769. tTree mACF_WHERE
  2770. # if defined __STDC__ | defined __cplusplus
  2771. (tTree pWHERE_EXP, tTree pTRUE_PART, tTree pFALSE_PART)
  2772. # else
  2773. (pWHERE_EXP, pTRUE_PART, pFALSE_PART)
  2774. tTree pWHERE_EXP;
  2775. tTree pTRUE_PART;
  2776. tTree pFALSE_PART;
  2777. # endif
  2778. {
  2779.  register tTree yyt;
  2780.  yyALLOC (yyt, Tree_NodeSize [kACF_WHERE])
  2781.  yyt->Kind = kACF_WHERE;
  2782.  yyt->yyHead.yyMark = 0;
  2783.  yyt->yyHead.yyParent = NoTree;
  2784.  beginint(yyt->ACF_WHERE.Label)
  2785.  beginint(yyt->ACF_WHERE.Line)
  2786.  yyt->ACF_WHERE.WHERE_EXP = pWHERE_EXP;
  2787.  yyt->ACF_WHERE.TRUE_PART = pTRUE_PART;
  2788.  yyt->ACF_WHERE.FALSE_PART = pFALSE_PART;
  2789.  return yyt;
  2790. }
  2791.  
  2792. tTree mACF_SWITCH
  2793. # if defined __STDC__ | defined __cplusplus
  2794. (tTree pSWITCH_EXP, tTree pSWITCH_STMT)
  2795. # else
  2796. (pSWITCH_EXP, pSWITCH_STMT)
  2797. tTree pSWITCH_EXP;
  2798. tTree pSWITCH_STMT;
  2799. # endif
  2800. {
  2801.  register tTree yyt;
  2802.  yyALLOC (yyt, Tree_NodeSize [kACF_SWITCH])
  2803.  yyt->Kind = kACF_SWITCH;
  2804.  yyt->yyHead.yyMark = 0;
  2805.  yyt->yyHead.yyParent = NoTree;
  2806.  beginint(yyt->ACF_SWITCH.Label)
  2807.  beginint(yyt->ACF_SWITCH.Line)
  2808.  yyt->ACF_SWITCH.SWITCH_EXP = pSWITCH_EXP;
  2809.  yyt->ACF_SWITCH.SWITCH_STMT = pSWITCH_STMT;
  2810.  return yyt;
  2811. }
  2812.  
  2813. tTree mACF_ALTER
  2814. # if defined __STDC__ | defined __cplusplus
  2815. (tTree pALTER_EXP, tTree pALTER_STMT)
  2816. # else
  2817. (pALTER_EXP, pALTER_STMT)
  2818. tTree pALTER_EXP;
  2819. tTree pALTER_STMT;
  2820. # endif
  2821. {
  2822.  register tTree yyt;
  2823.  yyALLOC (yyt, Tree_NodeSize [kACF_ALTER])
  2824.  yyt->Kind = kACF_ALTER;
  2825.  yyt->yyHead.yyMark = 0;
  2826.  yyt->yyHead.yyParent = NoTree;
  2827.  beginint(yyt->ACF_ALTER.Label)
  2828.  beginint(yyt->ACF_ALTER.Line)
  2829.  yyt->ACF_ALTER.ALTER_EXP = pALTER_EXP;
  2830.  yyt->ACF_ALTER.ALTER_STMT = pALTER_STMT;
  2831.  return yyt;
  2832. }
  2833.  
  2834. tTree mACF_CASE
  2835. # if defined __STDC__ | defined __cplusplus
  2836. (tTree pCASE_EXP, tTree pCASE_ALTS, tTree pCASE_OTHERWISE)
  2837. # else
  2838. (pCASE_EXP, pCASE_ALTS, pCASE_OTHERWISE)
  2839. tTree pCASE_EXP;
  2840. tTree pCASE_ALTS;
  2841. tTree pCASE_OTHERWISE;
  2842. # endif
  2843. {
  2844.  register tTree yyt;
  2845.  yyALLOC (yyt, Tree_NodeSize [kACF_CASE])
  2846.  yyt->Kind = kACF_CASE;
  2847.  yyt->yyHead.yyMark = 0;
  2848.  yyt->yyHead.yyParent = NoTree;
  2849.  beginint(yyt->ACF_CASE.Label)
  2850.  beginint(yyt->ACF_CASE.Line)
  2851.  yyt->ACF_CASE.CASE_EXP = pCASE_EXP;
  2852.  yyt->ACF_CASE.CASE_ALTS = pCASE_ALTS;
  2853.  yyt->ACF_CASE.CASE_OTHERWISE = pCASE_OTHERWISE;
  2854.  return yyt;
  2855. }
  2856.  
  2857. tTree mACF_WHILE
  2858. # if defined __STDC__ | defined __cplusplus
  2859. (tTree pWHILE_EXP, tTree pWHILE_BODY)
  2860. # else
  2861. (pWHILE_EXP, pWHILE_BODY)
  2862. tTree pWHILE_EXP;
  2863. tTree pWHILE_BODY;
  2864. # endif
  2865. {
  2866.  register tTree yyt;
  2867.  yyALLOC (yyt, Tree_NodeSize [kACF_WHILE])
  2868.  yyt->Kind = kACF_WHILE;
  2869.  yyt->yyHead.yyMark = 0;
  2870.  yyt->yyHead.yyParent = NoTree;
  2871.  beginint(yyt->ACF_WHILE.Label)
  2872.  beginint(yyt->ACF_WHILE.Line)
  2873.  yyt->ACF_WHILE.WHILE_EXP = pWHILE_EXP;
  2874.  yyt->ACF_WHILE.WHILE_BODY = pWHILE_BODY;
  2875.  return yyt;
  2876. }
  2877.  
  2878. tTree mACF_REPEAT
  2879. # if defined __STDC__ | defined __cplusplus
  2880. (tTree pREPEAT_BODY, tTree pREPEAT_EXP)
  2881. # else
  2882. (pREPEAT_BODY, pREPEAT_EXP)
  2883. tTree pREPEAT_BODY;
  2884. tTree pREPEAT_EXP;
  2885. # endif
  2886. {
  2887.  register tTree yyt;
  2888.  yyALLOC (yyt, Tree_NodeSize [kACF_REPEAT])
  2889.  yyt->Kind = kACF_REPEAT;
  2890.  yyt->yyHead.yyMark = 0;
  2891.  yyt->yyHead.yyParent = NoTree;
  2892.  beginint(yyt->ACF_REPEAT.Label)
  2893.  beginint(yyt->ACF_REPEAT.Line)
  2894.  yyt->ACF_REPEAT.REPEAT_BODY = pREPEAT_BODY;
  2895.  yyt->ACF_REPEAT.REPEAT_EXP = pREPEAT_EXP;
  2896.  return yyt;
  2897. }
  2898.  
  2899. tTree mACF_WITH
  2900. # if defined __STDC__ | defined __cplusplus
  2901. (tTree pWITH_VARS, tTree pWITH_BODY)
  2902. # else
  2903. (pWITH_VARS, pWITH_BODY)
  2904. tTree pWITH_VARS;
  2905. tTree pWITH_BODY;
  2906. # endif
  2907. {
  2908.  register tTree yyt;
  2909.  yyALLOC (yyt, Tree_NodeSize [kACF_WITH])
  2910.  yyt->Kind = kACF_WITH;
  2911.  yyt->yyHead.yyMark = 0;
  2912.  yyt->yyHead.yyParent = NoTree;
  2913.  beginint(yyt->ACF_WITH.Label)
  2914.  beginint(yyt->ACF_WITH.Line)
  2915.  yyt->ACF_WITH.WITH_VARS = pWITH_VARS;
  2916.  yyt->ACF_WITH.WITH_BODY = pWITH_BODY;
  2917.  return yyt;
  2918. }
  2919.  
  2920. tTree mACF_LOOP
  2921. # if defined __STDC__ | defined __cplusplus
  2922. (tTree pLOOP_BODY)
  2923. # else
  2924. (pLOOP_BODY)
  2925. tTree pLOOP_BODY;
  2926. # endif
  2927. {
  2928.  register tTree yyt;
  2929.  yyALLOC (yyt, Tree_NodeSize [kACF_LOOP])
  2930.  yyt->Kind = kACF_LOOP;
  2931.  yyt->yyHead.yyMark = 0;
  2932.  yyt->yyHead.yyParent = NoTree;
  2933.  beginint(yyt->ACF_LOOP.Label)
  2934.  beginint(yyt->ACF_LOOP.Line)
  2935.  yyt->ACF_LOOP.LOOP_BODY = pLOOP_BODY;
  2936.  return yyt;
  2937. }
  2938.  
  2939. tTree mACF_DO
  2940. # if defined __STDC__ | defined __cplusplus
  2941. (tTree pDO_ID, tTree pDO_RANGE, tTree pDO_BODY)
  2942. # else
  2943. (pDO_ID, pDO_RANGE, pDO_BODY)
  2944. tTree pDO_ID;
  2945. tTree pDO_RANGE;
  2946. tTree pDO_BODY;
  2947. # endif
  2948. {
  2949.  register tTree yyt;
  2950.  yyALLOC (yyt, Tree_NodeSize [kACF_DO])
  2951.  yyt->Kind = kACF_DO;
  2952.  yyt->yyHead.yyMark = 0;
  2953.  yyt->yyHead.yyParent = NoTree;
  2954.  beginint(yyt->ACF_DO.Label)
  2955.  beginint(yyt->ACF_DO.Line)
  2956.  yyt->ACF_DO.DO_ID = pDO_ID;
  2957.  yyt->ACF_DO.DO_RANGE = pDO_RANGE;
  2958.  yyt->ACF_DO.DO_BODY = pDO_BODY;
  2959.  return yyt;
  2960. }
  2961.  
  2962. tTree mACF_DOLOCAL
  2963. # if defined __STDC__ | defined __cplusplus
  2964. (tTree pDOLOCAL_ID, tTree pDOLOCAL_RANGE, tTree pDOLOCAL_BODY)
  2965. # else
  2966. (pDOLOCAL_ID, pDOLOCAL_RANGE, pDOLOCAL_BODY)
  2967. tTree pDOLOCAL_ID;
  2968. tTree pDOLOCAL_RANGE;
  2969. tTree pDOLOCAL_BODY;
  2970. # endif
  2971. {
  2972.  register tTree yyt;
  2973.  yyALLOC (yyt, Tree_NodeSize [kACF_DOLOCAL])
  2974.  yyt->Kind = kACF_DOLOCAL;
  2975.  yyt->yyHead.yyMark = 0;
  2976.  yyt->yyHead.yyParent = NoTree;
  2977.  beginint(yyt->ACF_DOLOCAL.Label)
  2978.  beginint(yyt->ACF_DOLOCAL.Line)
  2979.  yyt->ACF_DOLOCAL.DOLOCAL_ID = pDOLOCAL_ID;
  2980.  yyt->ACF_DOLOCAL.DOLOCAL_RANGE = pDOLOCAL_RANGE;
  2981.  yyt->ACF_DOLOCAL.DOLOCAL_BODY = pDOLOCAL_BODY;
  2982.  return yyt;
  2983. }
  2984.  
  2985. tTree mACF_DOVEC
  2986. # if defined __STDC__ | defined __cplusplus
  2987. (tTree pDOVEC_ID, tTree pDOVEC_RANGE, tTree pDOVEC_BODY)
  2988. # else
  2989. (pDOVEC_ID, pDOVEC_RANGE, pDOVEC_BODY)
  2990. tTree pDOVEC_ID;
  2991. tTree pDOVEC_RANGE;
  2992. tTree pDOVEC_BODY;
  2993. # endif
  2994. {
  2995.  register tTree yyt;
  2996.  yyALLOC (yyt, Tree_NodeSize [kACF_DOVEC])
  2997.  yyt->Kind = kACF_DOVEC;
  2998.  yyt->yyHead.yyMark = 0;
  2999.  yyt->yyHead.yyParent = NoTree;
  3000.  beginint(yyt->ACF_DOVEC.Label)
  3001.  beginint(yyt->ACF_DOVEC.Line)
  3002.  yyt->ACF_DOVEC.DOVEC_ID = pDOVEC_ID;
  3003.  yyt->ACF_DOVEC.DOVEC_RANGE = pDOVEC_RANGE;
  3004.  yyt->ACF_DOVEC.DOVEC_BODY = pDOVEC_BODY;
  3005.  return yyt;
  3006. }
  3007.  
  3008. tTree mACF_DOALL
  3009. # if defined __STDC__ | defined __cplusplus
  3010. (tTree pDOALL_NEW, tTree pDOALL_ID, tTree pDOALL_RANGE, tTree pDOALL_BODY)
  3011. # else
  3012. (pDOALL_NEW, pDOALL_ID, pDOALL_RANGE, pDOALL_BODY)
  3013. tTree pDOALL_NEW;
  3014. tTree pDOALL_ID;
  3015. tTree pDOALL_RANGE;
  3016. tTree pDOALL_BODY;
  3017. # endif
  3018. {
  3019.  register tTree yyt;
  3020.  yyALLOC (yyt, Tree_NodeSize [kACF_DOALL])
  3021.  yyt->Kind = kACF_DOALL;
  3022.  yyt->yyHead.yyMark = 0;
  3023.  yyt->yyHead.yyParent = NoTree;
  3024.  beginint(yyt->ACF_DOALL.Label)
  3025.  beginint(yyt->ACF_DOALL.Line)
  3026.  yyt->ACF_DOALL.DOALL_NEW = pDOALL_NEW;
  3027.  yyt->ACF_DOALL.DOALL_ID = pDOALL_ID;
  3028.  yyt->ACF_DOALL.DOALL_RANGE = pDOALL_RANGE;
  3029.  yyt->ACF_DOALL.DOALL_BODY = pDOALL_BODY;
  3030.  return yyt;
  3031. }
  3032.  
  3033. tTree mACF_FORALL
  3034. # if defined __STDC__ | defined __cplusplus
  3035. (tTree pFORALL_ID, tTree pFORALL_RANGE, tTree pFORALL_BODY)
  3036. # else
  3037. (pFORALL_ID, pFORALL_RANGE, pFORALL_BODY)
  3038. tTree pFORALL_ID;
  3039. tTree pFORALL_RANGE;
  3040. tTree pFORALL_BODY;
  3041. # endif
  3042. {
  3043.  register tTree yyt;
  3044.  yyALLOC (yyt, Tree_NodeSize [kACF_FORALL])
  3045.  yyt->Kind = kACF_FORALL;
  3046.  yyt->yyHead.yyMark = 0;
  3047.  yyt->yyHead.yyParent = NoTree;
  3048.  beginint(yyt->ACF_FORALL.Label)
  3049.  beginint(yyt->ACF_FORALL.Line)
  3050.  yyt->ACF_FORALL.FORALL_ID = pFORALL_ID;
  3051.  yyt->ACF_FORALL.FORALL_RANGE = pFORALL_RANGE;
  3052.  yyt->ACF_FORALL.FORALL_BODY = pFORALL_BODY;
  3053.  return yyt;
  3054. }
  3055.  
  3056. tTree mACF_ON
  3057. # if defined __STDC__ | defined __cplusplus
  3058. (tTree pON_VAR, tTree pON_STMT)
  3059. # else
  3060. (pON_VAR, pON_STMT)
  3061. tTree pON_VAR;
  3062. tTree pON_STMT;
  3063. # endif
  3064. {
  3065.  register tTree yyt;
  3066.  yyALLOC (yyt, Tree_NodeSize [kACF_ON])
  3067.  yyt->Kind = kACF_ON;
  3068.  yyt->yyHead.yyMark = 0;
  3069.  yyt->yyHead.yyParent = NoTree;
  3070.  beginint(yyt->ACF_ON.Label)
  3071.  beginint(yyt->ACF_ON.Line)
  3072.  yyt->ACF_ON.ON_VAR = pON_VAR;
  3073.  yyt->ACF_ON.ON_STMT = pON_STMT;
  3074.  return yyt;
  3075. }
  3076.  
  3077. tTree mACF_BODY
  3078. # if defined __STDC__ | defined __cplusplus
  3079. (tTree pNEW_BODY)
  3080. # else
  3081. (pNEW_BODY)
  3082. tTree pNEW_BODY;
  3083. # endif
  3084. {
  3085.  register tTree yyt;
  3086.  yyALLOC (yyt, Tree_NodeSize [kACF_BODY])
  3087.  yyt->Kind = kACF_BODY;
  3088.  yyt->yyHead.yyMark = 0;
  3089.  yyt->yyHead.yyParent = NoTree;
  3090.  beginint(yyt->ACF_BODY.Label)
  3091.  beginint(yyt->ACF_BODY.Line)
  3092.  yyt->ACF_BODY.NEW_BODY = pNEW_BODY;
  3093.  begintDefinitions(yyt->ACF_BODY.Entries)
  3094.  return yyt;
  3095. }
  3096.  
  3097. tTree mACF_FLOW_GRAPH
  3098. # if defined __STDC__ | defined __cplusplus
  3099. (tTree pFLOW_NODES)
  3100. # else
  3101. (pFLOW_NODES)
  3102. tTree pFLOW_NODES;
  3103. # endif
  3104. {
  3105.  register tTree yyt;
  3106.  yyALLOC (yyt, Tree_NodeSize [kACF_FLOW_GRAPH])
  3107.  yyt->Kind = kACF_FLOW_GRAPH;
  3108.  yyt->yyHead.yyMark = 0;
  3109.  yyt->yyHead.yyParent = NoTree;
  3110.  beginint(yyt->ACF_FLOW_GRAPH.Label)
  3111.  beginint(yyt->ACF_FLOW_GRAPH.Line)
  3112.  yyt->ACF_FLOW_GRAPH.FLOW_NODES = pFLOW_NODES;
  3113.  return yyt;
  3114. }
  3115.  
  3116. tTree mACF_ENTRY
  3117. # if defined __STDC__ | defined __cplusplus
  3118. (tTree pENTRY_DECL)
  3119. # else
  3120. (pENTRY_DECL)
  3121. tTree pENTRY_DECL;
  3122. # endif
  3123. {
  3124.  register tTree yyt;
  3125.  yyALLOC (yyt, Tree_NodeSize [kACF_ENTRY])
  3126.  yyt->Kind = kACF_ENTRY;
  3127.  yyt->yyHead.yyMark = 0;
  3128.  yyt->yyHead.yyParent = NoTree;
  3129.  beginint(yyt->ACF_ENTRY.Label)
  3130.  beginint(yyt->ACF_ENTRY.Line)
  3131.  yyt->ACF_ENTRY.ENTRY_DECL = pENTRY_DECL;
  3132.  return yyt;
  3133. }
  3134.  
  3135. tTree mACF_FLOW_KIND
  3136. # if defined __STDC__ | defined __cplusplus
  3137. ()
  3138. # else
  3139. ()
  3140. # endif
  3141. {
  3142.  register tTree yyt;
  3143.  yyALLOC (yyt, Tree_NodeSize [kACF_FLOW_KIND])
  3144.  yyt->Kind = kACF_FLOW_KIND;
  3145.  yyt->yyHead.yyMark = 0;
  3146.  yyt->yyHead.yyParent = NoTree;
  3147.  return yyt;
  3148. }
  3149.  
  3150. tTree mACF_COMPLEX_FLOW
  3151. # if defined __STDC__ | defined __cplusplus
  3152. ()
  3153. # else
  3154. ()
  3155. # endif
  3156. {
  3157.  register tTree yyt;
  3158.  yyALLOC (yyt, Tree_NodeSize [kACF_COMPLEX_FLOW])
  3159.  yyt->Kind = kACF_COMPLEX_FLOW;
  3160.  yyt->yyHead.yyMark = 0;
  3161.  yyt->yyHead.yyParent = NoTree;
  3162.  return yyt;
  3163. }
  3164.  
  3165. tTree mACF_INTERVAL_FLOW
  3166. # if defined __STDC__ | defined __cplusplus
  3167. ()
  3168. # else
  3169. ()
  3170. # endif
  3171. {
  3172.  register tTree yyt;
  3173.  yyALLOC (yyt, Tree_NodeSize [kACF_INTERVAL_FLOW])
  3174.  yyt->Kind = kACF_INTERVAL_FLOW;
  3175.  yyt->yyHead.yyMark = 0;
  3176.  yyt->yyHead.yyParent = NoTree;
  3177.  return yyt;
  3178. }
  3179.  
  3180. tTree mACF_SIMPLE_FLOW
  3181. # if defined __STDC__ | defined __cplusplus
  3182. ()
  3183. # else
  3184. ()
  3185. # endif
  3186. {
  3187.  register tTree yyt;
  3188.  yyALLOC (yyt, Tree_NodeSize [kACF_SIMPLE_FLOW])
  3189.  yyt->Kind = kACF_SIMPLE_FLOW;
  3190.  yyt->yyHead.yyMark = 0;
  3191.  yyt->yyHead.yyParent = NoTree;
  3192.  return yyt;
  3193. }
  3194.  
  3195. tTree mSELECTED_ACF_NODE_LIST
  3196. # if defined __STDC__ | defined __cplusplus
  3197. ()
  3198. # else
  3199. ()
  3200. # endif
  3201. {
  3202.  register tTree yyt;
  3203.  yyALLOC (yyt, Tree_NodeSize [kSELECTED_ACF_NODE_LIST])
  3204.  yyt->Kind = kSELECTED_ACF_NODE_LIST;
  3205.  yyt->yyHead.yyMark = 0;
  3206.  yyt->yyHead.yyParent = NoTree;
  3207.  return yyt;
  3208. }
  3209.  
  3210. tTree mSELECTED_ACF_EMPTY
  3211. # if defined __STDC__ | defined __cplusplus
  3212. ()
  3213. # else
  3214. ()
  3215. # endif
  3216. {
  3217.  register tTree yyt;
  3218.  yyALLOC (yyt, Tree_NodeSize [kSELECTED_ACF_EMPTY])
  3219.  yyt->Kind = kSELECTED_ACF_EMPTY;
  3220.  yyt->yyHead.yyMark = 0;
  3221.  yyt->yyHead.yyParent = NoTree;
  3222.  return yyt;
  3223. }
  3224.  
  3225. tTree mSELECTED_ACF_LIST
  3226. # if defined __STDC__ | defined __cplusplus
  3227. (tTree pElem, tTree pNext)
  3228. # else
  3229. (pElem, pNext)
  3230. tTree pElem;
  3231. tTree pNext;
  3232. # endif
  3233. {
  3234.  register tTree yyt;
  3235.  yyALLOC (yyt, Tree_NodeSize [kSELECTED_ACF_LIST])
  3236.  yyt->Kind = kSELECTED_ACF_LIST;
  3237.  yyt->yyHead.yyMark = 0;
  3238.  yyt->yyHead.yyParent = NoTree;
  3239.  yyt->SELECTED_ACF_LIST.Elem = pElem;
  3240.  yyt->SELECTED_ACF_LIST.Next = pNext;
  3241.  return yyt;
  3242. }
  3243.  
  3244. tTree mSELECTED_ACF_NODE
  3245. # if defined __STDC__ | defined __cplusplus
  3246. (tTree pSELECT_LIST, tTree pSELECT_ACFS)
  3247. # else
  3248. (pSELECT_LIST, pSELECT_ACFS)
  3249. tTree pSELECT_LIST;
  3250. tTree pSELECT_ACFS;
  3251. # endif
  3252. {
  3253.  register tTree yyt;
  3254.  yyALLOC (yyt, Tree_NodeSize [kSELECTED_ACF_NODE])
  3255.  yyt->Kind = kSELECTED_ACF_NODE;
  3256.  yyt->yyHead.yyMark = 0;
  3257.  yyt->yyHead.yyParent = NoTree;
  3258.  yyt->SELECTED_ACF_NODE.SELECT_LIST = pSELECT_LIST;
  3259.  yyt->SELECTED_ACF_NODE.SELECT_ACFS = pSELECT_ACFS;
  3260.  return yyt;
  3261. }
  3262.  
  3263. tTree mBT_STMT
  3264. # if defined __STDC__ | defined __cplusplus
  3265. ()
  3266. # else
  3267. ()
  3268. # endif
  3269. {
  3270.  register tTree yyt;
  3271.  yyALLOC (yyt, Tree_NodeSize [kBT_STMT])
  3272.  yyt->Kind = kBT_STMT;
  3273.  yyt->yyHead.yyMark = 0;
  3274.  yyt->yyHead.yyParent = NoTree;
  3275.  return yyt;
  3276. }
  3277.  
  3278. tTree mEXP_STMT
  3279. # if defined __STDC__ | defined __cplusplus
  3280. (tTree pSTMT_EXP)
  3281. # else
  3282. (pSTMT_EXP)
  3283. tTree pSTMT_EXP;
  3284. # endif
  3285. {
  3286.  register tTree yyt;
  3287.  yyALLOC (yyt, Tree_NodeSize [kEXP_STMT])
  3288.  yyt->Kind = kEXP_STMT;
  3289.  yyt->yyHead.yyMark = 0;
  3290.  yyt->yyHead.yyParent = NoTree;
  3291.  yyt->EXP_STMT.STMT_EXP = pSTMT_EXP;
  3292.  return yyt;
  3293. }
  3294.  
  3295. tTree mASSIGN_STMT
  3296. # if defined __STDC__ | defined __cplusplus
  3297. (tTree pASSIGN_VAR, tTree pASSIGN_EXP)
  3298. # else
  3299. (pASSIGN_VAR, pASSIGN_EXP)
  3300. tTree pASSIGN_VAR;
  3301. tTree pASSIGN_EXP;
  3302. # endif
  3303. {
  3304.  register tTree yyt;
  3305.  yyALLOC (yyt, Tree_NodeSize [kASSIGN_STMT])
  3306.  yyt->Kind = kASSIGN_STMT;
  3307.  yyt->yyHead.yyMark = 0;
  3308.  yyt->yyHead.yyParent = NoTree;
  3309.  yyt->ASSIGN_STMT.ASSIGN_VAR = pASSIGN_VAR;
  3310.  yyt->ASSIGN_STMT.ASSIGN_EXP = pASSIGN_EXP;
  3311.  return yyt;
  3312. }
  3313.  
  3314. tTree mPTR_ASSIGN_STMT
  3315. # if defined __STDC__ | defined __cplusplus
  3316. (tTree pASSIGN_VAR, tTree pASSIGN_EXP)
  3317. # else
  3318. (pASSIGN_VAR, pASSIGN_EXP)
  3319. tTree pASSIGN_VAR;
  3320. tTree pASSIGN_EXP;
  3321. # endif
  3322. {
  3323.  register tTree yyt;
  3324.  yyALLOC (yyt, Tree_NodeSize [kPTR_ASSIGN_STMT])
  3325.  yyt->Kind = kPTR_ASSIGN_STMT;
  3326.  yyt->yyHead.yyMark = 0;
  3327.  yyt->yyHead.yyParent = NoTree;
  3328.  yyt->PTR_ASSIGN_STMT.ASSIGN_VAR = pASSIGN_VAR;
  3329.  yyt->PTR_ASSIGN_STMT.ASSIGN_EXP = pASSIGN_EXP;
  3330.  return yyt;
  3331. }
  3332.  
  3333. tTree mLABEL_ASSIGN_STMT
  3334. # if defined __STDC__ | defined __cplusplus
  3335. (int passign_label, tTree pLABEL_VAR)
  3336. # else
  3337. (passign_label, pLABEL_VAR)
  3338. int passign_label;
  3339. tTree pLABEL_VAR;
  3340. # endif
  3341. {
  3342.  register tTree yyt;
  3343.  yyALLOC (yyt, Tree_NodeSize [kLABEL_ASSIGN_STMT])
  3344.  yyt->Kind = kLABEL_ASSIGN_STMT;
  3345.  yyt->yyHead.yyMark = 0;
  3346.  yyt->yyHead.yyParent = NoTree;
  3347.  yyt->LABEL_ASSIGN_STMT.assign_label = passign_label;
  3348.  yyt->LABEL_ASSIGN_STMT.LABEL_VAR = pLABEL_VAR;
  3349.  return yyt;
  3350. }
  3351.  
  3352. tTree mCALL_STMT
  3353. # if defined __STDC__ | defined __cplusplus
  3354. (tTree pCALL_ID, tTree pCALL_PARAMS)
  3355. # else
  3356. (pCALL_ID, pCALL_PARAMS)
  3357. tTree pCALL_ID;
  3358. tTree pCALL_PARAMS;
  3359. # endif
  3360. {
  3361.  register tTree yyt;
  3362.  yyALLOC (yyt, Tree_NodeSize [kCALL_STMT])
  3363.  yyt->Kind = kCALL_STMT;
  3364.  yyt->yyHead.yyMark = 0;
  3365.  yyt->yyHead.yyParent = NoTree;
  3366.  yyt->CALL_STMT.CALL_ID = pCALL_ID;
  3367.  yyt->CALL_STMT.CALL_PARAMS = pCALL_PARAMS;
  3368.  return yyt;
  3369. }
  3370.  
  3371. tTree mIO_STMT
  3372. # if defined __STDC__ | defined __cplusplus
  3373. (tTree pID, tTree pIO_SPECS, tTree pIO_ITEMS)
  3374. # else
  3375. (pID, pIO_SPECS, pIO_ITEMS)
  3376. tTree pID;
  3377. tTree pIO_SPECS;
  3378. tTree pIO_ITEMS;
  3379. # endif
  3380. {
  3381.  register tTree yyt;
  3382.  yyALLOC (yyt, Tree_NodeSize [kIO_STMT])
  3383.  yyt->Kind = kIO_STMT;
  3384.  yyt->yyHead.yyMark = 0;
  3385.  yyt->yyHead.yyParent = NoTree;
  3386.  yyt->IO_STMT.ID = pID;
  3387.  yyt->IO_STMT.IO_SPECS = pIO_SPECS;
  3388.  yyt->IO_STMT.IO_ITEMS = pIO_ITEMS;
  3389.  return yyt;
  3390. }
  3391.  
  3392. tTree mGOTO_STMT
  3393. # if defined __STDC__ | defined __cplusplus
  3394. (int pGOTO_LABEL)
  3395. # else
  3396. (pGOTO_LABEL)
  3397. int pGOTO_LABEL;
  3398. # endif
  3399. {
  3400.  register tTree yyt;
  3401.  yyALLOC (yyt, Tree_NodeSize [kGOTO_STMT])
  3402.  yyt->Kind = kGOTO_STMT;
  3403.  yyt->yyHead.yyMark = 0;
  3404.  yyt->yyHead.yyParent = NoTree;
  3405.  yyt->GOTO_STMT.GOTO_LABEL = pGOTO_LABEL;
  3406.  return yyt;
  3407. }
  3408.  
  3409. tTree mASS_GOTO_STMT
  3410. # if defined __STDC__ | defined __cplusplus
  3411. (tTree pGOTO_VAR, tTree pLABELS)
  3412. # else
  3413. (pGOTO_VAR, pLABELS)
  3414. tTree pGOTO_VAR;
  3415. tTree pLABELS;
  3416. # endif
  3417. {
  3418.  register tTree yyt;
  3419.  yyALLOC (yyt, Tree_NodeSize [kASS_GOTO_STMT])
  3420.  yyt->Kind = kASS_GOTO_STMT;
  3421.  yyt->yyHead.yyMark = 0;
  3422.  yyt->yyHead.yyParent = NoTree;
  3423.  yyt->ASS_GOTO_STMT.GOTO_VAR = pGOTO_VAR;
  3424.  yyt->ASS_GOTO_STMT.LABELS = pLABELS;
  3425.  return yyt;
  3426. }
  3427.  
  3428. tTree mCOMP_GOTO_STMT
  3429. # if defined __STDC__ | defined __cplusplus
  3430. (tTree pGOTO_LABELS, tTree pGOTO_EXP)
  3431. # else
  3432. (pGOTO_LABELS, pGOTO_EXP)
  3433. tTree pGOTO_LABELS;
  3434. tTree pGOTO_EXP;
  3435. # endif
  3436. {
  3437.  register tTree yyt;
  3438.  yyALLOC (yyt, Tree_NodeSize [kCOMP_GOTO_STMT])
  3439.  yyt->Kind = kCOMP_GOTO_STMT;
  3440.  yyt->yyHead.yyMark = 0;
  3441.  yyt->yyHead.yyParent = NoTree;
  3442.  yyt->COMP_GOTO_STMT.GOTO_LABELS = pGOTO_LABELS;
  3443.  yyt->COMP_GOTO_STMT.GOTO_EXP = pGOTO_EXP;
  3444.  return yyt;
  3445. }
  3446.  
  3447. tTree mCOMP_IF_STMT
  3448. # if defined __STDC__ | defined __cplusplus
  3449. (tTree pIF_EXP, int pIF_LT_LABEL, int pIF_EQ_LABEL, int pIF_GT_LABEL)
  3450. # else
  3451. (pIF_EXP, pIF_LT_LABEL, pIF_EQ_LABEL, pIF_GT_LABEL)
  3452. tTree pIF_EXP;
  3453. int pIF_LT_LABEL;
  3454. int pIF_EQ_LABEL;
  3455. int pIF_GT_LABEL;
  3456. # endif
  3457. {
  3458.  register tTree yyt;
  3459.  yyALLOC (yyt, Tree_NodeSize [kCOMP_IF_STMT])
  3460.  yyt->Kind = kCOMP_IF_STMT;
  3461.  yyt->yyHead.yyMark = 0;
  3462.  yyt->yyHead.yyParent = NoTree;
  3463.  yyt->COMP_IF_STMT.IF_EXP = pIF_EXP;
  3464.  yyt->COMP_IF_STMT.IF_LT_LABEL = pIF_LT_LABEL;
  3465.  yyt->COMP_IF_STMT.IF_EQ_LABEL = pIF_EQ_LABEL;
  3466.  yyt->COMP_IF_STMT.IF_GT_LABEL = pIF_GT_LABEL;
  3467.  return yyt;
  3468. }
  3469.  
  3470. tTree mRETURN_STMT
  3471. # if defined __STDC__ | defined __cplusplus
  3472. (tTree pRETURN_EXP)
  3473. # else
  3474. (pRETURN_EXP)
  3475. tTree pRETURN_EXP;
  3476. # endif
  3477. {
  3478.  register tTree yyt;
  3479.  yyALLOC (yyt, Tree_NodeSize [kRETURN_STMT])
  3480.  yyt->Kind = kRETURN_STMT;
  3481.  yyt->yyHead.yyMark = 0;
  3482.  yyt->yyHead.yyParent = NoTree;
  3483.  yyt->RETURN_STMT.RETURN_EXP = pRETURN_EXP;
  3484.  return yyt;
  3485. }
  3486.  
  3487. tTree mPAUSE_STMT
  3488. # if defined __STDC__ | defined __cplusplus
  3489. (tTree pPAUSE_CONST)
  3490. # else
  3491. (pPAUSE_CONST)
  3492. tTree pPAUSE_CONST;
  3493. # endif
  3494. {
  3495.  register tTree yyt;
  3496.  yyALLOC (yyt, Tree_NodeSize [kPAUSE_STMT])
  3497.  yyt->Kind = kPAUSE_STMT;
  3498.  yyt->yyHead.yyMark = 0;
  3499.  yyt->yyHead.yyParent = NoTree;
  3500.  yyt->PAUSE_STMT.PAUSE_CONST = pPAUSE_CONST;
  3501.  return yyt;
  3502. }
  3503.  
  3504. tTree mEXIT_STMT
  3505. # if defined __STDC__ | defined __cplusplus
  3506. (tIdent ploopid)
  3507. # else
  3508. (ploopid)
  3509. tIdent ploopid;
  3510. # endif
  3511. {
  3512.  register tTree yyt;
  3513.  yyALLOC (yyt, Tree_NodeSize [kEXIT_STMT])
  3514.  yyt->Kind = kEXIT_STMT;
  3515.  yyt->yyHead.yyMark = 0;
  3516.  yyt->yyHead.yyParent = NoTree;
  3517.  yyt->EXIT_STMT.loopid = ploopid;
  3518.  return yyt;
  3519. }
  3520.  
  3521. tTree mCYCLE_STMT
  3522. # if defined __STDC__ | defined __cplusplus
  3523. (tIdent ploopid)
  3524. # else
  3525. (ploopid)
  3526. tIdent ploopid;
  3527. # endif
  3528. {
  3529.  register tTree yyt;
  3530.  yyALLOC (yyt, Tree_NodeSize [kCYCLE_STMT])
  3531.  yyt->Kind = kCYCLE_STMT;
  3532.  yyt->yyHead.yyMark = 0;
  3533.  yyt->yyHead.yyParent = NoTree;
  3534.  yyt->CYCLE_STMT.loopid = ploopid;
  3535.  return yyt;
  3536. }
  3537.  
  3538. tTree mSTOP_STMT
  3539. # if defined __STDC__ | defined __cplusplus
  3540. (tTree pSTOP_CONST)
  3541. # else
  3542. (pSTOP_CONST)
  3543. tTree pSTOP_CONST;
  3544. # endif
  3545. {
  3546.  register tTree yyt;
  3547.  yyALLOC (yyt, Tree_NodeSize [kSTOP_STMT])
  3548.  yyt->Kind = kSTOP_STMT;
  3549.  yyt->yyHead.yyMark = 0;
  3550.  yyt->yyHead.yyParent = NoTree;
  3551.  yyt->STOP_STMT.STOP_CONST = pSTOP_CONST;
  3552.  return yyt;
  3553. }
  3554.  
  3555. tTree mFORMAT_STMT
  3556. # if defined __STDC__ | defined __cplusplus
  3557. (tTree pFORMAT_PARAMS)
  3558. # else
  3559. (pFORMAT_PARAMS)
  3560. tTree pFORMAT_PARAMS;
  3561. # endif
  3562. {
  3563.  register tTree yyt;
  3564.  yyALLOC (yyt, Tree_NodeSize [kFORMAT_STMT])
  3565.  yyt->Kind = kFORMAT_STMT;
  3566.  yyt->yyHead.yyMark = 0;
  3567.  yyt->yyHead.yyParent = NoTree;
  3568.  yyt->FORMAT_STMT.FORMAT_PARAMS = pFORMAT_PARAMS;
  3569.  return yyt;
  3570. }
  3571.  
  3572. tTree mALLOCATE_STMT
  3573. # if defined __STDC__ | defined __cplusplus
  3574. (tTree pPARAMS, tTree pSTAT)
  3575. # else
  3576. (pPARAMS, pSTAT)
  3577. tTree pPARAMS;
  3578. tTree pSTAT;
  3579. # endif
  3580. {
  3581.  register tTree yyt;
  3582.  yyALLOC (yyt, Tree_NodeSize [kALLOCATE_STMT])
  3583.  yyt->Kind = kALLOCATE_STMT;
  3584.  yyt->yyHead.yyMark = 0;
  3585.  yyt->yyHead.yyParent = NoTree;
  3586.  yyt->ALLOCATE_STMT.PARAMS = pPARAMS;
  3587.  yyt->ALLOCATE_STMT.STAT = pSTAT;
  3588.  return yyt;
  3589. }
  3590.  
  3591. tTree mDEALLOCATE_STMT
  3592. # if defined __STDC__ | defined __cplusplus
  3593. (tTree pPARAMS, tTree pSTAT)
  3594. # else
  3595. (pPARAMS, pSTAT)
  3596. tTree pPARAMS;
  3597. tTree pSTAT;
  3598. # endif
  3599. {
  3600.  register tTree yyt;
  3601.  yyALLOC (yyt, Tree_NodeSize [kDEALLOCATE_STMT])
  3602.  yyt->Kind = kDEALLOCATE_STMT;
  3603.  yyt->yyHead.yyMark = 0;
  3604.  yyt->yyHead.yyParent = NoTree;
  3605.  yyt->DEALLOCATE_STMT.PARAMS = pPARAMS;
  3606.  yyt->DEALLOCATE_STMT.STAT = pSTAT;
  3607.  return yyt;
  3608. }
  3609.  
  3610. tTree mNULLIFY_STMT
  3611. # if defined __STDC__ | defined __cplusplus
  3612. (tTree pPARAMS)
  3613. # else
  3614. (pPARAMS)
  3615. tTree pPARAMS;
  3616. # endif
  3617. {
  3618.  register tTree yyt;
  3619.  yyALLOC (yyt, Tree_NodeSize [kNULLIFY_STMT])
  3620.  yyt->Kind = kNULLIFY_STMT;
  3621.  yyt->yyHead.yyMark = 0;
  3622.  yyt->yyHead.yyParent = NoTree;
  3623.  yyt->NULLIFY_STMT.PARAMS = pPARAMS;
  3624.  return yyt;
  3625. }
  3626.  
  3627. tTree mREDUCE_STMT
  3628. # if defined __STDC__ | defined __cplusplus
  3629. (tTree pRED_FUNC, tTree pRED_PARAMS)
  3630. # else
  3631. (pRED_FUNC, pRED_PARAMS)
  3632. tTree pRED_FUNC;
  3633. tTree pRED_PARAMS;
  3634. # endif
  3635. {
  3636.  register tTree yyt;
  3637.  yyALLOC (yyt, Tree_NodeSize [kREDUCE_STMT])
  3638.  yyt->Kind = kREDUCE_STMT;
  3639.  yyt->yyHead.yyMark = 0;
  3640.  yyt->yyHead.yyParent = NoTree;
  3641.  yyt->REDUCE_STMT.RED_FUNC = pRED_FUNC;
  3642.  yyt->REDUCE_STMT.RED_PARAMS = pRED_PARAMS;
  3643.  return yyt;
  3644. }
  3645.  
  3646. tTree mGLOBAL_STMT
  3647. # if defined __STDC__ | defined __cplusplus
  3648. (tIdent pfunc, tTree pARRAY, tTree pINDEXED_ARRAY, tTree pINDEXES, tTree pMASK)
  3649. # else
  3650. (pfunc, pARRAY, pINDEXED_ARRAY, pINDEXES, pMASK)
  3651. tIdent pfunc;
  3652. tTree pARRAY;
  3653. tTree pINDEXED_ARRAY;
  3654. tTree pINDEXES;
  3655. tTree pMASK;
  3656. # endif
  3657. {
  3658.  register tTree yyt;
  3659.  yyALLOC (yyt, Tree_NodeSize [kGLOBAL_STMT])
  3660.  yyt->Kind = kGLOBAL_STMT;
  3661.  yyt->yyHead.yyMark = 0;
  3662.  yyt->yyHead.yyParent = NoTree;
  3663.  yyt->GLOBAL_STMT.func = pfunc;
  3664.  yyt->GLOBAL_STMT.ARRAY = pARRAY;
  3665.  yyt->GLOBAL_STMT.INDEXED_ARRAY = pINDEXED_ARRAY;
  3666.  yyt->GLOBAL_STMT.INDEXES = pINDEXES;
  3667.  yyt->GLOBAL_STMT.MASK = pMASK;
  3668.  return yyt;
  3669. }
  3670.  
  3671. tTree mALIGN_STMT
  3672. # if defined __STDC__ | defined __cplusplus
  3673. (tTree pALIGNEE, tTree pALIGN_SPEC)
  3674. # else
  3675. (pALIGNEE, pALIGN_SPEC)
  3676. tTree pALIGNEE;
  3677. tTree pALIGN_SPEC;
  3678. # endif
  3679. {
  3680.  register tTree yyt;
  3681.  yyALLOC (yyt, Tree_NodeSize [kALIGN_STMT])
  3682.  yyt->Kind = kALIGN_STMT;
  3683.  yyt->yyHead.yyMark = 0;
  3684.  yyt->yyHead.yyParent = NoTree;
  3685.  yyt->ALIGN_STMT.ALIGNEE = pALIGNEE;
  3686.  yyt->ALIGN_STMT.ALIGN_SPEC = pALIGN_SPEC;
  3687.  return yyt;
  3688. }
  3689.  
  3690. tTree mDISTRIBUTE_STMT
  3691. # if defined __STDC__ | defined __cplusplus
  3692. (tTree pDISTRIBUTEE, tTree pDISTRIBUTION, tIdent ptarget)
  3693. # else
  3694. (pDISTRIBUTEE, pDISTRIBUTION, ptarget)
  3695. tTree pDISTRIBUTEE;
  3696. tTree pDISTRIBUTION;
  3697. tIdent ptarget;
  3698. # endif
  3699. {
  3700.  register tTree yyt;
  3701.  yyALLOC (yyt, Tree_NodeSize [kDISTRIBUTE_STMT])
  3702.  yyt->Kind = kDISTRIBUTE_STMT;
  3703.  yyt->yyHead.yyMark = 0;
  3704.  yyt->yyHead.yyParent = NoTree;
  3705.  yyt->DISTRIBUTE_STMT.DISTRIBUTEE = pDISTRIBUTEE;
  3706.  yyt->DISTRIBUTE_STMT.DISTRIBUTION = pDISTRIBUTION;
  3707.  yyt->DISTRIBUTE_STMT.target = ptarget;
  3708.  return yyt;
  3709. }
  3710.  
  3711. tTree mLABEL_USE_LIST
  3712. # if defined __STDC__ | defined __cplusplus
  3713. ()
  3714. # else
  3715. ()
  3716. # endif
  3717. {
  3718.  register tTree yyt;
  3719.  yyALLOC (yyt, Tree_NodeSize [kLABEL_USE_LIST])
  3720.  yyt->Kind = kLABEL_USE_LIST;
  3721.  yyt->yyHead.yyMark = 0;
  3722.  yyt->yyHead.yyParent = NoTree;
  3723.  return yyt;
  3724. }
  3725.  
  3726. tTree mLABEL_EMPTY
  3727. # if defined __STDC__ | defined __cplusplus
  3728. ()
  3729. # else
  3730. ()
  3731. # endif
  3732. {
  3733.  register tTree yyt;
  3734.  yyALLOC (yyt, Tree_NodeSize [kLABEL_EMPTY])
  3735.  yyt->Kind = kLABEL_EMPTY;
  3736.  yyt->yyHead.yyMark = 0;
  3737.  yyt->yyHead.yyParent = NoTree;
  3738.  return yyt;
  3739. }
  3740.  
  3741. tTree mLABEL_LIST
  3742. # if defined __STDC__ | defined __cplusplus
  3743. (int pElem, tTree pNext)
  3744. # else
  3745. (pElem, pNext)
  3746. int pElem;
  3747. tTree pNext;
  3748. # endif
  3749. {
  3750.  register tTree yyt;
  3751.  yyALLOC (yyt, Tree_NodeSize [kLABEL_LIST])
  3752.  yyt->Kind = kLABEL_LIST;
  3753.  yyt->yyHead.yyMark = 0;
  3754.  yyt->yyHead.yyParent = NoTree;
  3755.  yyt->LABEL_LIST.Elem = pElem;
  3756.  yyt->LABEL_LIST.Next = pNext;
  3757.  return yyt;
  3758. }
  3759.  
  3760. tTree mOP
  3761. # if defined __STDC__ | defined __cplusplus
  3762. ()
  3763. # else
  3764. ()
  3765. # endif
  3766. {
  3767.  register tTree yyt;
  3768.  yyALLOC (yyt, Tree_NodeSize [kOP])
  3769.  yyt->Kind = kOP;
  3770.  yyt->yyHead.yyMark = 0;
  3771.  yyt->yyHead.yyParent = NoTree;
  3772.  return yyt;
  3773. }
  3774.  
  3775. tTree mOP_EQ
  3776. # if defined __STDC__ | defined __cplusplus
  3777. ()
  3778. # else
  3779. ()
  3780. # endif
  3781. {
  3782.  register tTree yyt;
  3783.  yyALLOC (yyt, Tree_NodeSize [kOP_EQ])
  3784.  yyt->Kind = kOP_EQ;
  3785.  yyt->yyHead.yyMark = 0;
  3786.  yyt->yyHead.yyParent = NoTree;
  3787.  return yyt;
  3788. }
  3789.  
  3790. tTree mOP_NE
  3791. # if defined __STDC__ | defined __cplusplus
  3792. ()
  3793. # else
  3794. ()
  3795. # endif
  3796. {
  3797.  register tTree yyt;
  3798.  yyALLOC (yyt, Tree_NodeSize [kOP_NE])
  3799.  yyt->Kind = kOP_NE;
  3800.  yyt->yyHead.yyMark = 0;
  3801.  yyt->yyHead.yyParent = NoTree;
  3802.  return yyt;
  3803. }
  3804.  
  3805. tTree mOP_LT
  3806. # if defined __STDC__ | defined __cplusplus
  3807. ()
  3808. # else
  3809. ()
  3810. # endif
  3811. {
  3812.  register tTree yyt;
  3813.  yyALLOC (yyt, Tree_NodeSize [kOP_LT])
  3814.  yyt->Kind = kOP_LT;
  3815.  yyt->yyHead.yyMark = 0;
  3816.  yyt->yyHead.yyParent = NoTree;
  3817.  return yyt;
  3818. }
  3819.  
  3820. tTree mOP_GT
  3821. # if defined __STDC__ | defined __cplusplus
  3822. ()
  3823. # else
  3824. ()
  3825. # endif
  3826. {
  3827.  register tTree yyt;
  3828.  yyALLOC (yyt, Tree_NodeSize [kOP_GT])
  3829.  yyt->Kind = kOP_GT;
  3830.  yyt->yyHead.yyMark = 0;
  3831.  yyt->yyHead.yyParent = NoTree;
  3832.  return yyt;
  3833. }
  3834.  
  3835. tTree mOP_GE
  3836. # if defined __STDC__ | defined __cplusplus
  3837. ()
  3838. # else
  3839. ()
  3840. # endif
  3841. {
  3842.  register tTree yyt;
  3843.  yyALLOC (yyt, Tree_NodeSize [kOP_GE])
  3844.  yyt->Kind = kOP_GE;
  3845.  yyt->yyHead.yyMark = 0;
  3846.  yyt->yyHead.yyParent = NoTree;
  3847.  return yyt;
  3848. }
  3849.  
  3850. tTree mOP_LE
  3851. # if defined __STDC__ | defined __cplusplus
  3852. ()
  3853. # else
  3854. ()
  3855. # endif
  3856. {
  3857.  register tTree yyt;
  3858.  yyALLOC (yyt, Tree_NodeSize [kOP_LE])
  3859.  yyt->Kind = kOP_LE;
  3860.  yyt->yyHead.yyMark = 0;
  3861.  yyt->yyHead.yyParent = NoTree;
  3862.  return yyt;
  3863. }
  3864.  
  3865. tTree mOP_PLUS
  3866. # if defined __STDC__ | defined __cplusplus
  3867. ()
  3868. # else
  3869. ()
  3870. # endif
  3871. {
  3872.  register tTree yyt;
  3873.  yyALLOC (yyt, Tree_NodeSize [kOP_PLUS])
  3874.  yyt->Kind = kOP_PLUS;
  3875.  yyt->yyHead.yyMark = 0;
  3876.  yyt->yyHead.yyParent = NoTree;
  3877.  return yyt;
  3878. }
  3879.  
  3880. tTree mOP_MINUS
  3881. # if defined __STDC__ | defined __cplusplus
  3882. ()
  3883. # else
  3884. ()
  3885. # endif
  3886. {
  3887.  register tTree yyt;
  3888.  yyALLOC (yyt, Tree_NodeSize [kOP_MINUS])
  3889.  yyt->Kind = kOP_MINUS;
  3890.  yyt->yyHead.yyMark = 0;
  3891.  yyt->yyHead.yyParent = NoTree;
  3892.  return yyt;
  3893. }
  3894.  
  3895. tTree mOP_XOR
  3896. # if defined __STDC__ | defined __cplusplus
  3897. ()
  3898. # else
  3899. ()
  3900. # endif
  3901. {
  3902.  register tTree yyt;
  3903.  yyALLOC (yyt, Tree_NodeSize [kOP_XOR])
  3904.  yyt->Kind = kOP_XOR;
  3905.  yyt->yyHead.yyMark = 0;
  3906.  yyt->yyHead.yyParent = NoTree;
  3907.  return yyt;
  3908. }
  3909.  
  3910. tTree mOP_OR
  3911. # if defined __STDC__ | defined __cplusplus
  3912. ()
  3913. # else
  3914. ()
  3915. # endif
  3916. {
  3917.  register tTree yyt;
  3918.  yyALLOC (yyt, Tree_NodeSize [kOP_OR])
  3919.  yyt->Kind = kOP_OR;
  3920.  yyt->yyHead.yyMark = 0;
  3921.  yyt->yyHead.yyParent = NoTree;
  3922.  return yyt;
  3923. }
  3924.  
  3925. tTree mOP_CONCAT
  3926. # if defined __STDC__ | defined __cplusplus
  3927. ()
  3928. # else
  3929. ()
  3930. # endif
  3931. {
  3932.  register tTree yyt;
  3933.  yyALLOC (yyt, Tree_NodeSize [kOP_CONCAT])
  3934.  yyt->Kind = kOP_CONCAT;
  3935.  yyt->yyHead.yyMark = 0;
  3936.  yyt->yyHead.yyParent = NoTree;
  3937.  return yyt;
  3938. }
  3939.  
  3940. tTree mOP_TIMES
  3941. # if defined __STDC__ | defined __cplusplus
  3942. ()
  3943. # else
  3944. ()
  3945. # endif
  3946. {
  3947.  register tTree yyt;
  3948.  yyALLOC (yyt, Tree_NodeSize [kOP_TIMES])
  3949.  yyt->Kind = kOP_TIMES;
  3950.  yyt->yyHead.yyMark = 0;
  3951.  yyt->yyHead.yyParent = NoTree;
  3952.  return yyt;
  3953. }
  3954.  
  3955. tTree mOP_DIVIDE
  3956. # if defined __STDC__ | defined __cplusplus
  3957. ()
  3958. # else
  3959. ()
  3960. # endif
  3961. {
  3962.  register tTree yyt;
  3963.  yyALLOC (yyt, Tree_NodeSize [kOP_DIVIDE])
  3964.  yyt->Kind = kOP_DIVIDE;
  3965.  yyt->yyHead.yyMark = 0;
  3966.  yyt->yyHead.yyParent = NoTree;
  3967.  return yyt;
  3968. }
  3969.  
  3970. tTree mOP_DIV
  3971. # if defined __STDC__ | defined __cplusplus
  3972. ()
  3973. # else
  3974. ()
  3975. # endif
  3976. {
  3977.  register tTree yyt;
  3978.  yyALLOC (yyt, Tree_NodeSize [kOP_DIV])
  3979.  yyt->Kind = kOP_DIV;
  3980.  yyt->yyHead.yyMark = 0;
  3981.  yyt->yyHead.yyParent = NoTree;
  3982.  return yyt;
  3983. }
  3984.  
  3985. tTree mOP_AND
  3986. # if defined __STDC__ | defined __cplusplus
  3987. ()
  3988. # else
  3989. ()
  3990. # endif
  3991. {
  3992.  register tTree yyt;
  3993.  yyALLOC (yyt, Tree_NodeSize [kOP_AND])
  3994.  yyt->Kind = kOP_AND;
  3995.  yyt->yyHead.yyMark = 0;
  3996.  yyt->yyHead.yyParent = NoTree;
  3997.  return yyt;
  3998. }
  3999.  
  4000. tTree mOP_EQV
  4001. # if defined __STDC__ | defined __cplusplus
  4002. ()
  4003. # else
  4004. ()
  4005. # endif
  4006. {
  4007.  register tTree yyt;
  4008.  yyALLOC (yyt, Tree_NodeSize [kOP_EQV])
  4009.  yyt->Kind = kOP_EQV;
  4010.  yyt->yyHead.yyMark = 0;
  4011.  yyt->yyHead.yyParent = NoTree;
  4012.  return yyt;
  4013. }
  4014.  
  4015. tTree mOP_NEQV
  4016. # if defined __STDC__ | defined __cplusplus
  4017. ()
  4018. # else
  4019. ()
  4020. # endif
  4021. {
  4022.  register tTree yyt;
  4023.  yyALLOC (yyt, Tree_NodeSize [kOP_NEQV])
  4024.  yyt->Kind = kOP_NEQV;
  4025.  yyt->yyHead.yyMark = 0;
  4026.  yyt->yyHead.yyParent = NoTree;
  4027.  return yyt;
  4028. }
  4029.  
  4030. tTree mOP_EXPO
  4031. # if defined __STDC__ | defined __cplusplus
  4032. ()
  4033. # else
  4034. ()
  4035. # endif
  4036. {
  4037.  register tTree yyt;
  4038.  yyALLOC (yyt, Tree_NodeSize [kOP_EXPO])
  4039.  yyt->Kind = kOP_EXPO;
  4040.  yyt->yyHead.yyMark = 0;
  4041.  yyt->yyHead.yyParent = NoTree;
  4042.  return yyt;
  4043. }
  4044.  
  4045. tTree mOP_MOD
  4046. # if defined __STDC__ | defined __cplusplus
  4047. ()
  4048. # else
  4049. ()
  4050. # endif
  4051. {
  4052.  register tTree yyt;
  4053.  yyALLOC (yyt, Tree_NodeSize [kOP_MOD])
  4054.  yyt->Kind = kOP_MOD;
  4055.  yyt->yyHead.yyMark = 0;
  4056.  yyt->yyHead.yyParent = NoTree;
  4057.  return yyt;
  4058. }
  4059.  
  4060. tTree mOP_IN
  4061. # if defined __STDC__ | defined __cplusplus
  4062. ()
  4063. # else
  4064. ()
  4065. # endif
  4066. {
  4067.  register tTree yyt;
  4068.  yyALLOC (yyt, Tree_NodeSize [kOP_IN])
  4069.  yyt->Kind = kOP_IN;
  4070.  yyt->yyHead.yyMark = 0;
  4071.  yyt->yyHead.yyParent = NoTree;
  4072.  return yyt;
  4073. }
  4074.  
  4075. tTree mOP_DEFINED
  4076. # if defined __STDC__ | defined __cplusplus
  4077. (tIdent popname)
  4078. # else
  4079. (popname)
  4080. tIdent popname;
  4081. # endif
  4082. {
  4083.  register tTree yyt;
  4084.  yyALLOC (yyt, Tree_NodeSize [kOP_DEFINED])
  4085.  yyt->Kind = kOP_DEFINED;
  4086.  yyt->yyHead.yyMark = 0;
  4087.  yyt->yyHead.yyParent = NoTree;
  4088.  yyt->OP_DEFINED.opname = popname;
  4089.  return yyt;
  4090. }
  4091.  
  4092. tTree mOP_ASSIGN
  4093. # if defined __STDC__ | defined __cplusplus
  4094. ()
  4095. # else
  4096. ()
  4097. # endif
  4098. {
  4099.  register tTree yyt;
  4100.  yyALLOC (yyt, Tree_NodeSize [kOP_ASSIGN])
  4101.  yyt->Kind = kOP_ASSIGN;
  4102.  yyt->yyHead.yyMark = 0;
  4103.  yyt->yyHead.yyParent = NoTree;
  4104.  return yyt;
  4105. }
  4106.  
  4107. tTree mOP_LEFT
  4108. # if defined __STDC__ | defined __cplusplus
  4109. ()
  4110. # else
  4111. ()
  4112. # endif
  4113. {
  4114.  register tTree yyt;
  4115.  yyALLOC (yyt, Tree_NodeSize [kOP_LEFT])
  4116.  yyt->Kind = kOP_LEFT;
  4117.  yyt->yyHead.yyMark = 0;
  4118.  yyt->yyHead.yyParent = NoTree;
  4119.  return yyt;
  4120. }
  4121.  
  4122. tTree mOP_RIGHT
  4123. # if defined __STDC__ | defined __cplusplus
  4124. ()
  4125. # else
  4126. ()
  4127. # endif
  4128. {
  4129.  register tTree yyt;
  4130.  yyALLOC (yyt, Tree_NodeSize [kOP_RIGHT])
  4131.  yyt->Kind = kOP_RIGHT;
  4132.  yyt->yyHead.yyMark = 0;
  4133.  yyt->yyHead.yyParent = NoTree;
  4134.  return yyt;
  4135. }
  4136.  
  4137. tTree mOP_LIST
  4138. # if defined __STDC__ | defined __cplusplus
  4139. ()
  4140. # else
  4141. ()
  4142. # endif
  4143. {
  4144.  register tTree yyt;
  4145.  yyALLOC (yyt, Tree_NodeSize [kOP_LIST])
  4146.  yyt->Kind = kOP_LIST;
  4147.  yyt->yyHead.yyMark = 0;
  4148.  yyt->yyHead.yyParent = NoTree;
  4149.  return yyt;
  4150. }
  4151.  
  4152. tTree mOP_IOR
  4153. # if defined __STDC__ | defined __cplusplus
  4154. ()
  4155. # else
  4156. ()
  4157. # endif
  4158. {
  4159.  register tTree yyt;
  4160.  yyALLOC (yyt, Tree_NodeSize [kOP_IOR])
  4161.  yyt->Kind = kOP_IOR;
  4162.  yyt->yyHead.yyMark = 0;
  4163.  yyt->yyHead.yyParent = NoTree;
  4164.  return yyt;
  4165. }
  4166.  
  4167. tTree mOP_IXOR
  4168. # if defined __STDC__ | defined __cplusplus
  4169. ()
  4170. # else
  4171. ()
  4172. # endif
  4173. {
  4174.  register tTree yyt;
  4175.  yyALLOC (yyt, Tree_NodeSize [kOP_IXOR])
  4176.  yyt->Kind = kOP_IXOR;
  4177.  yyt->yyHead.yyMark = 0;
  4178.  yyt->yyHead.yyParent = NoTree;
  4179.  return yyt;
  4180. }
  4181.  
  4182. tTree mOP_IAND
  4183. # if defined __STDC__ | defined __cplusplus
  4184. ()
  4185. # else
  4186. ()
  4187. # endif
  4188. {
  4189.  register tTree yyt;
  4190.  yyALLOC (yyt, Tree_NodeSize [kOP_IAND])
  4191.  yyt->Kind = kOP_IAND;
  4192.  yyt->yyHead.yyMark = 0;
  4193.  yyt->yyHead.yyParent = NoTree;
  4194.  return yyt;
  4195. }
  4196.  
  4197. tTree mOP1_NOT
  4198. # if defined __STDC__ | defined __cplusplus
  4199. ()
  4200. # else
  4201. ()
  4202. # endif
  4203. {
  4204.  register tTree yyt;
  4205.  yyALLOC (yyt, Tree_NodeSize [kOP1_NOT])
  4206.  yyt->Kind = kOP1_NOT;
  4207.  yyt->yyHead.yyMark = 0;
  4208.  yyt->yyHead.yyParent = NoTree;
  4209.  return yyt;
  4210. }
  4211.  
  4212. tTree mOP1_SIGN
  4213. # if defined __STDC__ | defined __cplusplus
  4214. ()
  4215. # else
  4216. ()
  4217. # endif
  4218. {
  4219.  register tTree yyt;
  4220.  yyALLOC (yyt, Tree_NodeSize [kOP1_SIGN])
  4221.  yyt->Kind = kOP1_SIGN;
  4222.  yyt->yyHead.yyMark = 0;
  4223.  yyt->yyHead.yyParent = NoTree;
  4224.  return yyt;
  4225. }
  4226.  
  4227. tTree mOP1_INOT
  4228. # if defined __STDC__ | defined __cplusplus
  4229. ()
  4230. # else
  4231. ()
  4232. # endif
  4233. {
  4234.  register tTree yyt;
  4235.  yyALLOC (yyt, Tree_NodeSize [kOP1_INOT])
  4236.  yyt->Kind = kOP1_INOT;
  4237.  yyt->yyHead.yyMark = 0;
  4238.  yyt->yyHead.yyParent = NoTree;
  4239.  return yyt;
  4240. }
  4241.  
  4242. tTree mOP1_SIZE
  4243. # if defined __STDC__ | defined __cplusplus
  4244. ()
  4245. # else
  4246. ()
  4247. # endif
  4248. {
  4249.  register tTree yyt;
  4250.  yyALLOC (yyt, Tree_NodeSize [kOP1_SIZE])
  4251.  yyt->Kind = kOP1_SIZE;
  4252.  yyt->yyHead.yyMark = 0;
  4253.  yyt->yyHead.yyParent = NoTree;
  4254.  return yyt;
  4255. }
  4256.  
  4257. tTree mOP1_DEC
  4258. # if defined __STDC__ | defined __cplusplus
  4259. ()
  4260. # else
  4261. ()
  4262. # endif
  4263. {
  4264.  register tTree yyt;
  4265.  yyALLOC (yyt, Tree_NodeSize [kOP1_DEC])
  4266.  yyt->Kind = kOP1_DEC;
  4267.  yyt->yyHead.yyMark = 0;
  4268.  yyt->yyHead.yyParent = NoTree;
  4269.  return yyt;
  4270. }
  4271.  
  4272. tTree mOP1_INC
  4273. # if defined __STDC__ | defined __cplusplus
  4274. ()
  4275. # else
  4276. ()
  4277. # endif
  4278. {
  4279.  register tTree yyt;
  4280.  yyALLOC (yyt, Tree_NodeSize [kOP1_INC])
  4281.  yyt->Kind = kOP1_INC;
  4282.  yyt->yyHead.yyMark = 0;
  4283.  yyt->yyHead.yyParent = NoTree;
  4284.  return yyt;
  4285. }
  4286.  
  4287. tTree mOP1_ADDRESS
  4288. # if defined __STDC__ | defined __cplusplus
  4289. ()
  4290. # else
  4291. ()
  4292. # endif
  4293. {
  4294.  register tTree yyt;
  4295.  yyALLOC (yyt, Tree_NodeSize [kOP1_ADDRESS])
  4296.  yyt->Kind = kOP1_ADDRESS;
  4297.  yyt->yyHead.yyMark = 0;
  4298.  yyt->yyHead.yyParent = NoTree;
  4299.  return yyt;
  4300. }
  4301.  
  4302. tTree mOP1_DEREF
  4303. # if defined __STDC__ | defined __cplusplus
  4304. ()
  4305. # else
  4306. ()
  4307. # endif
  4308. {
  4309.  register tTree yyt;
  4310.  yyALLOC (yyt, Tree_NodeSize [kOP1_DEREF])
  4311.  yyt->Kind = kOP1_DEREF;
  4312.  yyt->yyHead.yyMark = 0;
  4313.  yyt->yyHead.yyParent = NoTree;
  4314.  return yyt;
  4315. }
  4316.  
  4317. tTree mBT_EXP
  4318. # if defined __STDC__ | defined __cplusplus
  4319. ()
  4320. # else
  4321. ()
  4322. # endif
  4323. {
  4324.  register tTree yyt;
  4325.  yyALLOC (yyt, Tree_NodeSize [kBT_EXP])
  4326.  yyt->Kind = kBT_EXP;
  4327.  yyt->yyHead.yyMark = 0;
  4328.  yyt->yyHead.yyParent = NoTree;
  4329.  return yyt;
  4330. }
  4331.  
  4332. tTree mDUMMY_EXP
  4333. # if defined __STDC__ | defined __cplusplus
  4334. ()
  4335. # else
  4336. ()
  4337. # endif
  4338. {
  4339.  register tTree yyt;
  4340.  yyALLOC (yyt, Tree_NodeSize [kDUMMY_EXP])
  4341.  yyt->Kind = kDUMMY_EXP;
  4342.  yyt->yyHead.yyMark = 0;
  4343.  yyt->yyHead.yyParent = NoTree;
  4344.  return yyt;
  4345. }
  4346.  
  4347. tTree mCONST_EXP
  4348. # if defined __STDC__ | defined __cplusplus
  4349. (tTree pC)
  4350. # else
  4351. (pC)
  4352. tTree pC;
  4353. # endif
  4354. {
  4355.  register tTree yyt;
  4356.  yyALLOC (yyt, Tree_NodeSize [kCONST_EXP])
  4357.  yyt->Kind = kCONST_EXP;
  4358.  yyt->yyHead.yyMark = 0;
  4359.  yyt->yyHead.yyParent = NoTree;
  4360.  yyt->CONST_EXP.C = pC;
  4361.  return yyt;
  4362. }
  4363.  
  4364. tTree mOP_EXP
  4365. # if defined __STDC__ | defined __cplusplus
  4366. (tTree pEXP_OP, tTree pOPND1, tTree pOPND2)
  4367. # else
  4368. (pEXP_OP, pOPND1, pOPND2)
  4369. tTree pEXP_OP;
  4370. tTree pOPND1;
  4371. tTree pOPND2;
  4372. # endif
  4373. {
  4374.  register tTree yyt;
  4375.  yyALLOC (yyt, Tree_NodeSize [kOP_EXP])
  4376.  yyt->Kind = kOP_EXP;
  4377.  yyt->yyHead.yyMark = 0;
  4378.  yyt->yyHead.yyParent = NoTree;
  4379.  yyt->OP_EXP.EXP_OP = pEXP_OP;
  4380.  yyt->OP_EXP.OPND1 = pOPND1;
  4381.  yyt->OP_EXP.OPND2 = pOPND2;
  4382.  return yyt;
  4383. }
  4384.  
  4385. tTree mOP1_EXP
  4386. # if defined __STDC__ | defined __cplusplus
  4387. (tTree pEXP_OP1, tTree pOPND)
  4388. # else
  4389. (pEXP_OP1, pOPND)
  4390. tTree pEXP_OP1;
  4391. tTree pOPND;
  4392. # endif
  4393. {
  4394.  register tTree yyt;
  4395.  yyALLOC (yyt, Tree_NodeSize [kOP1_EXP])
  4396.  yyt->Kind = kOP1_EXP;
  4397.  yyt->yyHead.yyMark = 0;
  4398.  yyt->yyHead.yyParent = NoTree;
  4399.  yyt->OP1_EXP.EXP_OP1 = pEXP_OP1;
  4400.  yyt->OP1_EXP.OPND = pOPND;
  4401.  return yyt;
  4402. }
  4403.  
  4404. tTree mSLICE_EXP
  4405. # if defined __STDC__ | defined __cplusplus
  4406. (tTree pSTART, tTree pSTOP, tTree pINC)
  4407. # else
  4408. (pSTART, pSTOP, pINC)
  4409. tTree pSTART;
  4410. tTree pSTOP;
  4411. tTree pINC;
  4412. # endif
  4413. {
  4414.  register tTree yyt;
  4415.  yyALLOC (yyt, Tree_NodeSize [kSLICE_EXP])
  4416.  yyt->Kind = kSLICE_EXP;
  4417.  yyt->yyHead.yyMark = 0;
  4418.  yyt->yyHead.yyParent = NoTree;
  4419.  yyt->SLICE_EXP.START = pSTART;
  4420.  yyt->SLICE_EXP.STOP = pSTOP;
  4421.  yyt->SLICE_EXP.INC = pINC;
  4422.  return yyt;
  4423. }
  4424.  
  4425. tTree mPOSTFIX_EXP
  4426. # if defined __STDC__ | defined __cplusplus
  4427. (tTree pPOSTFIX_OP, tTree pOPND)
  4428. # else
  4429. (pPOSTFIX_OP, pOPND)
  4430. tTree pPOSTFIX_OP;
  4431. tTree pOPND;
  4432. # endif
  4433. {
  4434.  register tTree yyt;
  4435.  yyALLOC (yyt, Tree_NodeSize [kPOSTFIX_EXP])
  4436.  yyt->Kind = kPOSTFIX_EXP;
  4437.  yyt->yyHead.yyMark = 0;
  4438.  yyt->yyHead.yyParent = NoTree;
  4439.  yyt->POSTFIX_EXP.POSTFIX_OP = pPOSTFIX_OP;
  4440.  yyt->POSTFIX_EXP.OPND = pOPND;
  4441.  return yyt;
  4442. }
  4443.  
  4444. tTree mCALL_EXP
  4445. # if defined __STDC__ | defined __cplusplus
  4446. (tTree pFUNC_ID, tTree pFUNC_PARAMS)
  4447. # else
  4448. (pFUNC_ID, pFUNC_PARAMS)
  4449. tTree pFUNC_ID;
  4450. tTree pFUNC_PARAMS;
  4451. # endif
  4452. {
  4453.  register tTree yyt;
  4454.  yyALLOC (yyt, Tree_NodeSize [kCALL_EXP])
  4455.  yyt->Kind = kCALL_EXP;
  4456.  yyt->yyHead.yyMark = 0;
  4457.  yyt->yyHead.yyParent = NoTree;
  4458.  yyt->CALL_EXP.FUNC_ID = pFUNC_ID;
  4459.  yyt->CALL_EXP.FUNC_PARAMS = pFUNC_PARAMS;
  4460.  return yyt;
  4461. }
  4462.  
  4463. tTree mCAST_EXP
  4464. # if defined __STDC__ | defined __cplusplus
  4465. (tTree pID, tTree pCAST)
  4466. # else
  4467. (pID, pCAST)
  4468. tTree pID;
  4469. tTree pCAST;
  4470. # endif
  4471. {
  4472.  register tTree yyt;
  4473.  yyALLOC (yyt, Tree_NodeSize [kCAST_EXP])
  4474.  yyt->Kind = kCAST_EXP;
  4475.  yyt->yyHead.yyMark = 0;
  4476.  yyt->yyHead.yyParent = NoTree;
  4477.  yyt->CAST_EXP.ID = pID;
  4478.  yyt->CAST_EXP.CAST = pCAST;
  4479.  return yyt;
  4480. }
  4481.  
  4482. tTree mINDEXED_EXP
  4483. # if defined __STDC__ | defined __cplusplus
  4484. (tTree pIND_EXP, tTree pINDEX)
  4485. # else
  4486. (pIND_EXP, pINDEX)
  4487. tTree pIND_EXP;
  4488. tTree pINDEX;
  4489. # endif
  4490. {
  4491.  register tTree yyt;
  4492.  yyALLOC (yyt, Tree_NodeSize [kINDEXED_EXP])
  4493.  yyt->Kind = kINDEXED_EXP;
  4494.  yyt->yyHead.yyMark = 0;
  4495.  yyt->yyHead.yyParent = NoTree;
  4496.  yyt->INDEXED_EXP.IND_EXP = pIND_EXP;
  4497.  yyt->INDEXED_EXP.INDEX = pINDEX;
  4498.  return yyt;
  4499. }
  4500.  
  4501. tTree mSELECTED_EXP
  4502. # if defined __STDC__ | defined __cplusplus
  4503. (tTree pSELEC_EXP, tTree pSELECTOR)
  4504. # else
  4505. (pSELEC_EXP, pSELECTOR)
  4506. tTree pSELEC_EXP;
  4507. tTree pSELECTOR;
  4508. # endif
  4509. {
  4510.  register tTree yyt;
  4511.  yyALLOC (yyt, Tree_NodeSize [kSELECTED_EXP])
  4512.  yyt->Kind = kSELECTED_EXP;
  4513.  yyt->yyHead.yyMark = 0;
  4514.  yyt->yyHead.yyParent = NoTree;
  4515.  yyt->SELECTED_EXP.SELEC_EXP = pSELEC_EXP;
  4516.  yyt->SELECTED_EXP.SELECTOR = pSELECTOR;
  4517.  return yyt;
  4518. }
  4519.  
  4520. tTree mASSIGN_EXP
  4521. # if defined __STDC__ | defined __cplusplus
  4522. (tTree pASSIGN_OP, tTree pLHS, tTree pRHS)
  4523. # else
  4524. (pASSIGN_OP, pLHS, pRHS)
  4525. tTree pASSIGN_OP;
  4526. tTree pLHS;
  4527. tTree pRHS;
  4528. # endif
  4529. {
  4530.  register tTree yyt;
  4531.  yyALLOC (yyt, Tree_NodeSize [kASSIGN_EXP])
  4532.  yyt->Kind = kASSIGN_EXP;
  4533.  yyt->yyHead.yyMark = 0;
  4534.  yyt->yyHead.yyParent = NoTree;
  4535.  yyt->ASSIGN_EXP.ASSIGN_OP = pASSIGN_OP;
  4536.  yyt->ASSIGN_EXP.LHS = pLHS;
  4537.  yyt->ASSIGN_EXP.RHS = pRHS;
  4538.  return yyt;
  4539. }
  4540.  
  4541. tTree mUSED_EXP
  4542. # if defined __STDC__ | defined __cplusplus
  4543. (tTree pVARNAME)
  4544. # else
  4545. (pVARNAME)
  4546. tTree pVARNAME;
  4547. # endif
  4548. {
  4549.  register tTree yyt;
  4550.  yyALLOC (yyt, Tree_NodeSize [kUSED_EXP])
  4551.  yyt->Kind = kUSED_EXP;
  4552.  yyt->yyHead.yyMark = 0;
  4553.  yyt->yyHead.yyParent = NoTree;
  4554.  yyt->USED_EXP.VARNAME = pVARNAME;
  4555.  return yyt;
  4556. }
  4557.  
  4558. tTree mCOND_EXP
  4559. # if defined __STDC__ | defined __cplusplus
  4560. (tTree pCOND, tTree pTRUE_EXP, tTree pFALSE_EXP)
  4561. # else
  4562. (pCOND, pTRUE_EXP, pFALSE_EXP)
  4563. tTree pCOND;
  4564. tTree pTRUE_EXP;
  4565. tTree pFALSE_EXP;
  4566. # endif
  4567. {
  4568.  register tTree yyt;
  4569.  yyALLOC (yyt, Tree_NodeSize [kCOND_EXP])
  4570.  yyt->Kind = kCOND_EXP;
  4571.  yyt->yyHead.yyMark = 0;
  4572.  yyt->yyHead.yyParent = NoTree;
  4573.  yyt->COND_EXP.COND = pCOND;
  4574.  yyt->COND_EXP.TRUE_EXP = pTRUE_EXP;
  4575.  yyt->COND_EXP.FALSE_EXP = pFALSE_EXP;
  4576.  return yyt;
  4577. }
  4578.  
  4579. tTree mVAR_EXP
  4580. # if defined __STDC__ | defined __cplusplus
  4581. (tTree pV)
  4582. # else
  4583. (pV)
  4584. tTree pV;
  4585. # endif
  4586. {
  4587.  register tTree yyt;
  4588.  yyALLOC (yyt, Tree_NodeSize [kVAR_EXP])
  4589.  yyt->Kind = kVAR_EXP;
  4590.  yyt->yyHead.yyMark = 0;
  4591.  yyt->yyHead.yyParent = NoTree;
  4592.  yyt->VAR_EXP.V = pV;
  4593.  return yyt;
  4594. }
  4595.  
  4596. tTree mFUNC_CALL_EXP
  4597. # if defined __STDC__ | defined __cplusplus
  4598. (tTree pFUNC_ID, tTree pFUNC_PARAMS)
  4599. # else
  4600. (pFUNC_ID, pFUNC_PARAMS)
  4601. tTree pFUNC_ID;
  4602. tTree pFUNC_PARAMS;
  4603. # endif
  4604. {
  4605.  register tTree yyt;
  4606.  yyALLOC (yyt, Tree_NodeSize [kFUNC_CALL_EXP])
  4607.  yyt->Kind = kFUNC_CALL_EXP;
  4608.  yyt->yyHead.yyMark = 0;
  4609.  yyt->yyHead.yyParent = NoTree;
  4610.  yyt->FUNC_CALL_EXP.FUNC_ID = pFUNC_ID;
  4611.  yyt->FUNC_CALL_EXP.FUNC_PARAMS = pFUNC_PARAMS;
  4612.  return yyt;
  4613. }
  4614.  
  4615. tTree mNAMED_EXP
  4616. # if defined __STDC__ | defined __cplusplus
  4617. (tIdent pName, tTree pVAL)
  4618. # else
  4619. (pName, pVAL)
  4620. tIdent pName;
  4621. tTree pVAL;
  4622. # endif
  4623. {
  4624.  register tTree yyt;
  4625.  yyALLOC (yyt, Tree_NodeSize [kNAMED_EXP])
  4626.  yyt->Kind = kNAMED_EXP;
  4627.  yyt->yyHead.yyMark = 0;
  4628.  yyt->yyHead.yyParent = NoTree;
  4629.  yyt->NAMED_EXP.Name = pName;
  4630.  yyt->NAMED_EXP.VAL = pVAL;
  4631.  return yyt;
  4632. }
  4633.  
  4634. tTree mDO_EXP
  4635. # if defined __STDC__ | defined __cplusplus
  4636. (tTree pDO_ID, tTree pRANGE, tTree pBODY)
  4637. # else
  4638. (pDO_ID, pRANGE, pBODY)
  4639. tTree pDO_ID;
  4640. tTree pRANGE;
  4641. tTree pBODY;
  4642. # endif
  4643. {
  4644.  register tTree yyt;
  4645.  yyALLOC (yyt, Tree_NodeSize [kDO_EXP])
  4646.  yyt->Kind = kDO_EXP;
  4647.  yyt->yyHead.yyMark = 0;
  4648.  yyt->yyHead.yyParent = NoTree;
  4649.  yyt->DO_EXP.DO_ID = pDO_ID;
  4650.  yyt->DO_EXP.RANGE = pRANGE;
  4651.  yyt->DO_EXP.BODY = pBODY;
  4652.  return yyt;
  4653. }
  4654.  
  4655. tTree mTYPE_EXP
  4656. # if defined __STDC__ | defined __cplusplus
  4657. (tTree pID, tTree pELEMENTS)
  4658. # else
  4659. (pID, pELEMENTS)
  4660. tTree pID;
  4661. tTree pELEMENTS;
  4662. # endif
  4663. {
  4664.  register tTree yyt;
  4665.  yyALLOC (yyt, Tree_NodeSize [kTYPE_EXP])
  4666.  yyt->Kind = kTYPE_EXP;
  4667.  yyt->yyHead.yyMark = 0;
  4668.  yyt->yyHead.yyParent = NoTree;
  4669.  yyt->TYPE_EXP.ID = pID;
  4670.  yyt->TYPE_EXP.ELEMENTS = pELEMENTS;
  4671.  return yyt;
  4672. }
  4673.  
  4674. tTree mARRAY_EXP
  4675. # if defined __STDC__ | defined __cplusplus
  4676. (tTree pELEMENTS)
  4677. # else
  4678. (pELEMENTS)
  4679. tTree pELEMENTS;
  4680. # endif
  4681. {
  4682.  register tTree yyt;
  4683.  yyALLOC (yyt, Tree_NodeSize [kARRAY_EXP])
  4684.  yyt->Kind = kARRAY_EXP;
  4685.  yyt->yyHead.yyMark = 0;
  4686.  yyt->yyHead.yyParent = NoTree;
  4687.  yyt->ARRAY_EXP.ELEMENTS = pELEMENTS;
  4688.  return yyt;
  4689. }
  4690.  
  4691. tTree mBT_EXP_LIST
  4692. # if defined __STDC__ | defined __cplusplus
  4693. ()
  4694. # else
  4695. ()
  4696. # endif
  4697. {
  4698.  register tTree yyt;
  4699.  yyALLOC (yyt, Tree_NodeSize [kBT_EXP_LIST])
  4700.  yyt->Kind = kBT_EXP_LIST;
  4701.  yyt->yyHead.yyMark = 0;
  4702.  yyt->yyHead.yyParent = NoTree;
  4703.  return yyt;
  4704. }
  4705.  
  4706. tTree mBTE_EMPTY
  4707. # if defined __STDC__ | defined __cplusplus
  4708. ()
  4709. # else
  4710. ()
  4711. # endif
  4712. {
  4713.  register tTree yyt;
  4714.  yyALLOC (yyt, Tree_NodeSize [kBTE_EMPTY])
  4715.  yyt->Kind = kBTE_EMPTY;
  4716.  yyt->yyHead.yyMark = 0;
  4717.  yyt->yyHead.yyParent = NoTree;
  4718.  return yyt;
  4719. }
  4720.  
  4721. tTree mBTE_LIST
  4722. # if defined __STDC__ | defined __cplusplus
  4723. (tTree pElem, tTree pNext)
  4724. # else
  4725. (pElem, pNext)
  4726. tTree pElem;
  4727. tTree pNext;
  4728. # endif
  4729. {
  4730.  register tTree yyt;
  4731.  yyALLOC (yyt, Tree_NodeSize [kBTE_LIST])
  4732.  yyt->Kind = kBTE_LIST;
  4733.  yyt->yyHead.yyMark = 0;
  4734.  yyt->yyHead.yyParent = NoTree;
  4735.  yyt->BTE_LIST.Elem = pElem;
  4736.  yyt->BTE_LIST.Next = pNext;
  4737.  return yyt;
  4738. }
  4739.  
  4740. tTree mBT_VAR
  4741. # if defined __STDC__ | defined __cplusplus
  4742. ()
  4743. # else
  4744. ()
  4745. # endif
  4746. {
  4747.  register tTree yyt;
  4748.  yyALLOC (yyt, Tree_NodeSize [kBT_VAR])
  4749.  yyt->Kind = kBT_VAR;
  4750.  yyt->yyHead.yyMark = 0;
  4751.  yyt->yyHead.yyParent = NoTree;
  4752.  return yyt;
  4753. }
  4754.  
  4755. tTree mDUMMY_VAR
  4756. # if defined __STDC__ | defined __cplusplus
  4757. ()
  4758. # else
  4759. ()
  4760. # endif
  4761. {
  4762.  register tTree yyt;
  4763.  yyALLOC (yyt, Tree_NodeSize [kDUMMY_VAR])
  4764.  yyt->Kind = kDUMMY_VAR;
  4765.  yyt->yyHead.yyMark = 0;
  4766.  yyt->yyHead.yyParent = NoTree;
  4767.  return yyt;
  4768. }
  4769.  
  4770. tTree mUSED_VAR
  4771. # if defined __STDC__ | defined __cplusplus
  4772. (tTree pVARNAME)
  4773. # else
  4774. (pVARNAME)
  4775. tTree pVARNAME;
  4776. # endif
  4777. {
  4778.  register tTree yyt;
  4779.  yyALLOC (yyt, Tree_NodeSize [kUSED_VAR])
  4780.  yyt->Kind = kUSED_VAR;
  4781.  yyt->yyHead.yyMark = 0;
  4782.  yyt->yyHead.yyParent = NoTree;
  4783.  yyt->USED_VAR.VARNAME = pVARNAME;
  4784.  return yyt;
  4785. }
  4786.  
  4787. tTree mINDEXED_VAR
  4788. # if defined __STDC__ | defined __cplusplus
  4789. (tTree pIND_VAR, tTree pIND_EXPS)
  4790. # else
  4791. (pIND_VAR, pIND_EXPS)
  4792. tTree pIND_VAR;
  4793. tTree pIND_EXPS;
  4794. # endif
  4795. {
  4796.  register tTree yyt;
  4797.  yyALLOC (yyt, Tree_NodeSize [kINDEXED_VAR])
  4798.  yyt->Kind = kINDEXED_VAR;
  4799.  yyt->yyHead.yyMark = 0;
  4800.  yyt->yyHead.yyParent = NoTree;
  4801.  yyt->INDEXED_VAR.IND_VAR = pIND_VAR;
  4802.  yyt->INDEXED_VAR.IND_EXPS = pIND_EXPS;
  4803.  return yyt;
  4804. }
  4805.  
  4806. tTree mSUBSTRING_VAR
  4807. # if defined __STDC__ | defined __cplusplus
  4808. (tTree pIND_VAR, tTree pIND_EXP)
  4809. # else
  4810. (pIND_VAR, pIND_EXP)
  4811. tTree pIND_VAR;
  4812. tTree pIND_EXP;
  4813. # endif
  4814. {
  4815.  register tTree yyt;
  4816.  yyALLOC (yyt, Tree_NodeSize [kSUBSTRING_VAR])
  4817.  yyt->Kind = kSUBSTRING_VAR;
  4818.  yyt->yyHead.yyMark = 0;
  4819.  yyt->yyHead.yyParent = NoTree;
  4820.  yyt->SUBSTRING_VAR.IND_VAR = pIND_VAR;
  4821.  yyt->SUBSTRING_VAR.IND_EXP = pIND_EXP;
  4822.  return yyt;
  4823. }
  4824.  
  4825. tTree mSELECTED_VAR
  4826. # if defined __STDC__ | defined __cplusplus
  4827. (tTree pSELEC_VAR, tTree pSELECTOR)
  4828. # else
  4829. (pSELEC_VAR, pSELECTOR)
  4830. tTree pSELEC_VAR;
  4831. tTree pSELECTOR;
  4832. # endif
  4833. {
  4834.  register tTree yyt;
  4835.  yyALLOC (yyt, Tree_NodeSize [kSELECTED_VAR])
  4836.  yyt->Kind = kSELECTED_VAR;
  4837.  yyt->yyHead.yyMark = 0;
  4838.  yyt->yyHead.yyParent = NoTree;
  4839.  yyt->SELECTED_VAR.SELEC_VAR = pSELEC_VAR;
  4840.  yyt->SELECTED_VAR.SELECTOR = pSELECTOR;
  4841.  return yyt;
  4842. }
  4843.  
  4844. tTree mLOOP_VAR
  4845. # if defined __STDC__ | defined __cplusplus
  4846. (tTree pLOOP_VARNAME)
  4847. # else
  4848. (pLOOP_VARNAME)
  4849. tTree pLOOP_VARNAME;
  4850. # endif
  4851. {
  4852.  register tTree yyt;
  4853.  yyALLOC (yyt, Tree_NodeSize [kLOOP_VAR])
  4854.  yyt->Kind = kLOOP_VAR;
  4855.  yyt->yyHead.yyMark = 0;
  4856.  yyt->yyHead.yyParent = NoTree;
  4857.  yyt->LOOP_VAR.LOOP_VARNAME = pLOOP_VARNAME;
  4858.  return yyt;
  4859. }
  4860.  
  4861. tTree mADDR
  4862. # if defined __STDC__ | defined __cplusplus
  4863. (tTree pE)
  4864. # else
  4865. (pE)
  4866. tTree pE;
  4867. # endif
  4868. {
  4869.  register tTree yyt;
  4870.  yyALLOC (yyt, Tree_NodeSize [kADDR])
  4871.  yyt->Kind = kADDR;
  4872.  yyt->yyHead.yyMark = 0;
  4873.  yyt->yyHead.yyParent = NoTree;
  4874.  yyt->ADDR.E = pE;
  4875.  return yyt;
  4876. }
  4877.  
  4878. tTree mDO_VAR
  4879. # if defined __STDC__ | defined __cplusplus
  4880. (tTree pDO_ID, tTree pRANGE, tTree pBODY)
  4881. # else
  4882. (pDO_ID, pRANGE, pBODY)
  4883. tTree pDO_ID;
  4884. tTree pRANGE;
  4885. tTree pBODY;
  4886. # endif
  4887. {
  4888.  register tTree yyt;
  4889.  yyALLOC (yyt, Tree_NodeSize [kDO_VAR])
  4890.  yyt->Kind = kDO_VAR;
  4891.  yyt->yyHead.yyMark = 0;
  4892.  yyt->yyHead.yyParent = NoTree;
  4893.  yyt->DO_VAR.DO_ID = pDO_ID;
  4894.  yyt->DO_VAR.RANGE = pRANGE;
  4895.  yyt->DO_VAR.BODY = pBODY;
  4896.  return yyt;
  4897. }
  4898.  
  4899. tTree mBT_VAR_LIST
  4900. # if defined __STDC__ | defined __cplusplus
  4901. ()
  4902. # else
  4903. ()
  4904. # endif
  4905. {
  4906.  register tTree yyt;
  4907.  yyALLOC (yyt, Tree_NodeSize [kBT_VAR_LIST])
  4908.  yyt->Kind = kBT_VAR_LIST;
  4909.  yyt->yyHead.yyMark = 0;
  4910.  yyt->yyHead.yyParent = NoTree;
  4911.  return yyt;
  4912. }
  4913.  
  4914. tTree mBTV_EMPTY
  4915. # if defined __STDC__ | defined __cplusplus
  4916. ()
  4917. # else
  4918. ()
  4919. # endif
  4920. {
  4921.  register tTree yyt;
  4922.  yyALLOC (yyt, Tree_NodeSize [kBTV_EMPTY])
  4923.  yyt->Kind = kBTV_EMPTY;
  4924.  yyt->yyHead.yyMark = 0;
  4925.  yyt->yyHead.yyParent = NoTree;
  4926.  return yyt;
  4927. }
  4928.  
  4929. tTree mBTV_LIST
  4930. # if defined __STDC__ | defined __cplusplus
  4931. (tTree pElem, tTree pNext)
  4932. # else
  4933. (pElem, pNext)
  4934. tTree pElem;
  4935. tTree pNext;
  4936. # endif
  4937. {
  4938.  register tTree yyt;
  4939.  yyALLOC (yyt, Tree_NodeSize [kBTV_LIST])
  4940.  yyt->Kind = kBTV_LIST;
  4941.  yyt->yyHead.yyMark = 0;
  4942.  yyt->yyHead.yyParent = NoTree;
  4943.  yyt->BTV_LIST.Elem = pElem;
  4944.  yyt->BTV_LIST.Next = pNext;
  4945.  return yyt;
  4946. }
  4947.  
  4948. tTree mBT_PARAM
  4949. # if defined __STDC__ | defined __cplusplus
  4950. ()
  4951. # else
  4952. ()
  4953. # endif
  4954. {
  4955.  register tTree yyt;
  4956.  yyALLOC (yyt, Tree_NodeSize [kBT_PARAM])
  4957.  yyt->Kind = kBT_PARAM;
  4958.  yyt->yyHead.yyMark = 0;
  4959.  yyt->yyHead.yyParent = NoTree;
  4960.  return yyt;
  4961. }
  4962.  
  4963. tTree mVAR_PARAM
  4964. # if defined __STDC__ | defined __cplusplus
  4965. (tTree pV)
  4966. # else
  4967. (pV)
  4968. tTree pV;
  4969. # endif
  4970. {
  4971.  register tTree yyt;
  4972.  yyALLOC (yyt, Tree_NodeSize [kVAR_PARAM])
  4973.  yyt->Kind = kVAR_PARAM;
  4974.  yyt->yyHead.yyMark = 0;
  4975.  yyt->yyHead.yyParent = NoTree;
  4976.  yyt->VAR_PARAM.V = pV;
  4977.  return yyt;
  4978. }
  4979.  
  4980. tTree mVALUE_PARAM
  4981. # if defined __STDC__ | defined __cplusplus
  4982. (tTree pE)
  4983. # else
  4984. (pE)
  4985. tTree pE;
  4986. # endif
  4987. {
  4988.  register tTree yyt;
  4989.  yyALLOC (yyt, Tree_NodeSize [kVALUE_PARAM])
  4990.  yyt->Kind = kVALUE_PARAM;
  4991.  yyt->yyHead.yyMark = 0;
  4992.  yyt->yyHead.yyParent = NoTree;
  4993.  yyt->VALUE_PARAM.E = pE;
  4994.  return yyt;
  4995. }
  4996.  
  4997. tTree mNAMED_PARAM
  4998. # if defined __STDC__ | defined __cplusplus
  4999. (tIdent pName, tTree pVAL)
  5000. # else
  5001. (pName, pVAL)
  5002. tIdent pName;
  5003. tTree pVAL;
  5004. # endif
  5005. {
  5006.  register tTree yyt;
  5007.  yyALLOC (yyt, Tree_NodeSize [kNAMED_PARAM])
  5008.  yyt->Kind = kNAMED_PARAM;
  5009.  yyt->yyHead.yyMark = 0;
  5010.  yyt->yyHead.yyParent = NoTree;
  5011.  yyt->NAMED_PARAM.Name = pName;
  5012.  yyt->NAMED_PARAM.VAL = pVAL;
  5013.  return yyt;
  5014. }
  5015.  
  5016. tTree mPROC_PARAM
  5017. # if defined __STDC__ | defined __cplusplus
  5018. (tTree pP)
  5019. # else
  5020. (pP)
  5021. tTree pP;
  5022. # endif
  5023. {
  5024.  register tTree yyt;
  5025.  yyALLOC (yyt, Tree_NodeSize [kPROC_PARAM])
  5026.  yyt->Kind = kPROC_PARAM;
  5027.  yyt->yyHead.yyMark = 0;
  5028.  yyt->yyHead.yyParent = NoTree;
  5029.  yyt->PROC_PARAM.P = pP;
  5030.  return yyt;
  5031. }
  5032.  
  5033. tTree mFUNC_PARAM
  5034. # if defined __STDC__ | defined __cplusplus
  5035. (tTree pF)
  5036. # else
  5037. (pF)
  5038. tTree pF;
  5039. # endif
  5040. {
  5041.  register tTree yyt;
  5042.  yyALLOC (yyt, Tree_NodeSize [kFUNC_PARAM])
  5043.  yyt->Kind = kFUNC_PARAM;
  5044.  yyt->yyHead.yyMark = 0;
  5045.  yyt->yyHead.yyParent = NoTree;
  5046.  yyt->FUNC_PARAM.F = pF;
  5047.  return yyt;
  5048. }
  5049.  
  5050. tTree mFORMAT_PARAM
  5051. # if defined __STDC__ | defined __cplusplus
  5052. (tStringRef pS)
  5053. # else
  5054. (pS)
  5055. tStringRef pS;
  5056. # endif
  5057. {
  5058.  register tTree yyt;
  5059.  yyALLOC (yyt, Tree_NodeSize [kFORMAT_PARAM])
  5060.  yyt->Kind = kFORMAT_PARAM;
  5061.  yyt->yyHead.yyMark = 0;
  5062.  yyt->yyHead.yyParent = NoTree;
  5063.  yyt->FORMAT_PARAM.S = pS;
  5064.  return yyt;
  5065. }
  5066.  
  5067. tTree mRETURN_PARAM
  5068. # if defined __STDC__ | defined __cplusplus
  5069. (int plabel)
  5070. # else
  5071. (plabel)
  5072. int plabel;
  5073. # endif
  5074. {
  5075.  register tTree yyt;
  5076.  yyALLOC (yyt, Tree_NodeSize [kRETURN_PARAM])
  5077.  yyt->Kind = kRETURN_PARAM;
  5078.  yyt->yyHead.yyMark = 0;
  5079.  yyt->yyHead.yyParent = NoTree;
  5080.  yyt->RETURN_PARAM.label = plabel;
  5081.  return yyt;
  5082. }
  5083.  
  5084. tTree mNO_PARAM
  5085. # if defined __STDC__ | defined __cplusplus
  5086. ()
  5087. # else
  5088. ()
  5089. # endif
  5090. {
  5091.  register tTree yyt;
  5092.  yyALLOC (yyt, Tree_NodeSize [kNO_PARAM])
  5093.  yyt->Kind = kNO_PARAM;
  5094.  yyt->yyHead.yyMark = 0;
  5095.  yyt->yyHead.yyParent = NoTree;
  5096.  return yyt;
  5097. }
  5098.  
  5099. tTree mBT_PARAM_LIST
  5100. # if defined __STDC__ | defined __cplusplus
  5101. ()
  5102. # else
  5103. ()
  5104. # endif
  5105. {
  5106.  register tTree yyt;
  5107.  yyALLOC (yyt, Tree_NodeSize [kBT_PARAM_LIST])
  5108.  yyt->Kind = kBT_PARAM_LIST;
  5109.  yyt->yyHead.yyMark = 0;
  5110.  yyt->yyHead.yyParent = NoTree;
  5111.  return yyt;
  5112. }
  5113.  
  5114. tTree mBTP_EMPTY
  5115. # if defined __STDC__ | defined __cplusplus
  5116. ()
  5117. # else
  5118. ()
  5119. # endif
  5120. {
  5121.  register tTree yyt;
  5122.  yyALLOC (yyt, Tree_NodeSize [kBTP_EMPTY])
  5123.  yyt->Kind = kBTP_EMPTY;
  5124.  yyt->yyHead.yyMark = 0;
  5125.  yyt->yyHead.yyParent = NoTree;
  5126.  return yyt;
  5127. }
  5128.  
  5129. tTree mBTP_LIST
  5130. # if defined __STDC__ | defined __cplusplus
  5131. (tTree pElem, tTree pNext)
  5132. # else
  5133. (pElem, pNext)
  5134. tTree pElem;
  5135. tTree pNext;
  5136. # endif
  5137. {
  5138.  register tTree yyt;
  5139.  yyALLOC (yyt, Tree_NodeSize [kBTP_LIST])
  5140.  yyt->Kind = kBTP_LIST;
  5141.  yyt->yyHead.yyMark = 0;
  5142.  yyt->yyHead.yyParent = NoTree;
  5143.  yyt->BTP_LIST.Elem = pElem;
  5144.  yyt->BTP_LIST.Next = pNext;
  5145.  return yyt;
  5146. }
  5147.  
  5148. tTree mCONSTANT
  5149. # if defined __STDC__ | defined __cplusplus
  5150. ()
  5151. # else
  5152. ()
  5153. # endif
  5154. {
  5155.  register tTree yyt;
  5156.  yyALLOC (yyt, Tree_NodeSize [kCONSTANT])
  5157.  yyt->Kind = kCONSTANT;
  5158.  yyt->yyHead.yyMark = 0;
  5159.  yyt->yyHead.yyParent = NoTree;
  5160.  return yyt;
  5161. }
  5162.  
  5163. tTree mBOOL_CONSTANT
  5164. # if defined __STDC__ | defined __cplusplus
  5165. (int pvalue)
  5166. # else
  5167. (pvalue)
  5168. int pvalue;
  5169. # endif
  5170. {
  5171.  register tTree yyt;
  5172.  yyALLOC (yyt, Tree_NodeSize [kBOOL_CONSTANT])
  5173.  yyt->Kind = kBOOL_CONSTANT;
  5174.  yyt->yyHead.yyMark = 0;
  5175.  yyt->yyHead.yyParent = NoTree;
  5176.  yyt->BOOL_CONSTANT.value = pvalue;
  5177.  return yyt;
  5178. }
  5179.  
  5180. tTree mINT_CONSTANT
  5181. # if defined __STDC__ | defined __cplusplus
  5182. (int pvalue)
  5183. # else
  5184. (pvalue)
  5185. int pvalue;
  5186. # endif
  5187. {
  5188.  register tTree yyt;
  5189.  yyALLOC (yyt, Tree_NodeSize [kINT_CONSTANT])
  5190.  yyt->Kind = kINT_CONSTANT;
  5191.  yyt->yyHead.yyMark = 0;
  5192.  yyt->yyHead.yyParent = NoTree;
  5193.  yyt->INT_CONSTANT.value = pvalue;
  5194.  return yyt;
  5195. }
  5196.  
  5197. tTree mREAL_CONSTANT
  5198. # if defined __STDC__ | defined __cplusplus
  5199. (tStringRef pvalue)
  5200. # else
  5201. (pvalue)
  5202. tStringRef pvalue;
  5203. # endif
  5204. {
  5205.  register tTree yyt;
  5206.  yyALLOC (yyt, Tree_NodeSize [kREAL_CONSTANT])
  5207.  yyt->Kind = kREAL_CONSTANT;
  5208.  yyt->yyHead.yyMark = 0;
  5209.  yyt->yyHead.yyParent = NoTree;
  5210.  yyt->REAL_CONSTANT.value = pvalue;
  5211.  return yyt;
  5212. }
  5213.  
  5214. tTree mDREAL_CONSTANT
  5215. # if defined __STDC__ | defined __cplusplus
  5216. (tStringRef pvalue)
  5217. # else
  5218. (pvalue)
  5219. tStringRef pvalue;
  5220. # endif
  5221. {
  5222.  register tTree yyt;
  5223.  yyALLOC (yyt, Tree_NodeSize [kDREAL_CONSTANT])
  5224.  yyt->Kind = kDREAL_CONSTANT;
  5225.  yyt->yyHead.yyMark = 0;
  5226.  yyt->yyHead.yyParent = NoTree;
  5227.  yyt->DREAL_CONSTANT.value = pvalue;
  5228.  return yyt;
  5229. }
  5230.  
  5231. tTree mCHAR_CONSTANT
  5232. # if defined __STDC__ | defined __cplusplus
  5233. (char pvalue)
  5234. # else
  5235. (pvalue)
  5236. char pvalue;
  5237. # endif
  5238. {
  5239.  register tTree yyt;
  5240.  yyALLOC (yyt, Tree_NodeSize [kCHAR_CONSTANT])
  5241.  yyt->Kind = kCHAR_CONSTANT;
  5242.  yyt->yyHead.yyMark = 0;
  5243.  yyt->yyHead.yyParent = NoTree;
  5244.  yyt->CHAR_CONSTANT.value = pvalue;
  5245.  return yyt;
  5246. }
  5247.  
  5248. tTree mSTRING_CONSTANT
  5249. # if defined __STDC__ | defined __cplusplus
  5250. (tStringRef pvalue)
  5251. # else
  5252. (pvalue)
  5253. tStringRef pvalue;
  5254. # endif
  5255. {
  5256.  register tTree yyt;
  5257.  yyALLOC (yyt, Tree_NodeSize [kSTRING_CONSTANT])
  5258.  yyt->Kind = kSTRING_CONSTANT;
  5259.  yyt->yyHead.yyMark = 0;
  5260.  yyt->yyHead.yyParent = NoTree;
  5261.  yyt->STRING_CONSTANT.value = pvalue;
  5262.  return yyt;
  5263. }
  5264.  
  5265. tTree mCOMPLEX_CONSTANT
  5266. # if defined __STDC__ | defined __cplusplus
  5267. (tStringRef prvalue, tStringRef pivalue)
  5268. # else
  5269. (prvalue, pivalue)
  5270. tStringRef prvalue;
  5271. tStringRef pivalue;
  5272. # endif
  5273. {
  5274.  register tTree yyt;
  5275.  yyALLOC (yyt, Tree_NodeSize [kCOMPLEX_CONSTANT])
  5276.  yyt->Kind = kCOMPLEX_CONSTANT;
  5277.  yyt->yyHead.yyMark = 0;
  5278.  yyt->yyHead.yyParent = NoTree;
  5279.  yyt->COMPLEX_CONSTANT.rvalue = prvalue;
  5280.  yyt->COMPLEX_CONSTANT.ivalue = pivalue;
  5281.  return yyt;
  5282. }
  5283.  
  5284. tTree mPROC_OBJ
  5285. # if defined __STDC__ | defined __cplusplus
  5286. (tIdent pIdent)
  5287. # else
  5288. (pIdent)
  5289. tIdent pIdent;
  5290. # endif
  5291. {
  5292.  register tTree yyt;
  5293.  yyALLOC (yyt, Tree_NodeSize [kPROC_OBJ])
  5294.  yyt->Kind = kPROC_OBJ;
  5295.  yyt->yyHead.yyMark = 0;
  5296.  yyt->yyHead.yyParent = NoTree;
  5297.  yyt->PROC_OBJ.Ident = pIdent;
  5298.  begintDefinitions(yyt->PROC_OBJ.Object)
  5299.  return yyt;
  5300. }
  5301.  
  5302. tTree mVAR_OBJ
  5303. # if defined __STDC__ | defined __cplusplus
  5304. (int pPos, tIdent pIdent)
  5305. # else
  5306. (pPos, pIdent)
  5307. int pPos;
  5308. tIdent pIdent;
  5309. # endif
  5310. {
  5311.  register tTree yyt;
  5312.  yyALLOC (yyt, Tree_NodeSize [kVAR_OBJ])
  5313.  yyt->Kind = kVAR_OBJ;
  5314.  yyt->yyHead.yyMark = 0;
  5315.  yyt->yyHead.yyParent = NoTree;
  5316.  yyt->VAR_OBJ.Pos = pPos;
  5317.  yyt->VAR_OBJ.Ident = pIdent;
  5318.  begintDefinitions(yyt->VAR_OBJ.Object)
  5319.  return yyt;
  5320. }
  5321.  
  5322. tTree mTYPE_OBJ
  5323. # if defined __STDC__ | defined __cplusplus
  5324. (tIdent pIdent)
  5325. # else
  5326. (pIdent)
  5327. tIdent pIdent;
  5328. # endif
  5329. {
  5330.  register tTree yyt;
  5331.  yyALLOC (yyt, Tree_NodeSize [kTYPE_OBJ])
  5332.  yyt->Kind = kTYPE_OBJ;
  5333.  yyt->yyHead.yyMark = 0;
  5334.  yyt->yyHead.yyParent = NoTree;
  5335.  yyt->TYPE_OBJ.Ident = pIdent;
  5336.  begintDefinitions(yyt->TYPE_OBJ.Object)
  5337.  return yyt;
  5338. }
  5339.  
  5340. tTree mREC_COMP
  5341. # if defined __STDC__ | defined __cplusplus
  5342. (tIdent pIdent)
  5343. # else
  5344. (pIdent)
  5345. tIdent pIdent;
  5346. # endif
  5347. {
  5348.  register tTree yyt;
  5349.  yyALLOC (yyt, Tree_NodeSize [kREC_COMP])
  5350.  yyt->Kind = kREC_COMP;
  5351.  yyt->yyHead.yyMark = 0;
  5352.  yyt->yyHead.yyParent = NoTree;
  5353.  yyt->REC_COMP.Ident = pIdent;
  5354.  begintDefinitions(yyt->REC_COMP.Object)
  5355.  return yyt;
  5356. }
  5357.  
  5358. typedef tTree * yyPtrtTree;
  5359.  
  5360. static FILE * yyf;
  5361.  
  5362. static void yyMark
  5363. # if defined __STDC__ | defined __cplusplus
  5364.  (register tTree yyt)
  5365. # else
  5366.  (yyt) register tTree yyt;
  5367. # endif
  5368. {
  5369.  for (;;) {
  5370.   if (yyt == NoTree || ++ yyt->yyHead.yyMark > 1) return;
  5371.  
  5372.   switch (yyt->Kind) {
  5373. case kCOMP_UNIT:
  5374. yyt = yyt->COMP_UNIT.COMP_ELEMENTS; break;
  5375. case kBODY_NODE:
  5376. yyMark (yyt->BODY_NODE.DECLS);
  5377. yyMark (yyt->BODY_NODE.STATS);
  5378. yyt = yyt->BODY_NODE.INTERNALS; break;
  5379. case kSTRING_TYPE:
  5380. yyt = yyt->STRING_TYPE.LENGTH; break;
  5381. case kINDEX_TYPE:
  5382. yyMark (yyt->INDEX_TYPE.LOWER);
  5383. yyt = yyt->INDEX_TYPE.UPPER; break;
  5384. case kTYPE_ID:
  5385. yyt = yyt->TYPE_ID.ID; break;
  5386. case kARRAY_TYPE:
  5387. yyMark (yyt->ARRAY_TYPE.ARRAY_INDEX_TYPES);
  5388. yyt = yyt->ARRAY_TYPE.ARRAY_COMP_TYPE; break;
  5389. case kRECORD_TYPE:
  5390. yyt = yyt->RECORD_TYPE.COMPONENTS; break;
  5391. case kUNION_TYPE:
  5392. yyt = yyt->UNION_TYPE.COMPONENTS; break;
  5393. case kENUM_TYPE:
  5394. yyt = yyt->ENUM_TYPE.COMPONENTS; break;
  5395. case kPOINTER_TYPE:
  5396. yyt = yyt->POINTER_TYPE.PTR_COMP; break;
  5397. case kARRAY1_TYPE:
  5398. yyMark (yyt->ARRAY1_TYPE.SIZE);
  5399. yyt = yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE; break;
  5400. case kFUNCTION_TYPE:
  5401. yyMark (yyt->FUNCTION_TYPE.FORMALS);
  5402. yyt = yyt->FUNCTION_TYPE.RESULT_TYPE; break;
  5403. case kTYPE_LIST:
  5404. yyMark (yyt->TYPE_LIST.Elem);
  5405. yyt = yyt->TYPE_LIST.Next; break;
  5406. case kMODULE_DECL:
  5407. yyt = yyt->MODULE_DECL.MODULE_BODY; break;
  5408. case kPROGRAM_DECL:
  5409. yyMark (yyt->PROGRAM_DECL.FORMALS);
  5410. yyt = yyt->PROGRAM_DECL.PROGRAM_BODY; break;
  5411. case kPROC_DECL:
  5412. yyMark (yyt->PROC_DECL.FORMALS);
  5413. yyt = yyt->PROC_DECL.PROC_BODY; break;
  5414. case kFUNC_DECL:
  5415. yyMark (yyt->FUNC_DECL.FORMALS);
  5416. yyMark (yyt->FUNC_DECL.FUNC_BODY);
  5417. yyt = yyt->FUNC_DECL.RESULT_TYPE; break;
  5418. case kBLOCK_DATA_DECL:
  5419. yyt = yyt->BLOCK_DATA_DECL.DATA_BODY; break;
  5420. case kTYPE_DECL:
  5421. yyt = yyt->TYPE_DECL.VAL; break;
  5422. case kENTITY_DECL:
  5423. yyt = yyt->ENTITY_DECL.ATTRIBUTES; break;
  5424. case kVAR_DECL:
  5425. yyt = yyt->VAR_DECL.VAL; break;
  5426. case kCOMMON_DECL:
  5427. yyt = yyt->COMMON_DECL.IDS; break;
  5428. case kNAMELIST_DECL:
  5429. yyt = yyt->NAMELIST_DECL.IDS; break;
  5430. case kTEMPLATE_DECL:
  5431. yyt = yyt->TEMPLATE_DECL.DIMENSIONS; break;
  5432. case kPROCESSORS_DECL:
  5433. yyt = yyt->PROCESSORS_DECL.DIMENSIONS; break;
  5434. case kSTMT_FUNC_DECL:
  5435. yyMark (yyt->STMT_FUNC_DECL.FORMALS);
  5436. yyMark (yyt->STMT_FUNC_DECL.RESULT_TYPE);
  5437. yyt = yyt->STMT_FUNC_DECL.FFUNC_BODY; break;
  5438. case kINTERFACE_DECL:
  5439. yyMark (yyt->INTERFACE_DECL.SPEC);
  5440. yyt = yyt->INTERFACE_DECL.ITEMS; break;
  5441. case kEXT_PROC_DECL:
  5442. yyt = yyt->EXT_PROC_DECL.FORMALS; break;
  5443. case kEXT_FUNC_DECL:
  5444. yyMark (yyt->EXT_FUNC_DECL.FORMALS);
  5445. yyt = yyt->EXT_FUNC_DECL.RESULT_TYPE; break;
  5446. case kVAL_PARAM_DECL:
  5447. yyt = yyt->VAL_PARAM_DECL.VAL; break;
  5448. case kVAR_PARAM_DECL:
  5449. yyt = yyt->VAR_PARAM_DECL.VAL; break;
  5450. case kPROC_PARAM_DECL:
  5451. yyt = yyt->PROC_PARAM_DECL.FORMAL; break;
  5452. case kFUNC_PARAM_DECL:
  5453. yyMark (yyt->FUNC_PARAM_DECL.FORMAL);
  5454. yyt = yyt->FUNC_PARAM_DECL.RESULT_TYPE; break;
  5455. case kIMPLICIT_DECL:
  5456. yyt = yyt->IMPLICIT_DECL.VAL; break;
  5457. case kUSE_DECL:
  5458. yyt = yyt->USE_DECL.RENAMINGS; break;
  5459. case kONLY_USE_DECL:
  5460. yyt = yyt->ONLY_USE_DECL.NAMES; break;
  5461. case kEQV_DECL:
  5462. yyt = yyt->EQV_DECL.VARS; break;
  5463. case kDATA_DECL:
  5464. yyMark (yyt->DATA_DECL.VARS);
  5465. yyt = yyt->DATA_DECL.VALS; break;
  5466. case kDIMENSION_DECL:
  5467. yyt = yyt->DIMENSION_DECL.INDEXES; break;
  5468. case kINIT_DATA_DECL:
  5469. yyt = yyt->INIT_DATA_DECL.VAL; break;
  5470. case kTYPESPEC_DECL:
  5471. yyt = yyt->TYPESPEC_DECL.VAL; break;
  5472. case kPARAMETER_DECL:
  5473. yyt = yyt->PARAMETER_DECL.VAL; break;
  5474. case kDISTRIBUTE_DECL:
  5475. yyt = yyt->DISTRIBUTE_DECL.DISTRIBUTION; break;
  5476. case kALIGN_DECL:
  5477. yyMark (yyt->ALIGN_DECL.ALIGN_SOURCE);
  5478. yyt = yyt->ALIGN_DECL.ALIGN_SPEC; break;
  5479. case kDECL_LIST:
  5480. yyMark (yyt->DECL_LIST.Elem);
  5481. yyt = yyt->DECL_LIST.Next; break;
  5482. case kNODE_DISTRIBUTION:
  5483. yyt = yyt->NODE_DISTRIBUTION.MAPPING; break;
  5484. case kBLOCK_DISTRIBUTION:
  5485. yyt = yyt->BLOCK_DISTRIBUTION.SIZE; break;
  5486. case kCYCLIC_DISTRIBUTION:
  5487. yyt = yyt->CYCLIC_DISTRIBUTION.SIZE; break;
  5488. case kDIST_LIST:
  5489. yyMark (yyt->DIST_LIST.Elem);
  5490. yyt = yyt->DIST_LIST.Next; break;
  5491. case kOP_GENERIC_SPEC:
  5492. yyt = yyt->OP_GENERIC_SPEC.OPERATOR; break;
  5493. case kACF_LIST:
  5494. yyMark (yyt->ACF_LIST.Elem);
  5495. yyt = yyt->ACF_LIST.Next; break;
  5496. case kACF_BASIC:
  5497. yyt = yyt->ACF_BASIC.BASIC_STMT; break;
  5498. case kACF_IF:
  5499. yyMark (yyt->ACF_IF.IF_EXP);
  5500. yyMark (yyt->ACF_IF.THEN_PART);
  5501. yyt = yyt->ACF_IF.ELSE_PART; break;
  5502. case kACF_WHERE:
  5503. yyMark (yyt->ACF_WHERE.WHERE_EXP);
  5504. yyMark (yyt->ACF_WHERE.TRUE_PART);
  5505. yyt = yyt->ACF_WHERE.FALSE_PART; break;
  5506. case kACF_SWITCH:
  5507. yyMark (yyt->ACF_SWITCH.SWITCH_EXP);
  5508. yyt = yyt->ACF_SWITCH.SWITCH_STMT; break;
  5509. case kACF_ALTER:
  5510. yyMark (yyt->ACF_ALTER.ALTER_EXP);
  5511. yyt = yyt->ACF_ALTER.ALTER_STMT; break;
  5512. case kACF_CASE:
  5513. yyMark (yyt->ACF_CASE.CASE_EXP);
  5514. yyMark (yyt->ACF_CASE.CASE_ALTS);
  5515. yyt = yyt->ACF_CASE.CASE_OTHERWISE; break;
  5516. case kACF_WHILE:
  5517. yyMark (yyt->ACF_WHILE.WHILE_EXP);
  5518. yyt = yyt->ACF_WHILE.WHILE_BODY; break;
  5519. case kACF_REPEAT:
  5520. yyMark (yyt->ACF_REPEAT.REPEAT_BODY);
  5521. yyt = yyt->ACF_REPEAT.REPEAT_EXP; break;
  5522. case kACF_WITH:
  5523. yyMark (yyt->ACF_WITH.WITH_VARS);
  5524. yyt = yyt->ACF_WITH.WITH_BODY; break;
  5525. case kACF_LOOP:
  5526. yyt = yyt->ACF_LOOP.LOOP_BODY; break;
  5527. case kACF_DO:
  5528. yyMark (yyt->ACF_DO.DO_ID);
  5529. yyMark (yyt->ACF_DO.DO_RANGE);
  5530. yyt = yyt->ACF_DO.DO_BODY; break;
  5531. case kACF_DOLOCAL:
  5532. yyMark (yyt->ACF_DOLOCAL.DOLOCAL_ID);
  5533. yyMark (yyt->ACF_DOLOCAL.DOLOCAL_RANGE);
  5534. yyt = yyt->ACF_DOLOCAL.DOLOCAL_BODY; break;
  5535. case kACF_DOVEC:
  5536. yyMark (yyt->ACF_DOVEC.DOVEC_ID);
  5537. yyMark (yyt->ACF_DOVEC.DOVEC_RANGE);
  5538. yyt = yyt->ACF_DOVEC.DOVEC_BODY; break;
  5539. case kACF_DOALL:
  5540. yyMark (yyt->ACF_DOALL.DOALL_NEW);
  5541. yyMark (yyt->ACF_DOALL.DOALL_ID);
  5542. yyMark (yyt->ACF_DOALL.DOALL_RANGE);
  5543. yyt = yyt->ACF_DOALL.DOALL_BODY; break;
  5544. case kACF_FORALL:
  5545. yyMark (yyt->ACF_FORALL.FORALL_ID);
  5546. yyMark (yyt->ACF_FORALL.FORALL_RANGE);
  5547. yyt = yyt->ACF_FORALL.FORALL_BODY; break;
  5548. case kACF_ON:
  5549. yyMark (yyt->ACF_ON.ON_VAR);
  5550. yyt = yyt->ACF_ON.ON_STMT; break;
  5551. case kACF_BODY:
  5552. yyt = yyt->ACF_BODY.NEW_BODY; break;
  5553. case kACF_FLOW_GRAPH:
  5554. yyt = yyt->ACF_FLOW_GRAPH.FLOW_NODES; break;
  5555. case kACF_ENTRY:
  5556. yyt = yyt->ACF_ENTRY.ENTRY_DECL; break;
  5557. case kSELECTED_ACF_LIST:
  5558. yyMark (yyt->SELECTED_ACF_LIST.Elem);
  5559. yyt = yyt->SELECTED_ACF_LIST.Next; break;
  5560. case kSELECTED_ACF_NODE:
  5561. yyMark (yyt->SELECTED_ACF_NODE.SELECT_LIST);
  5562. yyt = yyt->SELECTED_ACF_NODE.SELECT_ACFS; break;
  5563. case kEXP_STMT:
  5564. yyt = yyt->EXP_STMT.STMT_EXP; break;
  5565. case kASSIGN_STMT:
  5566. yyMark (yyt->ASSIGN_STMT.ASSIGN_VAR);
  5567. yyt = yyt->ASSIGN_STMT.ASSIGN_EXP; break;
  5568. case kPTR_ASSIGN_STMT:
  5569. yyMark (yyt->PTR_ASSIGN_STMT.ASSIGN_VAR);
  5570. yyt = yyt->PTR_ASSIGN_STMT.ASSIGN_EXP; break;
  5571. case kLABEL_ASSIGN_STMT:
  5572. yyt = yyt->LABEL_ASSIGN_STMT.LABEL_VAR; break;
  5573. case kCALL_STMT:
  5574. yyMark (yyt->CALL_STMT.CALL_ID);
  5575. yyt = yyt->CALL_STMT.CALL_PARAMS; break;
  5576. case kIO_STMT:
  5577. yyMark (yyt->IO_STMT.ID);
  5578. yyMark (yyt->IO_STMT.IO_SPECS);
  5579. yyt = yyt->IO_STMT.IO_ITEMS; break;
  5580. case kASS_GOTO_STMT:
  5581. yyMark (yyt->ASS_GOTO_STMT.GOTO_VAR);
  5582. yyt = yyt->ASS_GOTO_STMT.LABELS; break;
  5583. case kCOMP_GOTO_STMT:
  5584. yyMark (yyt->COMP_GOTO_STMT.GOTO_LABELS);
  5585. yyt = yyt->COMP_GOTO_STMT.GOTO_EXP; break;
  5586. case kCOMP_IF_STMT:
  5587. yyt = yyt->COMP_IF_STMT.IF_EXP; break;
  5588. case kRETURN_STMT:
  5589. yyt = yyt->RETURN_STMT.RETURN_EXP; break;
  5590. case kPAUSE_STMT:
  5591. yyt = yyt->PAUSE_STMT.PAUSE_CONST; break;
  5592. case kSTOP_STMT:
  5593. yyt = yyt->STOP_STMT.STOP_CONST; break;
  5594. case kFORMAT_STMT:
  5595. yyt = yyt->FORMAT_STMT.FORMAT_PARAMS; break;
  5596. case kALLOCATE_STMT:
  5597. yyMark (yyt->ALLOCATE_STMT.PARAMS);
  5598. yyt = yyt->ALLOCATE_STMT.STAT; break;
  5599. case kDEALLOCATE_STMT:
  5600. yyMark (yyt->DEALLOCATE_STMT.PARAMS);
  5601. yyt = yyt->DEALLOCATE_STMT.STAT; break;
  5602. case kNULLIFY_STMT:
  5603. yyt = yyt->NULLIFY_STMT.PARAMS; break;
  5604. case kREDUCE_STMT:
  5605. yyMark (yyt->REDUCE_STMT.RED_FUNC);
  5606. yyt = yyt->REDUCE_STMT.RED_PARAMS; break;
  5607. case kGLOBAL_STMT:
  5608. yyMark (yyt->GLOBAL_STMT.ARRAY);
  5609. yyMark (yyt->GLOBAL_STMT.INDEXED_ARRAY);
  5610. yyMark (yyt->GLOBAL_STMT.INDEXES);
  5611. yyt = yyt->GLOBAL_STMT.MASK; break;
  5612. case kALIGN_STMT:
  5613. yyMark (yyt->ALIGN_STMT.ALIGNEE);
  5614. yyt = yyt->ALIGN_STMT.ALIGN_SPEC; break;
  5615. case kDISTRIBUTE_STMT:
  5616. yyMark (yyt->DISTRIBUTE_STMT.DISTRIBUTEE);
  5617. yyt = yyt->DISTRIBUTE_STMT.DISTRIBUTION; break;
  5618. case kLABEL_LIST:
  5619. yyt = yyt->LABEL_LIST.Next; break;
  5620. case kCONST_EXP:
  5621. yyt = yyt->CONST_EXP.C; break;
  5622. case kOP_EXP:
  5623. yyMark (yyt->OP_EXP.EXP_OP);
  5624. yyMark (yyt->OP_EXP.OPND1);
  5625. yyt = yyt->OP_EXP.OPND2; break;
  5626. case kOP1_EXP:
  5627. yyMark (yyt->OP1_EXP.EXP_OP1);
  5628. yyt = yyt->OP1_EXP.OPND; break;
  5629. case kSLICE_EXP:
  5630. yyMark (yyt->SLICE_EXP.START);
  5631. yyMark (yyt->SLICE_EXP.STOP);
  5632. yyt = yyt->SLICE_EXP.INC; break;
  5633. case kPOSTFIX_EXP:
  5634. yyMark (yyt->POSTFIX_EXP.POSTFIX_OP);
  5635. yyt = yyt->POSTFIX_EXP.OPND; break;
  5636. case kCALL_EXP:
  5637. yyMark (yyt->CALL_EXP.FUNC_ID);
  5638. yyt = yyt->CALL_EXP.FUNC_PARAMS; break;
  5639. case kCAST_EXP:
  5640. yyMark (yyt->CAST_EXP.ID);
  5641. yyt = yyt->CAST_EXP.CAST; break;
  5642. case kINDEXED_EXP:
  5643. yyMark (yyt->INDEXED_EXP.IND_EXP);
  5644. yyt = yyt->INDEXED_EXP.INDEX; break;
  5645. case kSELECTED_EXP:
  5646. yyMark (yyt->SELECTED_EXP.SELEC_EXP);
  5647. yyt = yyt->SELECTED_EXP.SELECTOR; break;
  5648. case kASSIGN_EXP:
  5649. yyMark (yyt->ASSIGN_EXP.ASSIGN_OP);
  5650. yyMark (yyt->ASSIGN_EXP.LHS);
  5651. yyt = yyt->ASSIGN_EXP.RHS; break;
  5652. case kUSED_EXP:
  5653. yyt = yyt->USED_EXP.VARNAME; break;
  5654. case kCOND_EXP:
  5655. yyMark (yyt->COND_EXP.COND);
  5656. yyMark (yyt->COND_EXP.TRUE_EXP);
  5657. yyt = yyt->COND_EXP.FALSE_EXP; break;
  5658. case kVAR_EXP:
  5659. yyt = yyt->VAR_EXP.V; break;
  5660. case kFUNC_CALL_EXP:
  5661. yyMark (yyt->FUNC_CALL_EXP.FUNC_ID);
  5662. yyt = yyt->FUNC_CALL_EXP.FUNC_PARAMS; break;
  5663. case kNAMED_EXP:
  5664. yyt = yyt->NAMED_EXP.VAL; break;
  5665. case kDO_EXP:
  5666. yyMark (yyt->DO_EXP.DO_ID);
  5667. yyMark (yyt->DO_EXP.RANGE);
  5668. yyt = yyt->DO_EXP.BODY; break;
  5669. case kTYPE_EXP:
  5670. yyMark (yyt->TYPE_EXP.ID);
  5671. yyt = yyt->TYPE_EXP.ELEMENTS; break;
  5672. case kARRAY_EXP:
  5673. yyt = yyt->ARRAY_EXP.ELEMENTS; break;
  5674. case kBTE_LIST:
  5675. yyMark (yyt->BTE_LIST.Elem);
  5676. yyt = yyt->BTE_LIST.Next; break;
  5677. case kUSED_VAR:
  5678. yyt = yyt->USED_VAR.VARNAME; break;
  5679. case kINDEXED_VAR:
  5680. yyMark (yyt->INDEXED_VAR.IND_VAR);
  5681. yyt = yyt->INDEXED_VAR.IND_EXPS; break;
  5682. case kSUBSTRING_VAR:
  5683. yyMark (yyt->SUBSTRING_VAR.IND_VAR);
  5684. yyt = yyt->SUBSTRING_VAR.IND_EXP; break;
  5685. case kSELECTED_VAR:
  5686. yyMark (yyt->SELECTED_VAR.SELEC_VAR);
  5687. yyt = yyt->SELECTED_VAR.SELECTOR; break;
  5688. case kLOOP_VAR:
  5689. yyt = yyt->LOOP_VAR.LOOP_VARNAME; break;
  5690. case kADDR:
  5691. yyt = yyt->ADDR.E; break;
  5692. case kDO_VAR:
  5693. yyMark (yyt->DO_VAR.DO_ID);
  5694. yyMark (yyt->DO_VAR.RANGE);
  5695. yyt = yyt->DO_VAR.BODY; break;
  5696. case kBTV_LIST:
  5697. yyMark (yyt->BTV_LIST.Elem);
  5698. yyt = yyt->BTV_LIST.Next; break;
  5699. case kVAR_PARAM:
  5700. yyt = yyt->VAR_PARAM.V; break;
  5701. case kVALUE_PARAM:
  5702. yyt = yyt->VALUE_PARAM.E; break;
  5703. case kNAMED_PARAM:
  5704. yyt = yyt->NAMED_PARAM.VAL; break;
  5705. case kPROC_PARAM:
  5706. yyt = yyt->PROC_PARAM.P; break;
  5707. case kFUNC_PARAM:
  5708. yyt = yyt->FUNC_PARAM.F; break;
  5709. case kBTP_LIST:
  5710. yyMark (yyt->BTP_LIST.Elem);
  5711. yyt = yyt->BTP_LIST.Next; break;
  5712.   default: return;
  5713.   }
  5714.  }
  5715. }
  5716.  
  5717. # define yyInitTreeStoreSize 32
  5718. # define yyMapToTree(yyLabel) yyTreeStorePtr [yyLabel]
  5719.  
  5720. static unsigned long yyTreeStoreSize = yyInitTreeStoreSize;
  5721. static tTree yyTreeStore [yyInitTreeStoreSize];
  5722. static tTree * yyTreeStorePtr = yyTreeStore;
  5723. static int yyLabelCount;
  5724. static short yyRecursionLevel = 0;
  5725. extern void exit ();
  5726.  
  5727. static Tree_tLabel yyMapToLabel
  5728. # if defined __STDC__ | defined __cplusplus
  5729.  (tTree yyt)
  5730. # else
  5731.  (yyt) tTree yyt;
  5732. # endif
  5733. {
  5734.  register int yyi;
  5735.  for (yyi = 1; yyi <= yyLabelCount; yyi ++) if (yyTreeStorePtr [yyi] == yyt) return yyi;
  5736.  if (++ yyLabelCount == yyTreeStoreSize)
  5737.   ExtendArray ((char * *) & yyTreeStorePtr, & yyTreeStoreSize, sizeof (tTree));
  5738.  yyTreeStorePtr [yyLabelCount] = yyt;
  5739.  return yyLabelCount;
  5740. }
  5741.  
  5742. static void yyWriteTree ();
  5743.  
  5744. static void yyWriteNl () { (void) putc ('\n', yyf); }
  5745.  
  5746. static void yyWriteSelector
  5747. # if defined __STDC__ | defined __cplusplus
  5748.  (char * yys)
  5749. # else
  5750.  (yys) char * yys;
  5751. # endif
  5752. {
  5753.  register int yyi = 16 - strlen (yys);
  5754.  (void) fputs (yys, yyf);
  5755.  while (yyi -- > 0) (void) putc (' ', yyf);
  5756.  (void) fputs (" = ", yyf);
  5757. }
  5758.  
  5759. static void yyWriteHex
  5760. # if defined __STDC__ | defined __cplusplus
  5761.  (unsigned char * yyx, int yysize)
  5762. # else
  5763.  (yyx, yysize) unsigned char * yyx; int yysize;
  5764. # endif
  5765. { register int yyi; for (yyi = 0; yyi < yysize; yyi ++) (void) fprintf (yyf, "%02x ", yyx [yyi]); }
  5766.  
  5767. static void yyWriteAdr
  5768. # if defined __STDC__ | defined __cplusplus
  5769.  (tTree yyt)
  5770. # else
  5771.  (yyt) tTree yyt;
  5772. # endif
  5773. {
  5774.  if (yyt == NoTree) (void) fputs ("NoTree", yyf);
  5775.  else yyWriteHex ((unsigned char *) & yyt, sizeof (yyt));
  5776.  yyWriteNl ();
  5777. }
  5778.  
  5779. static void yWriteNodeCOMP_UNIT
  5780. # if defined __STDC__ | defined __cplusplus
  5781.  (tTree yyt)
  5782. # else
  5783.  (yyt) tTree yyt;
  5784. # endif
  5785. {
  5786.  yyWriteSelector ("COMP_ELEMENTS"); yyWriteAdr (yyt->COMP_UNIT.COMP_ELEMENTS);
  5787. }
  5788.  
  5789. static void yWriteNodeBODY_NODE
  5790. # if defined __STDC__ | defined __cplusplus
  5791.  (tTree yyt)
  5792. # else
  5793.  (yyt) tTree yyt;
  5794. # endif
  5795. {
  5796.  yyWriteSelector ("DECLS"); yyWriteAdr (yyt->BODY_NODE.DECLS);
  5797.  yyWriteSelector ("STATS"); yyWriteAdr (yyt->BODY_NODE.STATS);
  5798.  yyWriteSelector ("INTERNALS"); yyWriteAdr (yyt->BODY_NODE.INTERNALS);
  5799. }
  5800.  
  5801. static void yWriteNodeINTEGER_TYPE
  5802. # if defined __STDC__ | defined __cplusplus
  5803.  (tTree yyt)
  5804. # else
  5805.  (yyt) tTree yyt;
  5806. # endif
  5807. {
  5808.  yyWriteSelector ("size"); writeint (yyt->INTEGER_TYPE.size) yyWriteNl ();
  5809. }
  5810.  
  5811. static void yWriteNodeCARDINAL_TYPE
  5812. # if defined __STDC__ | defined __cplusplus
  5813.  (tTree yyt)
  5814. # else
  5815.  (yyt) tTree yyt;
  5816. # endif
  5817. {
  5818.  yyWriteSelector ("size"); writeint (yyt->CARDINAL_TYPE.size) yyWriteNl ();
  5819. }
  5820.  
  5821. static void yWriteNodeREAL_TYPE
  5822. # if defined __STDC__ | defined __cplusplus
  5823.  (tTree yyt)
  5824. # else
  5825.  (yyt) tTree yyt;
  5826. # endif
  5827. {
  5828.  yyWriteSelector ("size"); writeint (yyt->REAL_TYPE.size) yyWriteNl ();
  5829. }
  5830.  
  5831. static void yWriteNodeBOOLEAN_TYPE
  5832. # if defined __STDC__ | defined __cplusplus
  5833.  (tTree yyt)
  5834. # else
  5835.  (yyt) tTree yyt;
  5836. # endif
  5837. {
  5838.  yyWriteSelector ("size"); writeint (yyt->BOOLEAN_TYPE.size) yyWriteNl ();
  5839. }
  5840.  
  5841. static void yWriteNodeCOMPLEX_TYPE
  5842. # if defined __STDC__ | defined __cplusplus
  5843.  (tTree yyt)
  5844. # else
  5845.  (yyt) tTree yyt;
  5846. # endif
  5847. {
  5848.  yyWriteSelector ("size"); writeint (yyt->COMPLEX_TYPE.size) yyWriteNl ();
  5849. }
  5850.  
  5851. static void yWriteNodeSTRING_TYPE
  5852. # if defined __STDC__ | defined __cplusplus
  5853.  (tTree yyt)
  5854. # else
  5855.  (yyt) tTree yyt;
  5856. # endif
  5857. {
  5858.  yyWriteSelector ("LENGTH"); yyWriteAdr (yyt->STRING_TYPE.LENGTH);
  5859. }
  5860.  
  5861. static void yWriteNodeINDEX_TYPE
  5862. # if defined __STDC__ | defined __cplusplus
  5863.  (tTree yyt)
  5864. # else
  5865.  (yyt) tTree yyt;
  5866. # endif
  5867. {
  5868.  yyWriteSelector ("LOWER"); yyWriteAdr (yyt->INDEX_TYPE.LOWER);
  5869.  yyWriteSelector ("UPPER"); yyWriteAdr (yyt->INDEX_TYPE.UPPER);
  5870.  yyWriteSelector ("left_overlap"); writeint (yyt->INDEX_TYPE.left_overlap) yyWriteNl ();
  5871.  yyWriteSelector ("right_overlap"); writeint (yyt->INDEX_TYPE.right_overlap) yyWriteNl ();
  5872. }
  5873.  
  5874. static void yWriteNodeTYPE_ID
  5875. # if defined __STDC__ | defined __cplusplus
  5876.  (tTree yyt)
  5877. # else
  5878.  (yyt) tTree yyt;
  5879. # endif
  5880. {
  5881.  yyWriteSelector ("ID"); yyWriteAdr (yyt->TYPE_ID.ID);
  5882. }
  5883.  
  5884. static void yWriteNodeARRAY_TYPE
  5885. # if defined __STDC__ | defined __cplusplus
  5886.  (tTree yyt)
  5887. # else
  5888.  (yyt) tTree yyt;
  5889. # endif
  5890. {
  5891.  yyWriteSelector ("ARRAY_INDEX_TYPES"); yyWriteAdr (yyt->ARRAY_TYPE.ARRAY_INDEX_TYPES);
  5892.  yyWriteSelector ("ARRAY_COMP_TYPE"); yyWriteAdr (yyt->ARRAY_TYPE.ARRAY_COMP_TYPE);
  5893. }
  5894.  
  5895. static void yWriteNodeRECORD_TYPE
  5896. # if defined __STDC__ | defined __cplusplus
  5897.  (tTree yyt)
  5898. # else
  5899.  (yyt) tTree yyt;
  5900. # endif
  5901. {
  5902.  yyWriteSelector ("Name"); writetIdent (yyt->RECORD_TYPE.Name) yyWriteNl ();
  5903.  yyWriteSelector ("COMPONENTS"); yyWriteAdr (yyt->RECORD_TYPE.COMPONENTS);
  5904. }
  5905.  
  5906. static void yWriteNodeUNION_TYPE
  5907. # if defined __STDC__ | defined __cplusplus
  5908.  (tTree yyt)
  5909. # else
  5910.  (yyt) tTree yyt;
  5911. # endif
  5912. {
  5913.  yyWriteSelector ("Name"); writetIdent (yyt->UNION_TYPE.Name) yyWriteNl ();
  5914.  yyWriteSelector ("COMPONENTS"); yyWriteAdr (yyt->UNION_TYPE.COMPONENTS);
  5915. }
  5916.  
  5917. static void yWriteNodeENUM_TYPE
  5918. # if defined __STDC__ | defined __cplusplus
  5919.  (tTree yyt)
  5920. # else
  5921.  (yyt) tTree yyt;
  5922. # endif
  5923. {
  5924.  yyWriteSelector ("Name"); writetIdent (yyt->ENUM_TYPE.Name) yyWriteNl ();
  5925.  yyWriteSelector ("COMPONENTS"); yyWriteAdr (yyt->ENUM_TYPE.COMPONENTS);
  5926. }
  5927.  
  5928. static void yWriteNodeDYNAMIC
  5929. # if defined __STDC__ | defined __cplusplus
  5930.  (tTree yyt)
  5931. # else
  5932.  (yyt) tTree yyt;
  5933. # endif
  5934. {
  5935.  yyWriteSelector ("Shape"); writetTree (yyt->DYNAMIC.Shape) yyWriteNl ();
  5936.  yyWriteSelector ("left_overlap"); writeint (yyt->DYNAMIC.left_overlap) yyWriteNl ();
  5937.  yyWriteSelector ("right_overlap"); writeint (yyt->DYNAMIC.right_overlap) yyWriteNl ();
  5938. }
  5939.  
  5940. static void yWriteNodePOINTER_TYPE
  5941. # if defined __STDC__ | defined __cplusplus
  5942.  (tTree yyt)
  5943. # else
  5944.  (yyt) tTree yyt;
  5945. # endif
  5946. {
  5947.  yyWriteSelector ("PTR_COMP"); yyWriteAdr (yyt->POINTER_TYPE.PTR_COMP);
  5948. }
  5949.  
  5950. static void yWriteNodeARRAY1_TYPE
  5951. # if defined __STDC__ | defined __cplusplus
  5952.  (tTree yyt)
  5953. # else
  5954.  (yyt) tTree yyt;
  5955. # endif
  5956. {
  5957.  yyWriteSelector ("SIZE"); yyWriteAdr (yyt->ARRAY1_TYPE.SIZE);
  5958.  yyWriteSelector ("ARRAY1_COMP_TYPE"); yyWriteAdr (yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE);
  5959. }
  5960.  
  5961. static void yWriteNodeFUNCTION_TYPE
  5962. # if defined __STDC__ | defined __cplusplus
  5963.  (tTree yyt)
  5964. # else
  5965.  (yyt) tTree yyt;
  5966. # endif
  5967. {
  5968.  yyWriteSelector ("FORMALS"); yyWriteAdr (yyt->FUNCTION_TYPE.FORMALS);
  5969.  yyWriteSelector ("RESULT_TYPE"); yyWriteAdr (yyt->FUNCTION_TYPE.RESULT_TYPE);
  5970. }
  5971.  
  5972. static void yWriteNodeTYPE_LIST
  5973. # if defined __STDC__ | defined __cplusplus
  5974.  (tTree yyt)
  5975. # else
  5976.  (yyt) tTree yyt;
  5977. # endif
  5978. {
  5979.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->TYPE_LIST.Elem);
  5980.  yyWriteSelector ("Next"); yyWriteAdr (yyt->TYPE_LIST.Next);
  5981. }
  5982.  
  5983. static void yWriteNodeDECL_NODE
  5984. # if defined __STDC__ | defined __cplusplus
  5985.  (tTree yyt)
  5986. # else
  5987.  (yyt) tTree yyt;
  5988. # endif
  5989. {
  5990.  yyWriteSelector ("Name"); writetIdent (yyt->DECL_NODE.Name) yyWriteNl ();
  5991.  yyWriteSelector ("Pos"); writeint (yyt->DECL_NODE.Pos) yyWriteNl ();
  5992. }
  5993.  
  5994. static void yWriteNodeMODULE_DECL
  5995. # if defined __STDC__ | defined __cplusplus
  5996.  (tTree yyt)
  5997. # else
  5998.  (yyt) tTree yyt;
  5999. # endif
  6000. {
  6001.  yWriteNodeDECL_NODE (yyt); 
  6002.  yyWriteSelector ("MODULE_BODY"); yyWriteAdr (yyt->MODULE_DECL.MODULE_BODY);
  6003. }
  6004.  
  6005. static void yWriteNodePROGRAM_DECL
  6006. # if defined __STDC__ | defined __cplusplus
  6007.  (tTree yyt)
  6008. # else
  6009.  (yyt) tTree yyt;
  6010. # endif
  6011. {
  6012.  yWriteNodeDECL_NODE (yyt); 
  6013.  yyWriteSelector ("FORMALS"); yyWriteAdr (yyt->PROGRAM_DECL.FORMALS);
  6014.  yyWriteSelector ("PROGRAM_BODY"); yyWriteAdr (yyt->PROGRAM_DECL.PROGRAM_BODY);
  6015. }
  6016.  
  6017. static void yWriteNodePROC_DECL
  6018. # if defined __STDC__ | defined __cplusplus
  6019.  (tTree yyt)
  6020. # else
  6021.  (yyt) tTree yyt;
  6022. # endif
  6023. {
  6024.  yWriteNodeDECL_NODE (yyt); 
  6025.  yyWriteSelector ("FORMALS"); yyWriteAdr (yyt->PROC_DECL.FORMALS);
  6026.  yyWriteSelector ("PROC_BODY"); yyWriteAdr (yyt->PROC_DECL.PROC_BODY);
  6027.  yyWriteSelector ("IsRecursive"); writebool (yyt->PROC_DECL.IsRecursive) yyWriteNl ();
  6028.  yyWriteSelector ("IsPure"); writebool (yyt->PROC_DECL.IsPure) yyWriteNl ();
  6029.  yyWriteSelector ("HPFExtrinsic"); writeint (yyt->PROC_DECL.HPFExtrinsic) yyWriteNl ();
  6030. }
  6031.  
  6032. static void yWriteNodeFUNC_DECL
  6033. # if defined __STDC__ | defined __cplusplus
  6034.  (tTree yyt)
  6035. # else
  6036.  (yyt) tTree yyt;
  6037. # endif
  6038. {
  6039.  yWriteNodeDECL_NODE (yyt); 
  6040.  yyWriteSelector ("FORMALS"); yyWriteAdr (yyt->FUNC_DECL.FORMALS);
  6041.  yyWriteSelector ("FUNC_BODY"); yyWriteAdr (yyt->FUNC_DECL.FUNC_BODY);
  6042.  yyWriteSelector ("RESULT_TYPE"); yyWriteAdr (yyt->FUNC_DECL.RESULT_TYPE);
  6043.  yyWriteSelector ("RESULT_ID"); writetIdent (yyt->FUNC_DECL.RESULT_ID) yyWriteNl ();
  6044.  yyWriteSelector ("IsRecursive"); writebool (yyt->FUNC_DECL.IsRecursive) yyWriteNl ();
  6045.  yyWriteSelector ("IsPure"); writebool (yyt->FUNC_DECL.IsPure) yyWriteNl ();
  6046.  yyWriteSelector ("HPFExtrinsic"); writeint (yyt->FUNC_DECL.HPFExtrinsic) yyWriteNl ();
  6047. }
  6048.  
  6049. static void yWriteNodeBLOCK_DATA_DECL
  6050. # if defined __STDC__ | defined __cplusplus
  6051.  (tTree yyt)
  6052. # else
  6053.  (yyt) tTree yyt;
  6054. # endif
  6055. {
  6056.  yWriteNodeDECL_NODE (yyt); 
  6057.  yyWriteSelector ("DATA_BODY"); yyWriteAdr (yyt->BLOCK_DATA_DECL.DATA_BODY);
  6058. }
  6059.  
  6060. static void yWriteNodeTYPE_DECL
  6061. # if defined __STDC__ | defined __cplusplus
  6062.  (tTree yyt)
  6063. # else
  6064.  (yyt) tTree yyt;
  6065. # endif
  6066. {
  6067.  yWriteNodeDECL_NODE (yyt); 
  6068.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->TYPE_DECL.VAL);
  6069. }
  6070.  
  6071. static void yWriteNodeNAME_DECL
  6072. # if defined __STDC__ | defined __cplusplus
  6073.  (tTree yyt)
  6074. # else
  6075.  (yyt) tTree yyt;
  6076. # endif
  6077. {
  6078.  yWriteNodeDECL_NODE (yyt); 
  6079. }
  6080.  
  6081. static void yWriteNodeRENAME_DECL
  6082. # if defined __STDC__ | defined __cplusplus
  6083.  (tTree yyt)
  6084. # else
  6085.  (yyt) tTree yyt;
  6086. # endif
  6087. {
  6088.  yWriteNodeDECL_NODE (yyt); 
  6089.  yyWriteSelector ("oldname"); writetIdent (yyt->RENAME_DECL.oldname) yyWriteNl ();
  6090. }
  6091.  
  6092. static void yWriteNodeENTITY_DECL
  6093. # if defined __STDC__ | defined __cplusplus
  6094.  (tTree yyt)
  6095. # else
  6096.  (yyt) tTree yyt;
  6097. # endif
  6098. {
  6099.  yWriteNodeDECL_NODE (yyt); 
  6100.  yyWriteSelector ("ATTRIBUTES"); yyWriteAdr (yyt->ENTITY_DECL.ATTRIBUTES);
  6101. }
  6102.  
  6103. static void yWriteNodeVAR_DECL
  6104. # if defined __STDC__ | defined __cplusplus
  6105.  (tTree yyt)
  6106. # else
  6107.  (yyt) tTree yyt;
  6108. # endif
  6109. {
  6110.  yWriteNodeDECL_NODE (yyt); 
  6111.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->VAR_DECL.VAL);
  6112. }
  6113.  
  6114. static void yWriteNodeCOMMON_DECL
  6115. # if defined __STDC__ | defined __cplusplus
  6116.  (tTree yyt)
  6117. # else
  6118.  (yyt) tTree yyt;
  6119. # endif
  6120. {
  6121.  yWriteNodeDECL_NODE (yyt); 
  6122.  yyWriteSelector ("IDS"); yyWriteAdr (yyt->COMMON_DECL.IDS);
  6123. }
  6124.  
  6125. static void yWriteNodeNAMELIST_DECL
  6126. # if defined __STDC__ | defined __cplusplus
  6127.  (tTree yyt)
  6128. # else
  6129.  (yyt) tTree yyt;
  6130. # endif
  6131. {
  6132.  yWriteNodeDECL_NODE (yyt); 
  6133.  yyWriteSelector ("IDS"); yyWriteAdr (yyt->NAMELIST_DECL.IDS);
  6134. }
  6135.  
  6136. static void yWriteNodeTEMPLATE_DECL
  6137. # if defined __STDC__ | defined __cplusplus
  6138.  (tTree yyt)
  6139. # else
  6140.  (yyt) tTree yyt;
  6141. # endif
  6142. {
  6143.  yWriteNodeDECL_NODE (yyt); 
  6144.  yyWriteSelector ("DIMENSIONS"); yyWriteAdr (yyt->TEMPLATE_DECL.DIMENSIONS);
  6145. }
  6146.  
  6147. static void yWriteNodePROCESSORS_DECL
  6148. # if defined __STDC__ | defined __cplusplus
  6149.  (tTree yyt)
  6150. # else
  6151.  (yyt) tTree yyt;
  6152. # endif
  6153. {
  6154.  yWriteNodeDECL_NODE (yyt); 
  6155.  yyWriteSelector ("DIMENSIONS"); yyWriteAdr (yyt->PROCESSORS_DECL.DIMENSIONS);
  6156. }
  6157.  
  6158. static void yWriteNodeINHERIT_DECL
  6159. # if defined __STDC__ | defined __cplusplus
  6160.  (tTree yyt)
  6161. # else
  6162.  (yyt) tTree yyt;
  6163. # endif
  6164. {
  6165.  yWriteNodeDECL_NODE (yyt); 
  6166. }
  6167.  
  6168. static void yWriteNodeSTMT_FUNC_DECL
  6169. # if defined __STDC__ | defined __cplusplus
  6170.  (tTree yyt)
  6171. # else
  6172.  (yyt) tTree yyt;
  6173. # endif
  6174. {
  6175.  yWriteNodeDECL_NODE (yyt); 
  6176.  yyWriteSelector ("FORMALS"); yyWriteAdr (yyt->STMT_FUNC_DECL.FORMALS);
  6177.  yyWriteSelector ("RESULT_TYPE"); yyWriteAdr (yyt->STMT_FUNC_DECL.RESULT_TYPE);
  6178.  yyWriteSelector ("FFUNC_BODY"); yyWriteAdr (yyt->STMT_FUNC_DECL.FFUNC_BODY);
  6179. }
  6180.  
  6181. static void yWriteNodeINTERFACE_DECL
  6182. # if defined __STDC__ | defined __cplusplus
  6183.  (tTree yyt)
  6184. # else
  6185.  (yyt) tTree yyt;
  6186. # endif
  6187. {
  6188.  yWriteNodeDECL_NODE (yyt); 
  6189.  yyWriteSelector ("SPEC"); yyWriteAdr (yyt->INTERFACE_DECL.SPEC);
  6190.  yyWriteSelector ("ITEMS"); yyWriteAdr (yyt->INTERFACE_DECL.ITEMS);
  6191. }
  6192.  
  6193. static void yWriteNodeEXT_PROC_DECL
  6194. # if defined __STDC__ | defined __cplusplus
  6195.  (tTree yyt)
  6196. # else
  6197.  (yyt) tTree yyt;
  6198. # endif
  6199. {
  6200.  yWriteNodeDECL_NODE (yyt); 
  6201.  yyWriteSelector ("FORMALS"); yyWriteAdr (yyt->EXT_PROC_DECL.FORMALS);
  6202. }
  6203.  
  6204. static void yWriteNodeEXT_FUNC_DECL
  6205. # if defined __STDC__ | defined __cplusplus
  6206.  (tTree yyt)
  6207. # else
  6208.  (yyt) tTree yyt;
  6209. # endif
  6210. {
  6211.  yWriteNodeDECL_NODE (yyt); 
  6212.  yyWriteSelector ("FORMALS"); yyWriteAdr (yyt->EXT_FUNC_DECL.FORMALS);
  6213.  yyWriteSelector ("RESULT_TYPE"); yyWriteAdr (yyt->EXT_FUNC_DECL.RESULT_TYPE);
  6214. }
  6215.  
  6216. static void yWriteNodeVAL_PARAM_DECL
  6217. # if defined __STDC__ | defined __cplusplus
  6218.  (tTree yyt)
  6219. # else
  6220.  (yyt) tTree yyt;
  6221. # endif
  6222. {
  6223.  yWriteNodeDECL_NODE (yyt); 
  6224.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->VAL_PARAM_DECL.VAL);
  6225. }
  6226.  
  6227. static void yWriteNodeVAR_PARAM_DECL
  6228. # if defined __STDC__ | defined __cplusplus
  6229.  (tTree yyt)
  6230. # else
  6231.  (yyt) tTree yyt;
  6232. # endif
  6233. {
  6234.  yWriteNodeDECL_NODE (yyt); 
  6235.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->VAR_PARAM_DECL.VAL);
  6236. }
  6237.  
  6238. static void yWriteNodePROC_PARAM_DECL
  6239. # if defined __STDC__ | defined __cplusplus
  6240.  (tTree yyt)
  6241. # else
  6242.  (yyt) tTree yyt;
  6243. # endif
  6244. {
  6245.  yWriteNodeDECL_NODE (yyt); 
  6246.  yyWriteSelector ("FORMAL"); yyWriteAdr (yyt->PROC_PARAM_DECL.FORMAL);
  6247. }
  6248.  
  6249. static void yWriteNodeFUNC_PARAM_DECL
  6250. # if defined __STDC__ | defined __cplusplus
  6251.  (tTree yyt)
  6252. # else
  6253.  (yyt) tTree yyt;
  6254. # endif
  6255. {
  6256.  yWriteNodeDECL_NODE (yyt); 
  6257.  yyWriteSelector ("FORMAL"); yyWriteAdr (yyt->FUNC_PARAM_DECL.FORMAL);
  6258.  yyWriteSelector ("RESULT_TYPE"); yyWriteAdr (yyt->FUNC_PARAM_DECL.RESULT_TYPE);
  6259. }
  6260.  
  6261. static void yWriteNodeELIPSIS_PARAM_DECL
  6262. # if defined __STDC__ | defined __cplusplus
  6263.  (tTree yyt)
  6264. # else
  6265.  (yyt) tTree yyt;
  6266. # endif
  6267. {
  6268.  yWriteNodeDECL_NODE (yyt); 
  6269. }
  6270.  
  6271. static void yWriteNodeRET_PARAM_DECL
  6272. # if defined __STDC__ | defined __cplusplus
  6273.  (tTree yyt)
  6274. # else
  6275.  (yyt) tTree yyt;
  6276. # endif
  6277. {
  6278.  yWriteNodeDECL_NODE (yyt); 
  6279. }
  6280.  
  6281. static void yWriteNodeIMPLICIT_DECL
  6282. # if defined __STDC__ | defined __cplusplus
  6283.  (tTree yyt)
  6284. # else
  6285.  (yyt) tTree yyt;
  6286. # endif
  6287. {
  6288.  yWriteNodeDECL_NODE (yyt); 
  6289.  yyWriteSelector ("first"); writetIdent (yyt->IMPLICIT_DECL.first) yyWriteNl ();
  6290.  yyWriteSelector ("last"); writetIdent (yyt->IMPLICIT_DECL.last) yyWriteNl ();
  6291.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->IMPLICIT_DECL.VAL);
  6292. }
  6293.  
  6294. static void yWriteNodeUSE_DECL
  6295. # if defined __STDC__ | defined __cplusplus
  6296.  (tTree yyt)
  6297. # else
  6298.  (yyt) tTree yyt;
  6299. # endif
  6300. {
  6301.  yWriteNodeDECL_NODE (yyt); 
  6302.  yyWriteSelector ("use"); writetIdent (yyt->USE_DECL.use) yyWriteNl ();
  6303.  yyWriteSelector ("RENAMINGS"); yyWriteAdr (yyt->USE_DECL.RENAMINGS);
  6304. }
  6305.  
  6306. static void yWriteNodeONLY_USE_DECL
  6307. # if defined __STDC__ | defined __cplusplus
  6308.  (tTree yyt)
  6309. # else
  6310.  (yyt) tTree yyt;
  6311. # endif
  6312. {
  6313.  yWriteNodeDECL_NODE (yyt); 
  6314.  yyWriteSelector ("use"); writetIdent (yyt->ONLY_USE_DECL.use) yyWriteNl ();
  6315.  yyWriteSelector ("NAMES"); yyWriteAdr (yyt->ONLY_USE_DECL.NAMES);
  6316. }
  6317.  
  6318. static void yWriteNodeEQV_DECL
  6319. # if defined __STDC__ | defined __cplusplus
  6320.  (tTree yyt)
  6321. # else
  6322.  (yyt) tTree yyt;
  6323. # endif
  6324. {
  6325.  yWriteNodeDECL_NODE (yyt); 
  6326.  yyWriteSelector ("VARS"); yyWriteAdr (yyt->EQV_DECL.VARS);
  6327. }
  6328.  
  6329. static void yWriteNodeDATA_DECL
  6330. # if defined __STDC__ | defined __cplusplus
  6331.  (tTree yyt)
  6332. # else
  6333.  (yyt) tTree yyt;
  6334. # endif
  6335. {
  6336.  yWriteNodeDECL_NODE (yyt); 
  6337.  yyWriteSelector ("VARS"); yyWriteAdr (yyt->DATA_DECL.VARS);
  6338.  yyWriteSelector ("VALS"); yyWriteAdr (yyt->DATA_DECL.VALS);
  6339. }
  6340.  
  6341. static void yWriteNodeDIMENSION_DECL
  6342. # if defined __STDC__ | defined __cplusplus
  6343.  (tTree yyt)
  6344. # else
  6345.  (yyt) tTree yyt;
  6346. # endif
  6347. {
  6348.  yWriteNodeDECL_NODE (yyt); 
  6349.  yyWriteSelector ("INDEXES"); yyWriteAdr (yyt->DIMENSION_DECL.INDEXES);
  6350. }
  6351.  
  6352. static void yWriteNodeINIT_DATA_DECL
  6353. # if defined __STDC__ | defined __cplusplus
  6354.  (tTree yyt)
  6355. # else
  6356.  (yyt) tTree yyt;
  6357. # endif
  6358. {
  6359.  yWriteNodeDECL_NODE (yyt); 
  6360.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->INIT_DATA_DECL.VAL);
  6361. }
  6362.  
  6363. static void yWriteNodeTYPESPEC_DECL
  6364. # if defined __STDC__ | defined __cplusplus
  6365.  (tTree yyt)
  6366. # else
  6367.  (yyt) tTree yyt;
  6368. # endif
  6369. {
  6370.  yWriteNodeDECL_NODE (yyt); 
  6371.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->TYPESPEC_DECL.VAL);
  6372. }
  6373.  
  6374. static void yWriteNodeALLOCATABLE_DECL
  6375. # if defined __STDC__ | defined __cplusplus
  6376.  (tTree yyt)
  6377. # else
  6378.  (yyt) tTree yyt;
  6379. # endif
  6380. {
  6381.  yWriteNodeDECL_NODE (yyt); 
  6382. }
  6383.  
  6384. static void yWriteNodeEXTERNAL_DECL
  6385. # if defined __STDC__ | defined __cplusplus
  6386.  (tTree yyt)
  6387. # else
  6388.  (yyt) tTree yyt;
  6389. # endif
  6390. {
  6391.  yWriteNodeDECL_NODE (yyt); 
  6392. }
  6393.  
  6394. static void yWriteNodeINTENT_DECL
  6395. # if defined __STDC__ | defined __cplusplus
  6396.  (tTree yyt)
  6397. # else
  6398.  (yyt) tTree yyt;
  6399. # endif
  6400. {
  6401.  yWriteNodeDECL_NODE (yyt); 
  6402.  yyWriteSelector ("intent"); writeint (yyt->INTENT_DECL.intent) yyWriteNl ();
  6403. }
  6404.  
  6405. static void yWriteNodeINTRINSIC_DECL
  6406. # if defined __STDC__ | defined __cplusplus
  6407.  (tTree yyt)
  6408. # else
  6409.  (yyt) tTree yyt;
  6410. # endif
  6411. {
  6412.  yWriteNodeDECL_NODE (yyt); 
  6413. }
  6414.  
  6415. static void yWriteNodeOPTIONAL_DECL
  6416. # if defined __STDC__ | defined __cplusplus
  6417.  (tTree yyt)
  6418. # else
  6419.  (yyt) tTree yyt;
  6420. # endif
  6421. {
  6422.  yWriteNodeDECL_NODE (yyt); 
  6423. }
  6424.  
  6425. static void yWriteNodePOINTER_DECL
  6426. # if defined __STDC__ | defined __cplusplus
  6427.  (tTree yyt)
  6428. # else
  6429.  (yyt) tTree yyt;
  6430. # endif
  6431. {
  6432.  yWriteNodeDECL_NODE (yyt); 
  6433. }
  6434.  
  6435. static void yWriteNodeSAVE_DECL
  6436. # if defined __STDC__ | defined __cplusplus
  6437.  (tTree yyt)
  6438. # else
  6439.  (yyt) tTree yyt;
  6440. # endif
  6441. {
  6442.  yWriteNodeDECL_NODE (yyt); 
  6443. }
  6444.  
  6445. static void yWriteNodeTARGET_DECL
  6446. # if defined __STDC__ | defined __cplusplus
  6447.  (tTree yyt)
  6448. # else
  6449.  (yyt) tTree yyt;
  6450. # endif
  6451. {
  6452.  yWriteNodeDECL_NODE (yyt); 
  6453. }
  6454.  
  6455. static void yWriteNodePARAMETER_DECL
  6456. # if defined __STDC__ | defined __cplusplus
  6457.  (tTree yyt)
  6458. # else
  6459.  (yyt) tTree yyt;
  6460. # endif
  6461. {
  6462.  yWriteNodeDECL_NODE (yyt); 
  6463.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->PARAMETER_DECL.VAL);
  6464. }
  6465.  
  6466. static void yWriteNodePUBLIC_DECL
  6467. # if defined __STDC__ | defined __cplusplus
  6468.  (tTree yyt)
  6469. # else
  6470.  (yyt) tTree yyt;
  6471. # endif
  6472. {
  6473.  yWriteNodeDECL_NODE (yyt); 
  6474. }
  6475.  
  6476. static void yWriteNodePRIVATE_DECL
  6477. # if defined __STDC__ | defined __cplusplus
  6478.  (tTree yyt)
  6479. # else
  6480.  (yyt) tTree yyt;
  6481. # endif
  6482. {
  6483.  yWriteNodeDECL_NODE (yyt); 
  6484. }
  6485.  
  6486. static void yWriteNodeDISTRIBUTE_DECL
  6487. # if defined __STDC__ | defined __cplusplus
  6488.  (tTree yyt)
  6489. # else
  6490.  (yyt) tTree yyt;
  6491. # endif
  6492. {
  6493.  yWriteNodeDECL_NODE (yyt); 
  6494.  yyWriteSelector ("DISTRIBUTION"); yyWriteAdr (yyt->DISTRIBUTE_DECL.DISTRIBUTION);
  6495.  yyWriteSelector ("target"); writetIdent (yyt->DISTRIBUTE_DECL.target) yyWriteNl ();
  6496. }
  6497.  
  6498. static void yWriteNodeALIGN_DECL
  6499. # if defined __STDC__ | defined __cplusplus
  6500.  (tTree yyt)
  6501. # else
  6502.  (yyt) tTree yyt;
  6503. # endif
  6504. {
  6505.  yWriteNodeDECL_NODE (yyt); 
  6506.  yyWriteSelector ("ALIGN_SOURCE"); yyWriteAdr (yyt->ALIGN_DECL.ALIGN_SOURCE);
  6507.  yyWriteSelector ("ALIGN_SPEC"); yyWriteAdr (yyt->ALIGN_DECL.ALIGN_SPEC);
  6508. }
  6509.  
  6510. static void yWriteNodeDYNAMIC_DECL
  6511. # if defined __STDC__ | defined __cplusplus
  6512.  (tTree yyt)
  6513. # else
  6514.  (yyt) tTree yyt;
  6515. # endif
  6516. {
  6517.  yWriteNodeDECL_NODE (yyt); 
  6518. }
  6519.  
  6520. static void yWriteNodeSEQUENCE_DECL
  6521. # if defined __STDC__ | defined __cplusplus
  6522.  (tTree yyt)
  6523. # else
  6524.  (yyt) tTree yyt;
  6525. # endif
  6526. {
  6527.  yWriteNodeDECL_NODE (yyt); 
  6528. }
  6529.  
  6530. static void yWriteNodeNOSEQUENCE_DECL
  6531. # if defined __STDC__ | defined __cplusplus
  6532.  (tTree yyt)
  6533. # else
  6534.  (yyt) tTree yyt;
  6535. # endif
  6536. {
  6537.  yWriteNodeDECL_NODE (yyt); 
  6538. }
  6539.  
  6540. static void yWriteNodeDECL_LIST
  6541. # if defined __STDC__ | defined __cplusplus
  6542.  (tTree yyt)
  6543. # else
  6544.  (yyt) tTree yyt;
  6545. # endif
  6546. {
  6547.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->DECL_LIST.Elem);
  6548.  yyWriteSelector ("Next"); yyWriteAdr (yyt->DECL_LIST.Next);
  6549. }
  6550.  
  6551. static void yWriteNodeNODE_DISTRIBUTION
  6552. # if defined __STDC__ | defined __cplusplus
  6553.  (tTree yyt)
  6554. # else
  6555.  (yyt) tTree yyt;
  6556. # endif
  6557. {
  6558.  yyWriteSelector ("MAPPING"); yyWriteAdr (yyt->NODE_DISTRIBUTION.MAPPING);
  6559. }
  6560.  
  6561. static void yWriteNodeBLOCK_DISTRIBUTION
  6562. # if defined __STDC__ | defined __cplusplus
  6563.  (tTree yyt)
  6564. # else
  6565.  (yyt) tTree yyt;
  6566. # endif
  6567. {
  6568.  yyWriteSelector ("SIZE"); yyWriteAdr (yyt->BLOCK_DISTRIBUTION.SIZE);
  6569. }
  6570.  
  6571. static void yWriteNodeCYCLIC_DISTRIBUTION
  6572. # if defined __STDC__ | defined __cplusplus
  6573.  (tTree yyt)
  6574. # else
  6575.  (yyt) tTree yyt;
  6576. # endif
  6577. {
  6578.  yyWriteSelector ("SIZE"); yyWriteAdr (yyt->CYCLIC_DISTRIBUTION.SIZE);
  6579. }
  6580.  
  6581. static void yWriteNodeDIST_LIST
  6582. # if defined __STDC__ | defined __cplusplus
  6583.  (tTree yyt)
  6584. # else
  6585.  (yyt) tTree yyt;
  6586. # endif
  6587. {
  6588.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->DIST_LIST.Elem);
  6589.  yyWriteSelector ("Next"); yyWriteAdr (yyt->DIST_LIST.Next);
  6590. }
  6591.  
  6592. static void yWriteNodeID_GENERIC_SPEC
  6593. # if defined __STDC__ | defined __cplusplus
  6594.  (tTree yyt)
  6595. # else
  6596.  (yyt) tTree yyt;
  6597. # endif
  6598. {
  6599.  yyWriteSelector ("name"); writetIdent (yyt->ID_GENERIC_SPEC.name) yyWriteNl ();
  6600. }
  6601.  
  6602. static void yWriteNodeOP_GENERIC_SPEC
  6603. # if defined __STDC__ | defined __cplusplus
  6604.  (tTree yyt)
  6605. # else
  6606.  (yyt) tTree yyt;
  6607. # endif
  6608. {
  6609.  yyWriteSelector ("OPERATOR"); yyWriteAdr (yyt->OP_GENERIC_SPEC.OPERATOR);
  6610. }
  6611.  
  6612. static void yWriteNodeACF_LIST
  6613. # if defined __STDC__ | defined __cplusplus
  6614.  (tTree yyt)
  6615. # else
  6616.  (yyt) tTree yyt;
  6617. # endif
  6618. {
  6619.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->ACF_LIST.Elem);
  6620.  yyWriteSelector ("Next"); yyWriteAdr (yyt->ACF_LIST.Next);
  6621. }
  6622.  
  6623. static void yWriteNodeACF_NODE
  6624. # if defined __STDC__ | defined __cplusplus
  6625.  (tTree yyt)
  6626. # else
  6627.  (yyt) tTree yyt;
  6628. # endif
  6629. {
  6630.  yyWriteSelector ("Label"); writeint (yyt->ACF_NODE.Label) yyWriteNl ();
  6631.  yyWriteSelector ("Line"); writeint (yyt->ACF_NODE.Line) yyWriteNl ();
  6632. }
  6633.  
  6634. static void yWriteNodeACF_DUMMY
  6635. # if defined __STDC__ | defined __cplusplus
  6636.  (tTree yyt)
  6637. # else
  6638.  (yyt) tTree yyt;
  6639. # endif
  6640. {
  6641.  yWriteNodeACF_NODE (yyt); 
  6642. }
  6643.  
  6644. static void yWriteNodeACF_BASIC
  6645. # if defined __STDC__ | defined __cplusplus
  6646.  (tTree yyt)
  6647. # else
  6648.  (yyt) tTree yyt;
  6649. # endif
  6650. {
  6651.  yWriteNodeACF_NODE (yyt); 
  6652.  yyWriteSelector ("BASIC_STMT"); yyWriteAdr (yyt->ACF_BASIC.BASIC_STMT);
  6653. }
  6654.  
  6655. static void yWriteNodeACF_IF
  6656. # if defined __STDC__ | defined __cplusplus
  6657.  (tTree yyt)
  6658. # else
  6659.  (yyt) tTree yyt;
  6660. # endif
  6661. {
  6662.  yWriteNodeACF_NODE (yyt); 
  6663.  yyWriteSelector ("IF_EXP"); yyWriteAdr (yyt->ACF_IF.IF_EXP);
  6664.  yyWriteSelector ("THEN_PART"); yyWriteAdr (yyt->ACF_IF.THEN_PART);
  6665.  yyWriteSelector ("ELSE_PART"); yyWriteAdr (yyt->ACF_IF.ELSE_PART);
  6666. }
  6667.  
  6668. static void yWriteNodeACF_WHERE
  6669. # if defined __STDC__ | defined __cplusplus
  6670.  (tTree yyt)
  6671. # else
  6672.  (yyt) tTree yyt;
  6673. # endif
  6674. {
  6675.  yWriteNodeACF_NODE (yyt); 
  6676.  yyWriteSelector ("WHERE_EXP"); yyWriteAdr (yyt->ACF_WHERE.WHERE_EXP);
  6677.  yyWriteSelector ("TRUE_PART"); yyWriteAdr (yyt->ACF_WHERE.TRUE_PART);
  6678.  yyWriteSelector ("FALSE_PART"); yyWriteAdr (yyt->ACF_WHERE.FALSE_PART);
  6679. }
  6680.  
  6681. static void yWriteNodeACF_SWITCH
  6682. # if defined __STDC__ | defined __cplusplus
  6683.  (tTree yyt)
  6684. # else
  6685.  (yyt) tTree yyt;
  6686. # endif
  6687. {
  6688.  yWriteNodeACF_NODE (yyt); 
  6689.  yyWriteSelector ("SWITCH_EXP"); yyWriteAdr (yyt->ACF_SWITCH.SWITCH_EXP);
  6690.  yyWriteSelector ("SWITCH_STMT"); yyWriteAdr (yyt->ACF_SWITCH.SWITCH_STMT);
  6691. }
  6692.  
  6693. static void yWriteNodeACF_ALTER
  6694. # if defined __STDC__ | defined __cplusplus
  6695.  (tTree yyt)
  6696. # else
  6697.  (yyt) tTree yyt;
  6698. # endif
  6699. {
  6700.  yWriteNodeACF_NODE (yyt); 
  6701.  yyWriteSelector ("ALTER_EXP"); yyWriteAdr (yyt->ACF_ALTER.ALTER_EXP);
  6702.  yyWriteSelector ("ALTER_STMT"); yyWriteAdr (yyt->ACF_ALTER.ALTER_STMT);
  6703. }
  6704.  
  6705. static void yWriteNodeACF_CASE
  6706. # if defined __STDC__ | defined __cplusplus
  6707.  (tTree yyt)
  6708. # else
  6709.  (yyt) tTree yyt;
  6710. # endif
  6711. {
  6712.  yWriteNodeACF_NODE (yyt); 
  6713.  yyWriteSelector ("CASE_EXP"); yyWriteAdr (yyt->ACF_CASE.CASE_EXP);
  6714.  yyWriteSelector ("CASE_ALTS"); yyWriteAdr (yyt->ACF_CASE.CASE_ALTS);
  6715.  yyWriteSelector ("CASE_OTHERWISE"); yyWriteAdr (yyt->ACF_CASE.CASE_OTHERWISE);
  6716. }
  6717.  
  6718. static void yWriteNodeACF_WHILE
  6719. # if defined __STDC__ | defined __cplusplus
  6720.  (tTree yyt)
  6721. # else
  6722.  (yyt) tTree yyt;
  6723. # endif
  6724. {
  6725.  yWriteNodeACF_NODE (yyt); 
  6726.  yyWriteSelector ("WHILE_EXP"); yyWriteAdr (yyt->ACF_WHILE.WHILE_EXP);
  6727.  yyWriteSelector ("WHILE_BODY"); yyWriteAdr (yyt->ACF_WHILE.WHILE_BODY);
  6728. }
  6729.  
  6730. static void yWriteNodeACF_REPEAT
  6731. # if defined __STDC__ | defined __cplusplus
  6732.  (tTree yyt)
  6733. # else
  6734.  (yyt) tTree yyt;
  6735. # endif
  6736. {
  6737.  yWriteNodeACF_NODE (yyt); 
  6738.  yyWriteSelector ("REPEAT_BODY"); yyWriteAdr (yyt->ACF_REPEAT.REPEAT_BODY);
  6739.  yyWriteSelector ("REPEAT_EXP"); yyWriteAdr (yyt->ACF_REPEAT.REPEAT_EXP);
  6740. }
  6741.  
  6742. static void yWriteNodeACF_WITH
  6743. # if defined __STDC__ | defined __cplusplus
  6744.  (tTree yyt)
  6745. # else
  6746.  (yyt) tTree yyt;
  6747. # endif
  6748. {
  6749.  yWriteNodeACF_NODE (yyt); 
  6750.  yyWriteSelector ("WITH_VARS"); yyWriteAdr (yyt->ACF_WITH.WITH_VARS);
  6751.  yyWriteSelector ("WITH_BODY"); yyWriteAdr (yyt->ACF_WITH.WITH_BODY);
  6752. }
  6753.  
  6754. static void yWriteNodeACF_LOOP
  6755. # if defined __STDC__ | defined __cplusplus
  6756.  (tTree yyt)
  6757. # else
  6758.  (yyt) tTree yyt;
  6759. # endif
  6760. {
  6761.  yWriteNodeACF_NODE (yyt); 
  6762.  yyWriteSelector ("LOOP_BODY"); yyWriteAdr (yyt->ACF_LOOP.LOOP_BODY);
  6763. }
  6764.  
  6765. static void yWriteNodeACF_DO
  6766. # if defined __STDC__ | defined __cplusplus
  6767.  (tTree yyt)
  6768. # else
  6769.  (yyt) tTree yyt;
  6770. # endif
  6771. {
  6772.  yWriteNodeACF_NODE (yyt); 
  6773.  yyWriteSelector ("DO_ID"); yyWriteAdr (yyt->ACF_DO.DO_ID);
  6774.  yyWriteSelector ("DO_RANGE"); yyWriteAdr (yyt->ACF_DO.DO_RANGE);
  6775.  yyWriteSelector ("DO_BODY"); yyWriteAdr (yyt->ACF_DO.DO_BODY);
  6776. }
  6777.  
  6778. static void yWriteNodeACF_DOLOCAL
  6779. # if defined __STDC__ | defined __cplusplus
  6780.  (tTree yyt)
  6781. # else
  6782.  (yyt) tTree yyt;
  6783. # endif
  6784. {
  6785.  yWriteNodeACF_NODE (yyt); 
  6786.  yyWriteSelector ("DOLOCAL_ID"); yyWriteAdr (yyt->ACF_DOLOCAL.DOLOCAL_ID);
  6787.  yyWriteSelector ("DOLOCAL_RANGE"); yyWriteAdr (yyt->ACF_DOLOCAL.DOLOCAL_RANGE);
  6788.  yyWriteSelector ("DOLOCAL_BODY"); yyWriteAdr (yyt->ACF_DOLOCAL.DOLOCAL_BODY);
  6789. }
  6790.  
  6791. static void yWriteNodeACF_DOVEC
  6792. # if defined __STDC__ | defined __cplusplus
  6793.  (tTree yyt)
  6794. # else
  6795.  (yyt) tTree yyt;
  6796. # endif
  6797. {
  6798.  yWriteNodeACF_NODE (yyt); 
  6799.  yyWriteSelector ("DOVEC_ID"); yyWriteAdr (yyt->ACF_DOVEC.DOVEC_ID);
  6800.  yyWriteSelector ("DOVEC_RANGE"); yyWriteAdr (yyt->ACF_DOVEC.DOVEC_RANGE);
  6801.  yyWriteSelector ("DOVEC_BODY"); yyWriteAdr (yyt->ACF_DOVEC.DOVEC_BODY);
  6802. }
  6803.  
  6804. static void yWriteNodeACF_DOALL
  6805. # if defined __STDC__ | defined __cplusplus
  6806.  (tTree yyt)
  6807. # else
  6808.  (yyt) tTree yyt;
  6809. # endif
  6810. {
  6811.  yWriteNodeACF_NODE (yyt); 
  6812.  yyWriteSelector ("DOALL_NEW"); yyWriteAdr (yyt->ACF_DOALL.DOALL_NEW);
  6813.  yyWriteSelector ("DOALL_ID"); yyWriteAdr (yyt->ACF_DOALL.DOALL_ID);
  6814.  yyWriteSelector ("DOALL_RANGE"); yyWriteAdr (yyt->ACF_DOALL.DOALL_RANGE);
  6815.  yyWriteSelector ("DOALL_BODY"); yyWriteAdr (yyt->ACF_DOALL.DOALL_BODY);
  6816. }
  6817.  
  6818. static void yWriteNodeACF_FORALL
  6819. # if defined __STDC__ | defined __cplusplus
  6820.  (tTree yyt)
  6821. # else
  6822.  (yyt) tTree yyt;
  6823. # endif
  6824. {
  6825.  yWriteNodeACF_NODE (yyt); 
  6826.  yyWriteSelector ("FORALL_ID"); yyWriteAdr (yyt->ACF_FORALL.FORALL_ID);
  6827.  yyWriteSelector ("FORALL_RANGE"); yyWriteAdr (yyt->ACF_FORALL.FORALL_RANGE);
  6828.  yyWriteSelector ("FORALL_BODY"); yyWriteAdr (yyt->ACF_FORALL.FORALL_BODY);
  6829. }
  6830.  
  6831. static void yWriteNodeACF_ON
  6832. # if defined __STDC__ | defined __cplusplus
  6833.  (tTree yyt)
  6834. # else
  6835.  (yyt) tTree yyt;
  6836. # endif
  6837. {
  6838.  yWriteNodeACF_NODE (yyt); 
  6839.  yyWriteSelector ("ON_VAR"); yyWriteAdr (yyt->ACF_ON.ON_VAR);
  6840.  yyWriteSelector ("ON_STMT"); yyWriteAdr (yyt->ACF_ON.ON_STMT);
  6841. }
  6842.  
  6843. static void yWriteNodeACF_BODY
  6844. # if defined __STDC__ | defined __cplusplus
  6845.  (tTree yyt)
  6846. # else
  6847.  (yyt) tTree yyt;
  6848. # endif
  6849. {
  6850.  yWriteNodeACF_NODE (yyt); 
  6851.  yyWriteSelector ("NEW_BODY"); yyWriteAdr (yyt->ACF_BODY.NEW_BODY);
  6852.  yyWriteSelector ("Entries"); writetDefinitions (yyt->ACF_BODY.Entries) yyWriteNl ();
  6853. }
  6854.  
  6855. static void yWriteNodeACF_FLOW_GRAPH
  6856. # if defined __STDC__ | defined __cplusplus
  6857.  (tTree yyt)
  6858. # else
  6859.  (yyt) tTree yyt;
  6860. # endif
  6861. {
  6862.  yWriteNodeACF_NODE (yyt); 
  6863.  yyWriteSelector ("FLOW_NODES"); yyWriteAdr (yyt->ACF_FLOW_GRAPH.FLOW_NODES);
  6864. }
  6865.  
  6866. static void yWriteNodeACF_ENTRY
  6867. # if defined __STDC__ | defined __cplusplus
  6868.  (tTree yyt)
  6869. # else
  6870.  (yyt) tTree yyt;
  6871. # endif
  6872. {
  6873.  yWriteNodeACF_NODE (yyt); 
  6874.  yyWriteSelector ("ENTRY_DECL"); yyWriteAdr (yyt->ACF_ENTRY.ENTRY_DECL);
  6875. }
  6876.  
  6877. static void yWriteNodeSELECTED_ACF_LIST
  6878. # if defined __STDC__ | defined __cplusplus
  6879.  (tTree yyt)
  6880. # else
  6881.  (yyt) tTree yyt;
  6882. # endif
  6883. {
  6884.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->SELECTED_ACF_LIST.Elem);
  6885.  yyWriteSelector ("Next"); yyWriteAdr (yyt->SELECTED_ACF_LIST.Next);
  6886. }
  6887.  
  6888. static void yWriteNodeSELECTED_ACF_NODE
  6889. # if defined __STDC__ | defined __cplusplus
  6890.  (tTree yyt)
  6891. # else
  6892.  (yyt) tTree yyt;
  6893. # endif
  6894. {
  6895.  yyWriteSelector ("SELECT_LIST"); yyWriteAdr (yyt->SELECTED_ACF_NODE.SELECT_LIST);
  6896.  yyWriteSelector ("SELECT_ACFS"); yyWriteAdr (yyt->SELECTED_ACF_NODE.SELECT_ACFS);
  6897. }
  6898.  
  6899. static void yWriteNodeEXP_STMT
  6900. # if defined __STDC__ | defined __cplusplus
  6901.  (tTree yyt)
  6902. # else
  6903.  (yyt) tTree yyt;
  6904. # endif
  6905. {
  6906.  yyWriteSelector ("STMT_EXP"); yyWriteAdr (yyt->EXP_STMT.STMT_EXP);
  6907. }
  6908.  
  6909. static void yWriteNodeASSIGN_STMT
  6910. # if defined __STDC__ | defined __cplusplus
  6911.  (tTree yyt)
  6912. # else
  6913.  (yyt) tTree yyt;
  6914. # endif
  6915. {
  6916.  yyWriteSelector ("ASSIGN_VAR"); yyWriteAdr (yyt->ASSIGN_STMT.ASSIGN_VAR);
  6917.  yyWriteSelector ("ASSIGN_EXP"); yyWriteAdr (yyt->ASSIGN_STMT.ASSIGN_EXP);
  6918. }
  6919.  
  6920. static void yWriteNodePTR_ASSIGN_STMT
  6921. # if defined __STDC__ | defined __cplusplus
  6922.  (tTree yyt)
  6923. # else
  6924.  (yyt) tTree yyt;
  6925. # endif
  6926. {
  6927.  yyWriteSelector ("ASSIGN_VAR"); yyWriteAdr (yyt->PTR_ASSIGN_STMT.ASSIGN_VAR);
  6928.  yyWriteSelector ("ASSIGN_EXP"); yyWriteAdr (yyt->PTR_ASSIGN_STMT.ASSIGN_EXP);
  6929. }
  6930.  
  6931. static void yWriteNodeLABEL_ASSIGN_STMT
  6932. # if defined __STDC__ | defined __cplusplus
  6933.  (tTree yyt)
  6934. # else
  6935.  (yyt) tTree yyt;
  6936. # endif
  6937. {
  6938.  yyWriteSelector ("assign_label"); writeint (yyt->LABEL_ASSIGN_STMT.assign_label) yyWriteNl ();
  6939.  yyWriteSelector ("LABEL_VAR"); yyWriteAdr (yyt->LABEL_ASSIGN_STMT.LABEL_VAR);
  6940. }
  6941.  
  6942. static void yWriteNodeCALL_STMT
  6943. # if defined __STDC__ | defined __cplusplus
  6944.  (tTree yyt)
  6945. # else
  6946.  (yyt) tTree yyt;
  6947. # endif
  6948. {
  6949.  yyWriteSelector ("CALL_ID"); yyWriteAdr (yyt->CALL_STMT.CALL_ID);
  6950.  yyWriteSelector ("CALL_PARAMS"); yyWriteAdr (yyt->CALL_STMT.CALL_PARAMS);
  6951. }
  6952.  
  6953. static void yWriteNodeIO_STMT
  6954. # if defined __STDC__ | defined __cplusplus
  6955.  (tTree yyt)
  6956. # else
  6957.  (yyt) tTree yyt;
  6958. # endif
  6959. {
  6960.  yyWriteSelector ("ID"); yyWriteAdr (yyt->IO_STMT.ID);
  6961.  yyWriteSelector ("IO_SPECS"); yyWriteAdr (yyt->IO_STMT.IO_SPECS);
  6962.  yyWriteSelector ("IO_ITEMS"); yyWriteAdr (yyt->IO_STMT.IO_ITEMS);
  6963. }
  6964.  
  6965. static void yWriteNodeGOTO_STMT
  6966. # if defined __STDC__ | defined __cplusplus
  6967.  (tTree yyt)
  6968. # else
  6969.  (yyt) tTree yyt;
  6970. # endif
  6971. {
  6972.  yyWriteSelector ("GOTO_LABEL"); writeint (yyt->GOTO_STMT.GOTO_LABEL) yyWriteNl ();
  6973. }
  6974.  
  6975. static void yWriteNodeASS_GOTO_STMT
  6976. # if defined __STDC__ | defined __cplusplus
  6977.  (tTree yyt)
  6978. # else
  6979.  (yyt) tTree yyt;
  6980. # endif
  6981. {
  6982.  yyWriteSelector ("GOTO_VAR"); yyWriteAdr (yyt->ASS_GOTO_STMT.GOTO_VAR);
  6983.  yyWriteSelector ("LABELS"); yyWriteAdr (yyt->ASS_GOTO_STMT.LABELS);
  6984. }
  6985.  
  6986. static void yWriteNodeCOMP_GOTO_STMT
  6987. # if defined __STDC__ | defined __cplusplus
  6988.  (tTree yyt)
  6989. # else
  6990.  (yyt) tTree yyt;
  6991. # endif
  6992. {
  6993.  yyWriteSelector ("GOTO_LABELS"); yyWriteAdr (yyt->COMP_GOTO_STMT.GOTO_LABELS);
  6994.  yyWriteSelector ("GOTO_EXP"); yyWriteAdr (yyt->COMP_GOTO_STMT.GOTO_EXP);
  6995. }
  6996.  
  6997. static void yWriteNodeCOMP_IF_STMT
  6998. # if defined __STDC__ | defined __cplusplus
  6999.  (tTree yyt)
  7000. # else
  7001.  (yyt) tTree yyt;
  7002. # endif
  7003. {
  7004.  yyWriteSelector ("IF_EXP"); yyWriteAdr (yyt->COMP_IF_STMT.IF_EXP);
  7005.  yyWriteSelector ("IF_LT_LABEL"); writeint (yyt->COMP_IF_STMT.IF_LT_LABEL) yyWriteNl ();
  7006.  yyWriteSelector ("IF_EQ_LABEL"); writeint (yyt->COMP_IF_STMT.IF_EQ_LABEL) yyWriteNl ();
  7007.  yyWriteSelector ("IF_GT_LABEL"); writeint (yyt->COMP_IF_STMT.IF_GT_LABEL) yyWriteNl ();
  7008. }
  7009.  
  7010. static void yWriteNodeRETURN_STMT
  7011. # if defined __STDC__ | defined __cplusplus
  7012.  (tTree yyt)
  7013. # else
  7014.  (yyt) tTree yyt;
  7015. # endif
  7016. {
  7017.  yyWriteSelector ("RETURN_EXP"); yyWriteAdr (yyt->RETURN_STMT.RETURN_EXP);
  7018. }
  7019.  
  7020. static void yWriteNodePAUSE_STMT
  7021. # if defined __STDC__ | defined __cplusplus
  7022.  (tTree yyt)
  7023. # else
  7024.  (yyt) tTree yyt;
  7025. # endif
  7026. {
  7027.  yyWriteSelector ("PAUSE_CONST"); yyWriteAdr (yyt->PAUSE_STMT.PAUSE_CONST);
  7028. }
  7029.  
  7030. static void yWriteNodeEXIT_STMT
  7031. # if defined __STDC__ | defined __cplusplus
  7032.  (tTree yyt)
  7033. # else
  7034.  (yyt) tTree yyt;
  7035. # endif
  7036. {
  7037.  yyWriteSelector ("loopid"); writetIdent (yyt->EXIT_STMT.loopid) yyWriteNl ();
  7038. }
  7039.  
  7040. static void yWriteNodeCYCLE_STMT
  7041. # if defined __STDC__ | defined __cplusplus
  7042.  (tTree yyt)
  7043. # else
  7044.  (yyt) tTree yyt;
  7045. # endif
  7046. {
  7047.  yyWriteSelector ("loopid"); writetIdent (yyt->CYCLE_STMT.loopid) yyWriteNl ();
  7048. }
  7049.  
  7050. static void yWriteNodeSTOP_STMT
  7051. # if defined __STDC__ | defined __cplusplus
  7052.  (tTree yyt)
  7053. # else
  7054.  (yyt) tTree yyt;
  7055. # endif
  7056. {
  7057.  yyWriteSelector ("STOP_CONST"); yyWriteAdr (yyt->STOP_STMT.STOP_CONST);
  7058. }
  7059.  
  7060. static void yWriteNodeFORMAT_STMT
  7061. # if defined __STDC__ | defined __cplusplus
  7062.  (tTree yyt)
  7063. # else
  7064.  (yyt) tTree yyt;
  7065. # endif
  7066. {
  7067.  yyWriteSelector ("FORMAT_PARAMS"); yyWriteAdr (yyt->FORMAT_STMT.FORMAT_PARAMS);
  7068. }
  7069.  
  7070. static void yWriteNodeALLOCATE_STMT
  7071. # if defined __STDC__ | defined __cplusplus
  7072.  (tTree yyt)
  7073. # else
  7074.  (yyt) tTree yyt;
  7075. # endif
  7076. {
  7077.  yyWriteSelector ("PARAMS"); yyWriteAdr (yyt->ALLOCATE_STMT.PARAMS);
  7078.  yyWriteSelector ("STAT"); yyWriteAdr (yyt->ALLOCATE_STMT.STAT);
  7079. }
  7080.  
  7081. static void yWriteNodeDEALLOCATE_STMT
  7082. # if defined __STDC__ | defined __cplusplus
  7083.  (tTree yyt)
  7084. # else
  7085.  (yyt) tTree yyt;
  7086. # endif
  7087. {
  7088.  yyWriteSelector ("PARAMS"); yyWriteAdr (yyt->DEALLOCATE_STMT.PARAMS);
  7089.  yyWriteSelector ("STAT"); yyWriteAdr (yyt->DEALLOCATE_STMT.STAT);
  7090. }
  7091.  
  7092. static void yWriteNodeNULLIFY_STMT
  7093. # if defined __STDC__ | defined __cplusplus
  7094.  (tTree yyt)
  7095. # else
  7096.  (yyt) tTree yyt;
  7097. # endif
  7098. {
  7099.  yyWriteSelector ("PARAMS"); yyWriteAdr (yyt->NULLIFY_STMT.PARAMS);
  7100. }
  7101.  
  7102. static void yWriteNodeREDUCE_STMT
  7103. # if defined __STDC__ | defined __cplusplus
  7104.  (tTree yyt)
  7105. # else
  7106.  (yyt) tTree yyt;
  7107. # endif
  7108. {
  7109.  yyWriteSelector ("RED_FUNC"); yyWriteAdr (yyt->REDUCE_STMT.RED_FUNC);
  7110.  yyWriteSelector ("RED_PARAMS"); yyWriteAdr (yyt->REDUCE_STMT.RED_PARAMS);
  7111. }
  7112.  
  7113. static void yWriteNodeGLOBAL_STMT
  7114. # if defined __STDC__ | defined __cplusplus
  7115.  (tTree yyt)
  7116. # else
  7117.  (yyt) tTree yyt;
  7118. # endif
  7119. {
  7120.  yyWriteSelector ("func"); writetIdent (yyt->GLOBAL_STMT.func) yyWriteNl ();
  7121.  yyWriteSelector ("ARRAY"); yyWriteAdr (yyt->GLOBAL_STMT.ARRAY);
  7122.  yyWriteSelector ("INDEXED_ARRAY"); yyWriteAdr (yyt->GLOBAL_STMT.INDEXED_ARRAY);
  7123.  yyWriteSelector ("INDEXES"); yyWriteAdr (yyt->GLOBAL_STMT.INDEXES);
  7124.  yyWriteSelector ("MASK"); yyWriteAdr (yyt->GLOBAL_STMT.MASK);
  7125. }
  7126.  
  7127. static void yWriteNodeALIGN_STMT
  7128. # if defined __STDC__ | defined __cplusplus
  7129.  (tTree yyt)
  7130. # else
  7131.  (yyt) tTree yyt;
  7132. # endif
  7133. {
  7134.  yyWriteSelector ("ALIGNEE"); yyWriteAdr (yyt->ALIGN_STMT.ALIGNEE);
  7135.  yyWriteSelector ("ALIGN_SPEC"); yyWriteAdr (yyt->ALIGN_STMT.ALIGN_SPEC);
  7136. }
  7137.  
  7138. static void yWriteNodeDISTRIBUTE_STMT
  7139. # if defined __STDC__ | defined __cplusplus
  7140.  (tTree yyt)
  7141. # else
  7142.  (yyt) tTree yyt;
  7143. # endif
  7144. {
  7145.  yyWriteSelector ("DISTRIBUTEE"); yyWriteAdr (yyt->DISTRIBUTE_STMT.DISTRIBUTEE);
  7146.  yyWriteSelector ("DISTRIBUTION"); yyWriteAdr (yyt->DISTRIBUTE_STMT.DISTRIBUTION);
  7147.  yyWriteSelector ("target"); writetIdent (yyt->DISTRIBUTE_STMT.target) yyWriteNl ();
  7148. }
  7149.  
  7150. static void yWriteNodeLABEL_LIST
  7151. # if defined __STDC__ | defined __cplusplus
  7152.  (tTree yyt)
  7153. # else
  7154.  (yyt) tTree yyt;
  7155. # endif
  7156. {
  7157.  yyWriteSelector ("Elem"); writeint (yyt->LABEL_LIST.Elem) yyWriteNl ();
  7158.  yyWriteSelector ("Next"); yyWriteAdr (yyt->LABEL_LIST.Next);
  7159. }
  7160.  
  7161. static void yWriteNodeOP_DEFINED
  7162. # if defined __STDC__ | defined __cplusplus
  7163.  (tTree yyt)
  7164. # else
  7165.  (yyt) tTree yyt;
  7166. # endif
  7167. {
  7168.  yyWriteSelector ("opname"); writetIdent (yyt->OP_DEFINED.opname) yyWriteNl ();
  7169. }
  7170.  
  7171. static void yWriteNodeCONST_EXP
  7172. # if defined __STDC__ | defined __cplusplus
  7173.  (tTree yyt)
  7174. # else
  7175.  (yyt) tTree yyt;
  7176. # endif
  7177. {
  7178.  yyWriteSelector ("C"); yyWriteAdr (yyt->CONST_EXP.C);
  7179. }
  7180.  
  7181. static void yWriteNodeOP_EXP
  7182. # if defined __STDC__ | defined __cplusplus
  7183.  (tTree yyt)
  7184. # else
  7185.  (yyt) tTree yyt;
  7186. # endif
  7187. {
  7188.  yyWriteSelector ("EXP_OP"); yyWriteAdr (yyt->OP_EXP.EXP_OP);
  7189.  yyWriteSelector ("OPND1"); yyWriteAdr (yyt->OP_EXP.OPND1);
  7190.  yyWriteSelector ("OPND2"); yyWriteAdr (yyt->OP_EXP.OPND2);
  7191. }
  7192.  
  7193. static void yWriteNodeOP1_EXP
  7194. # if defined __STDC__ | defined __cplusplus
  7195.  (tTree yyt)
  7196. # else
  7197.  (yyt) tTree yyt;
  7198. # endif
  7199. {
  7200.  yyWriteSelector ("EXP_OP1"); yyWriteAdr (yyt->OP1_EXP.EXP_OP1);
  7201.  yyWriteSelector ("OPND"); yyWriteAdr (yyt->OP1_EXP.OPND);
  7202. }
  7203.  
  7204. static void yWriteNodeSLICE_EXP
  7205. # if defined __STDC__ | defined __cplusplus
  7206.  (tTree yyt)
  7207. # else
  7208.  (yyt) tTree yyt;
  7209. # endif
  7210. {
  7211.  yyWriteSelector ("START"); yyWriteAdr (yyt->SLICE_EXP.START);
  7212.  yyWriteSelector ("STOP"); yyWriteAdr (yyt->SLICE_EXP.STOP);
  7213.  yyWriteSelector ("INC"); yyWriteAdr (yyt->SLICE_EXP.INC);
  7214. }
  7215.  
  7216. static void yWriteNodePOSTFIX_EXP
  7217. # if defined __STDC__ | defined __cplusplus
  7218.  (tTree yyt)
  7219. # else
  7220.  (yyt) tTree yyt;
  7221. # endif
  7222. {
  7223.  yyWriteSelector ("POSTFIX_OP"); yyWriteAdr (yyt->POSTFIX_EXP.POSTFIX_OP);
  7224.  yyWriteSelector ("OPND"); yyWriteAdr (yyt->POSTFIX_EXP.OPND);
  7225. }
  7226.  
  7227. static void yWriteNodeCALL_EXP
  7228. # if defined __STDC__ | defined __cplusplus
  7229.  (tTree yyt)
  7230. # else
  7231.  (yyt) tTree yyt;
  7232. # endif
  7233. {
  7234.  yyWriteSelector ("FUNC_ID"); yyWriteAdr (yyt->CALL_EXP.FUNC_ID);
  7235.  yyWriteSelector ("FUNC_PARAMS"); yyWriteAdr (yyt->CALL_EXP.FUNC_PARAMS);
  7236. }
  7237.  
  7238. static void yWriteNodeCAST_EXP
  7239. # if defined __STDC__ | defined __cplusplus
  7240.  (tTree yyt)
  7241. # else
  7242.  (yyt) tTree yyt;
  7243. # endif
  7244. {
  7245.  yyWriteSelector ("ID"); yyWriteAdr (yyt->CAST_EXP.ID);
  7246.  yyWriteSelector ("CAST"); yyWriteAdr (yyt->CAST_EXP.CAST);
  7247. }
  7248.  
  7249. static void yWriteNodeINDEXED_EXP
  7250. # if defined __STDC__ | defined __cplusplus
  7251.  (tTree yyt)
  7252. # else
  7253.  (yyt) tTree yyt;
  7254. # endif
  7255. {
  7256.  yyWriteSelector ("IND_EXP"); yyWriteAdr (yyt->INDEXED_EXP.IND_EXP);
  7257.  yyWriteSelector ("INDEX"); yyWriteAdr (yyt->INDEXED_EXP.INDEX);
  7258. }
  7259.  
  7260. static void yWriteNodeSELECTED_EXP
  7261. # if defined __STDC__ | defined __cplusplus
  7262.  (tTree yyt)
  7263. # else
  7264.  (yyt) tTree yyt;
  7265. # endif
  7266. {
  7267.  yyWriteSelector ("SELEC_EXP"); yyWriteAdr (yyt->SELECTED_EXP.SELEC_EXP);
  7268.  yyWriteSelector ("SELECTOR"); yyWriteAdr (yyt->SELECTED_EXP.SELECTOR);
  7269. }
  7270.  
  7271. static void yWriteNodeASSIGN_EXP
  7272. # if defined __STDC__ | defined __cplusplus
  7273.  (tTree yyt)
  7274. # else
  7275.  (yyt) tTree yyt;
  7276. # endif
  7277. {
  7278.  yyWriteSelector ("ASSIGN_OP"); yyWriteAdr (yyt->ASSIGN_EXP.ASSIGN_OP);
  7279.  yyWriteSelector ("LHS"); yyWriteAdr (yyt->ASSIGN_EXP.LHS);
  7280.  yyWriteSelector ("RHS"); yyWriteAdr (yyt->ASSIGN_EXP.RHS);
  7281. }
  7282.  
  7283. static void yWriteNodeUSED_EXP
  7284. # if defined __STDC__ | defined __cplusplus
  7285.  (tTree yyt)
  7286. # else
  7287.  (yyt) tTree yyt;
  7288. # endif
  7289. {
  7290.  yyWriteSelector ("VARNAME"); yyWriteAdr (yyt->USED_EXP.VARNAME);
  7291. }
  7292.  
  7293. static void yWriteNodeCOND_EXP
  7294. # if defined __STDC__ | defined __cplusplus
  7295.  (tTree yyt)
  7296. # else
  7297.  (yyt) tTree yyt;
  7298. # endif
  7299. {
  7300.  yyWriteSelector ("COND"); yyWriteAdr (yyt->COND_EXP.COND);
  7301.  yyWriteSelector ("TRUE_EXP"); yyWriteAdr (yyt->COND_EXP.TRUE_EXP);
  7302.  yyWriteSelector ("FALSE_EXP"); yyWriteAdr (yyt->COND_EXP.FALSE_EXP);
  7303. }
  7304.  
  7305. static void yWriteNodeVAR_EXP
  7306. # if defined __STDC__ | defined __cplusplus
  7307.  (tTree yyt)
  7308. # else
  7309.  (yyt) tTree yyt;
  7310. # endif
  7311. {
  7312.  yyWriteSelector ("V"); yyWriteAdr (yyt->VAR_EXP.V);
  7313. }
  7314.  
  7315. static void yWriteNodeFUNC_CALL_EXP
  7316. # if defined __STDC__ | defined __cplusplus
  7317.  (tTree yyt)
  7318. # else
  7319.  (yyt) tTree yyt;
  7320. # endif
  7321. {
  7322.  yyWriteSelector ("FUNC_ID"); yyWriteAdr (yyt->FUNC_CALL_EXP.FUNC_ID);
  7323.  yyWriteSelector ("FUNC_PARAMS"); yyWriteAdr (yyt->FUNC_CALL_EXP.FUNC_PARAMS);
  7324. }
  7325.  
  7326. static void yWriteNodeNAMED_EXP
  7327. # if defined __STDC__ | defined __cplusplus
  7328.  (tTree yyt)
  7329. # else
  7330.  (yyt) tTree yyt;
  7331. # endif
  7332. {
  7333.  yyWriteSelector ("Name"); writetIdent (yyt->NAMED_EXP.Name) yyWriteNl ();
  7334.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->NAMED_EXP.VAL);
  7335. }
  7336.  
  7337. static void yWriteNodeDO_EXP
  7338. # if defined __STDC__ | defined __cplusplus
  7339.  (tTree yyt)
  7340. # else
  7341.  (yyt) tTree yyt;
  7342. # endif
  7343. {
  7344.  yyWriteSelector ("DO_ID"); yyWriteAdr (yyt->DO_EXP.DO_ID);
  7345.  yyWriteSelector ("RANGE"); yyWriteAdr (yyt->DO_EXP.RANGE);
  7346.  yyWriteSelector ("BODY"); yyWriteAdr (yyt->DO_EXP.BODY);
  7347. }
  7348.  
  7349. static void yWriteNodeTYPE_EXP
  7350. # if defined __STDC__ | defined __cplusplus
  7351.  (tTree yyt)
  7352. # else
  7353.  (yyt) tTree yyt;
  7354. # endif
  7355. {
  7356.  yyWriteSelector ("ID"); yyWriteAdr (yyt->TYPE_EXP.ID);
  7357.  yyWriteSelector ("ELEMENTS"); yyWriteAdr (yyt->TYPE_EXP.ELEMENTS);
  7358. }
  7359.  
  7360. static void yWriteNodeARRAY_EXP
  7361. # if defined __STDC__ | defined __cplusplus
  7362.  (tTree yyt)
  7363. # else
  7364.  (yyt) tTree yyt;
  7365. # endif
  7366. {
  7367.  yyWriteSelector ("ELEMENTS"); yyWriteAdr (yyt->ARRAY_EXP.ELEMENTS);
  7368. }
  7369.  
  7370. static void yWriteNodeBTE_LIST
  7371. # if defined __STDC__ | defined __cplusplus
  7372.  (tTree yyt)
  7373. # else
  7374.  (yyt) tTree yyt;
  7375. # endif
  7376. {
  7377.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->BTE_LIST.Elem);
  7378.  yyWriteSelector ("Next"); yyWriteAdr (yyt->BTE_LIST.Next);
  7379. }
  7380.  
  7381. static void yWriteNodeUSED_VAR
  7382. # if defined __STDC__ | defined __cplusplus
  7383.  (tTree yyt)
  7384. # else
  7385.  (yyt) tTree yyt;
  7386. # endif
  7387. {
  7388.  yyWriteSelector ("VARNAME"); yyWriteAdr (yyt->USED_VAR.VARNAME);
  7389. }
  7390.  
  7391. static void yWriteNodeINDEXED_VAR
  7392. # if defined __STDC__ | defined __cplusplus
  7393.  (tTree yyt)
  7394. # else
  7395.  (yyt) tTree yyt;
  7396. # endif
  7397. {
  7398.  yyWriteSelector ("IND_VAR"); yyWriteAdr (yyt->INDEXED_VAR.IND_VAR);
  7399.  yyWriteSelector ("IND_EXPS"); yyWriteAdr (yyt->INDEXED_VAR.IND_EXPS);
  7400. }
  7401.  
  7402. static void yWriteNodeSUBSTRING_VAR
  7403. # if defined __STDC__ | defined __cplusplus
  7404.  (tTree yyt)
  7405. # else
  7406.  (yyt) tTree yyt;
  7407. # endif
  7408. {
  7409.  yyWriteSelector ("IND_VAR"); yyWriteAdr (yyt->SUBSTRING_VAR.IND_VAR);
  7410.  yyWriteSelector ("IND_EXP"); yyWriteAdr (yyt->SUBSTRING_VAR.IND_EXP);
  7411. }
  7412.  
  7413. static void yWriteNodeSELECTED_VAR
  7414. # if defined __STDC__ | defined __cplusplus
  7415.  (tTree yyt)
  7416. # else
  7417.  (yyt) tTree yyt;
  7418. # endif
  7419. {
  7420.  yyWriteSelector ("SELEC_VAR"); yyWriteAdr (yyt->SELECTED_VAR.SELEC_VAR);
  7421.  yyWriteSelector ("SELECTOR"); yyWriteAdr (yyt->SELECTED_VAR.SELECTOR);
  7422. }
  7423.  
  7424. static void yWriteNodeLOOP_VAR
  7425. # if defined __STDC__ | defined __cplusplus
  7426.  (tTree yyt)
  7427. # else
  7428.  (yyt) tTree yyt;
  7429. # endif
  7430. {
  7431.  yyWriteSelector ("LOOP_VARNAME"); yyWriteAdr (yyt->LOOP_VAR.LOOP_VARNAME);
  7432. }
  7433.  
  7434. static void yWriteNodeADDR
  7435. # if defined __STDC__ | defined __cplusplus
  7436.  (tTree yyt)
  7437. # else
  7438.  (yyt) tTree yyt;
  7439. # endif
  7440. {
  7441.  yyWriteSelector ("E"); yyWriteAdr (yyt->ADDR.E);
  7442. }
  7443.  
  7444. static void yWriteNodeDO_VAR
  7445. # if defined __STDC__ | defined __cplusplus
  7446.  (tTree yyt)
  7447. # else
  7448.  (yyt) tTree yyt;
  7449. # endif
  7450. {
  7451.  yyWriteSelector ("DO_ID"); yyWriteAdr (yyt->DO_VAR.DO_ID);
  7452.  yyWriteSelector ("RANGE"); yyWriteAdr (yyt->DO_VAR.RANGE);
  7453.  yyWriteSelector ("BODY"); yyWriteAdr (yyt->DO_VAR.BODY);
  7454. }
  7455.  
  7456. static void yWriteNodeBTV_LIST
  7457. # if defined __STDC__ | defined __cplusplus
  7458.  (tTree yyt)
  7459. # else
  7460.  (yyt) tTree yyt;
  7461. # endif
  7462. {
  7463.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->BTV_LIST.Elem);
  7464.  yyWriteSelector ("Next"); yyWriteAdr (yyt->BTV_LIST.Next);
  7465. }
  7466.  
  7467. static void yWriteNodeVAR_PARAM
  7468. # if defined __STDC__ | defined __cplusplus
  7469.  (tTree yyt)
  7470. # else
  7471.  (yyt) tTree yyt;
  7472. # endif
  7473. {
  7474.  yyWriteSelector ("V"); yyWriteAdr (yyt->VAR_PARAM.V);
  7475. }
  7476.  
  7477. static void yWriteNodeVALUE_PARAM
  7478. # if defined __STDC__ | defined __cplusplus
  7479.  (tTree yyt)
  7480. # else
  7481.  (yyt) tTree yyt;
  7482. # endif
  7483. {
  7484.  yyWriteSelector ("E"); yyWriteAdr (yyt->VALUE_PARAM.E);
  7485. }
  7486.  
  7487. static void yWriteNodeNAMED_PARAM
  7488. # if defined __STDC__ | defined __cplusplus
  7489.  (tTree yyt)
  7490. # else
  7491.  (yyt) tTree yyt;
  7492. # endif
  7493. {
  7494.  yyWriteSelector ("Name"); writetIdent (yyt->NAMED_PARAM.Name) yyWriteNl ();
  7495.  yyWriteSelector ("VAL"); yyWriteAdr (yyt->NAMED_PARAM.VAL);
  7496. }
  7497.  
  7498. static void yWriteNodePROC_PARAM
  7499. # if defined __STDC__ | defined __cplusplus
  7500.  (tTree yyt)
  7501. # else
  7502.  (yyt) tTree yyt;
  7503. # endif
  7504. {
  7505.  yyWriteSelector ("P"); yyWriteAdr (yyt->PROC_PARAM.P);
  7506. }
  7507.  
  7508. static void yWriteNodeFUNC_PARAM
  7509. # if defined __STDC__ | defined __cplusplus
  7510.  (tTree yyt)
  7511. # else
  7512.  (yyt) tTree yyt;
  7513. # endif
  7514. {
  7515.  yyWriteSelector ("F"); yyWriteAdr (yyt->FUNC_PARAM.F);
  7516. }
  7517.  
  7518. static void yWriteNodeFORMAT_PARAM
  7519. # if defined __STDC__ | defined __cplusplus
  7520.  (tTree yyt)
  7521. # else
  7522.  (yyt) tTree yyt;
  7523. # endif
  7524. {
  7525.  yyWriteSelector ("S"); writetStringRef (yyt->FORMAT_PARAM.S) yyWriteNl ();
  7526. }
  7527.  
  7528. static void yWriteNodeRETURN_PARAM
  7529. # if defined __STDC__ | defined __cplusplus
  7530.  (tTree yyt)
  7531. # else
  7532.  (yyt) tTree yyt;
  7533. # endif
  7534. {
  7535.  yyWriteSelector ("label"); writeint (yyt->RETURN_PARAM.label) yyWriteNl ();
  7536. }
  7537.  
  7538. static void yWriteNodeBTP_LIST
  7539. # if defined __STDC__ | defined __cplusplus
  7540.  (tTree yyt)
  7541. # else
  7542.  (yyt) tTree yyt;
  7543. # endif
  7544. {
  7545.  yyWriteSelector ("Elem"); yyWriteAdr (yyt->BTP_LIST.Elem);
  7546.  yyWriteSelector ("Next"); yyWriteAdr (yyt->BTP_LIST.Next);
  7547. }
  7548.  
  7549. static void yWriteNodeBOOL_CONSTANT
  7550. # if defined __STDC__ | defined __cplusplus
  7551.  (tTree yyt)
  7552. # else
  7553.  (yyt) tTree yyt;
  7554. # endif
  7555. {
  7556.  yyWriteSelector ("value"); writeint (yyt->BOOL_CONSTANT.value) yyWriteNl ();
  7557. }
  7558.  
  7559. static void yWriteNodeINT_CONSTANT
  7560. # if defined __STDC__ | defined __cplusplus
  7561.  (tTree yyt)
  7562. # else
  7563.  (yyt) tTree yyt;
  7564. # endif
  7565. {
  7566.  yyWriteSelector ("value"); writeint (yyt->INT_CONSTANT.value) yyWriteNl ();
  7567. }
  7568.  
  7569. static void yWriteNodeREAL_CONSTANT
  7570. # if defined __STDC__ | defined __cplusplus
  7571.  (tTree yyt)
  7572. # else
  7573.  (yyt) tTree yyt;
  7574. # endif
  7575. {
  7576.  yyWriteSelector ("value"); writetStringRef (yyt->REAL_CONSTANT.value) yyWriteNl ();
  7577. }
  7578.  
  7579. static void yWriteNodeDREAL_CONSTANT
  7580. # if defined __STDC__ | defined __cplusplus
  7581.  (tTree yyt)
  7582. # else
  7583.  (yyt) tTree yyt;
  7584. # endif
  7585. {
  7586.  yyWriteSelector ("value"); writetStringRef (yyt->DREAL_CONSTANT.value) yyWriteNl ();
  7587. }
  7588.  
  7589. static void yWriteNodeCHAR_CONSTANT
  7590. # if defined __STDC__ | defined __cplusplus
  7591.  (tTree yyt)
  7592. # else
  7593.  (yyt) tTree yyt;
  7594. # endif
  7595. {
  7596.  yyWriteSelector ("value"); writechar (yyt->CHAR_CONSTANT.value) yyWriteNl ();
  7597. }
  7598.  
  7599. static void yWriteNodeSTRING_CONSTANT
  7600. # if defined __STDC__ | defined __cplusplus
  7601.  (tTree yyt)
  7602. # else
  7603.  (yyt) tTree yyt;
  7604. # endif
  7605. {
  7606.  yyWriteSelector ("value"); writetStringRef (yyt->STRING_CONSTANT.value) yyWriteNl ();
  7607. }
  7608.  
  7609. static void yWriteNodeCOMPLEX_CONSTANT
  7610. # if defined __STDC__ | defined __cplusplus
  7611.  (tTree yyt)
  7612. # else
  7613.  (yyt) tTree yyt;
  7614. # endif
  7615. {
  7616.  yyWriteSelector ("rvalue"); writetStringRef (yyt->COMPLEX_CONSTANT.rvalue) yyWriteNl ();
  7617.  yyWriteSelector ("ivalue"); writetStringRef (yyt->COMPLEX_CONSTANT.ivalue) yyWriteNl ();
  7618. }
  7619.  
  7620. static void yWriteNodePROC_OBJ
  7621. # if defined __STDC__ | defined __cplusplus
  7622.  (tTree yyt)
  7623. # else
  7624.  (yyt) tTree yyt;
  7625. # endif
  7626. {
  7627.  yyWriteSelector ("Ident"); writetIdent (yyt->PROC_OBJ.Ident) yyWriteNl ();
  7628.  yyWriteSelector ("Object"); writetDefinitions (yyt->PROC_OBJ.Object) yyWriteNl ();
  7629. }
  7630.  
  7631. static void yWriteNodeVAR_OBJ
  7632. # if defined __STDC__ | defined __cplusplus
  7633.  (tTree yyt)
  7634. # else
  7635.  (yyt) tTree yyt;
  7636. # endif
  7637. {
  7638.  yyWriteSelector ("Pos"); writeint (yyt->VAR_OBJ.Pos) yyWriteNl ();
  7639.  yyWriteSelector ("Ident"); writetIdent (yyt->VAR_OBJ.Ident) yyWriteNl ();
  7640.  yyWriteSelector ("Object"); writetDefinitions (yyt->VAR_OBJ.Object) yyWriteNl ();
  7641. }
  7642.  
  7643. static void yWriteNodeTYPE_OBJ
  7644. # if defined __STDC__ | defined __cplusplus
  7645.  (tTree yyt)
  7646. # else
  7647.  (yyt) tTree yyt;
  7648. # endif
  7649. {
  7650.  yyWriteSelector ("Ident"); writetIdent (yyt->TYPE_OBJ.Ident) yyWriteNl ();
  7651.  yyWriteSelector ("Object"); writetDefinitions (yyt->TYPE_OBJ.Object) yyWriteNl ();
  7652. }
  7653.  
  7654. static void yWriteNodeREC_COMP
  7655. # if defined __STDC__ | defined __cplusplus
  7656.  (tTree yyt)
  7657. # else
  7658.  (yyt) tTree yyt;
  7659. # endif
  7660. {
  7661.  yyWriteSelector ("Ident"); writetIdent (yyt->REC_COMP.Ident) yyWriteNl ();
  7662.  yyWriteSelector ("Object"); writetDefinitions (yyt->REC_COMP.Object) yyWriteNl ();
  7663. }
  7664.  
  7665. void WriteTreeNode
  7666. # if defined __STDC__ | defined __cplusplus
  7667.  (FILE * yyyf, tTree yyt)
  7668. # else
  7669.  (yyyf, yyt) FILE * yyyf; tTree yyt;
  7670. # endif
  7671. {
  7672.  yyf = yyyf;
  7673.  if (yyt == NoTree) { (void) fputs ("NoTree\n", yyf); return; }
  7674.  
  7675.  switch (yyt->Kind) {
  7676. case kCOMP_UNIT: (void) fputs (Tree_NodeName [kCOMP_UNIT], yyf); (void) fputc ('\n', yyf);
  7677.  yWriteNodeCOMP_UNIT (yyt); break;
  7678. case kBODY_NODE: (void) fputs (Tree_NodeName [kBODY_NODE], yyf); (void) fputc ('\n', yyf);
  7679.  yWriteNodeBODY_NODE (yyt); break;
  7680. case kTYPE_NODE: (void) fputs (Tree_NodeName [kTYPE_NODE], yyf); (void) fputc ('\n', yyf);
  7681.  break;
  7682. case kDUMMY_TYPE: (void) fputs (Tree_NodeName [kDUMMY_TYPE], yyf); (void) fputc ('\n', yyf);
  7683.  break;
  7684. case kVOID_TYPE: (void) fputs (Tree_NodeName [kVOID_TYPE], yyf); (void) fputc ('\n', yyf);
  7685.  break;
  7686. case kINTEGER_TYPE: (void) fputs (Tree_NodeName [kINTEGER_TYPE], yyf); (void) fputc ('\n', yyf);
  7687.  yWriteNodeINTEGER_TYPE (yyt); break;
  7688. case kCARDINAL_TYPE: (void) fputs (Tree_NodeName [kCARDINAL_TYPE], yyf); (void) fputc ('\n', yyf);
  7689.  yWriteNodeCARDINAL_TYPE (yyt); break;
  7690. case kREAL_TYPE: (void) fputs (Tree_NodeName [kREAL_TYPE], yyf); (void) fputc ('\n', yyf);
  7691.  yWriteNodeREAL_TYPE (yyt); break;
  7692. case kBOOLEAN_TYPE: (void) fputs (Tree_NodeName [kBOOLEAN_TYPE], yyf); (void) fputc ('\n', yyf);
  7693.  yWriteNodeBOOLEAN_TYPE (yyt); break;
  7694. case kCOMPLEX_TYPE: (void) fputs (Tree_NodeName [kCOMPLEX_TYPE], yyf); (void) fputc ('\n', yyf);
  7695.  yWriteNodeCOMPLEX_TYPE (yyt); break;
  7696. case kCHAR_TYPE: (void) fputs (Tree_NodeName [kCHAR_TYPE], yyf); (void) fputc ('\n', yyf);
  7697.  break;
  7698. case kSTRING_TYPE: (void) fputs (Tree_NodeName [kSTRING_TYPE], yyf); (void) fputc ('\n', yyf);
  7699.  yWriteNodeSTRING_TYPE (yyt); break;
  7700. case kINDEX_TYPE: (void) fputs (Tree_NodeName [kINDEX_TYPE], yyf); (void) fputc ('\n', yyf);
  7701.  yWriteNodeINDEX_TYPE (yyt); break;
  7702. case kTYPE_ID: (void) fputs (Tree_NodeName [kTYPE_ID], yyf); (void) fputc ('\n', yyf);
  7703.  yWriteNodeTYPE_ID (yyt); break;
  7704. case kARRAY_TYPE: (void) fputs (Tree_NodeName [kARRAY_TYPE], yyf); (void) fputc ('\n', yyf);
  7705.  yWriteNodeARRAY_TYPE (yyt); break;
  7706. case kRECORD_TYPE: (void) fputs (Tree_NodeName [kRECORD_TYPE], yyf); (void) fputc ('\n', yyf);
  7707.  yWriteNodeRECORD_TYPE (yyt); break;
  7708. case kUNION_TYPE: (void) fputs (Tree_NodeName [kUNION_TYPE], yyf); (void) fputc ('\n', yyf);
  7709.  yWriteNodeUNION_TYPE (yyt); break;
  7710. case kENUM_TYPE: (void) fputs (Tree_NodeName [kENUM_TYPE], yyf); (void) fputc ('\n', yyf);
  7711.  yWriteNodeENUM_TYPE (yyt); break;
  7712. case kDYNAMIC: (void) fputs (Tree_NodeName [kDYNAMIC], yyf); (void) fputc ('\n', yyf);
  7713.  yWriteNodeDYNAMIC (yyt); break;
  7714. case kPOINTER_TYPE: (void) fputs (Tree_NodeName [kPOINTER_TYPE], yyf); (void) fputc ('\n', yyf);
  7715.  yWriteNodePOINTER_TYPE (yyt); break;
  7716. case kARRAY1_TYPE: (void) fputs (Tree_NodeName [kARRAY1_TYPE], yyf); (void) fputc ('\n', yyf);
  7717.  yWriteNodeARRAY1_TYPE (yyt); break;
  7718. case kFUNCTION_TYPE: (void) fputs (Tree_NodeName [kFUNCTION_TYPE], yyf); (void) fputc ('\n', yyf);
  7719.  yWriteNodeFUNCTION_TYPE (yyt); break;
  7720. case kTYPE_NODE_LIST: (void) fputs (Tree_NodeName [kTYPE_NODE_LIST], yyf); (void) fputc ('\n', yyf);
  7721.  break;
  7722. case kTYPE_EMPTY: (void) fputs (Tree_NodeName [kTYPE_EMPTY], yyf); (void) fputc ('\n', yyf);
  7723.  break;
  7724. case kTYPE_LIST: (void) fputs (Tree_NodeName [kTYPE_LIST], yyf); (void) fputc ('\n', yyf);
  7725.  yWriteNodeTYPE_LIST (yyt); break;
  7726. case kDECL_NODE: (void) fputs (Tree_NodeName [kDECL_NODE], yyf); (void) fputc ('\n', yyf);
  7727.  yWriteNodeDECL_NODE (yyt); break;
  7728. case kMODULE_DECL: (void) fputs (Tree_NodeName [kMODULE_DECL], yyf); (void) fputc ('\n', yyf);
  7729.  yWriteNodeMODULE_DECL (yyt); break;
  7730. case kPROGRAM_DECL: (void) fputs (Tree_NodeName [kPROGRAM_DECL], yyf); (void) fputc ('\n', yyf);
  7731.  yWriteNodePROGRAM_DECL (yyt); break;
  7732. case kPROC_DECL: (void) fputs (Tree_NodeName [kPROC_DECL], yyf); (void) fputc ('\n', yyf);
  7733.  yWriteNodePROC_DECL (yyt); break;
  7734. case kFUNC_DECL: (void) fputs (Tree_NodeName [kFUNC_DECL], yyf); (void) fputc ('\n', yyf);
  7735.  yWriteNodeFUNC_DECL (yyt); break;
  7736. case kBLOCK_DATA_DECL: (void) fputs (Tree_NodeName [kBLOCK_DATA_DECL], yyf); (void) fputc ('\n', yyf);
  7737.  yWriteNodeBLOCK_DATA_DECL (yyt); break;
  7738. case kTYPE_DECL: (void) fputs (Tree_NodeName [kTYPE_DECL], yyf); (void) fputc ('\n', yyf);
  7739.  yWriteNodeTYPE_DECL (yyt); break;
  7740. case kNAME_DECL: (void) fputs (Tree_NodeName [kNAME_DECL], yyf); (void) fputc ('\n', yyf);
  7741.  yWriteNodeNAME_DECL (yyt); break;
  7742. case kRENAME_DECL: (void) fputs (Tree_NodeName [kRENAME_DECL], yyf); (void) fputc ('\n', yyf);
  7743.  yWriteNodeRENAME_DECL (yyt); break;
  7744. case kENTITY_DECL: (void) fputs (Tree_NodeName [kENTITY_DECL], yyf); (void) fputc ('\n', yyf);
  7745.  yWriteNodeENTITY_DECL (yyt); break;
  7746. case kVAR_DECL: (void) fputs (Tree_NodeName [kVAR_DECL], yyf); (void) fputc ('\n', yyf);
  7747.  yWriteNodeVAR_DECL (yyt); break;
  7748. case kCOMMON_DECL: (void) fputs (Tree_NodeName [kCOMMON_DECL], yyf); (void) fputc ('\n', yyf);
  7749.  yWriteNodeCOMMON_DECL (yyt); break;
  7750. case kNAMELIST_DECL: (void) fputs (Tree_NodeName [kNAMELIST_DECL], yyf); (void) fputc ('\n', yyf);
  7751.  yWriteNodeNAMELIST_DECL (yyt); break;
  7752. case kTEMPLATE_DECL: (void) fputs (Tree_NodeName [kTEMPLATE_DECL], yyf); (void) fputc ('\n', yyf);
  7753.  yWriteNodeTEMPLATE_DECL (yyt); break;
  7754. case kPROCESSORS_DECL: (void) fputs (Tree_NodeName [kPROCESSORS_DECL], yyf); (void) fputc ('\n', yyf);
  7755.  yWriteNodePROCESSORS_DECL (yyt); break;
  7756. case kINHERIT_DECL: (void) fputs (Tree_NodeName [kINHERIT_DECL], yyf); (void) fputc ('\n', yyf);
  7757.  yWriteNodeINHERIT_DECL (yyt); break;
  7758. case kSTMT_FUNC_DECL: (void) fputs (Tree_NodeName [kSTMT_FUNC_DECL], yyf); (void) fputc ('\n', yyf);
  7759.  yWriteNodeSTMT_FUNC_DECL (yyt); break;
  7760. case kINTERFACE_DECL: (void) fputs (Tree_NodeName [kINTERFACE_DECL], yyf); (void) fputc ('\n', yyf);
  7761.  yWriteNodeINTERFACE_DECL (yyt); break;
  7762. case kEXT_PROC_DECL: (void) fputs (Tree_NodeName [kEXT_PROC_DECL], yyf); (void) fputc ('\n', yyf);
  7763.  yWriteNodeEXT_PROC_DECL (yyt); break;
  7764. case kEXT_FUNC_DECL: (void) fputs (Tree_NodeName [kEXT_FUNC_DECL], yyf); (void) fputc ('\n', yyf);
  7765.  yWriteNodeEXT_FUNC_DECL (yyt); break;
  7766. case kVAL_PARAM_DECL: (void) fputs (Tree_NodeName [kVAL_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  7767.  yWriteNodeVAL_PARAM_DECL (yyt); break;
  7768. case kVAR_PARAM_DECL: (void) fputs (Tree_NodeName [kVAR_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  7769.  yWriteNodeVAR_PARAM_DECL (yyt); break;
  7770. case kPROC_PARAM_DECL: (void) fputs (Tree_NodeName [kPROC_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  7771.  yWriteNodePROC_PARAM_DECL (yyt); break;
  7772. case kFUNC_PARAM_DECL: (void) fputs (Tree_NodeName [kFUNC_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  7773.  yWriteNodeFUNC_PARAM_DECL (yyt); break;
  7774. case kELIPSIS_PARAM_DECL: (void) fputs (Tree_NodeName [kELIPSIS_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  7775.  yWriteNodeELIPSIS_PARAM_DECL (yyt); break;
  7776. case kRET_PARAM_DECL: (void) fputs (Tree_NodeName [kRET_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  7777.  yWriteNodeRET_PARAM_DECL (yyt); break;
  7778. case kIMPLICIT_DECL: (void) fputs (Tree_NodeName [kIMPLICIT_DECL], yyf); (void) fputc ('\n', yyf);
  7779.  yWriteNodeIMPLICIT_DECL (yyt); break;
  7780. case kUSE_DECL: (void) fputs (Tree_NodeName [kUSE_DECL], yyf); (void) fputc ('\n', yyf);
  7781.  yWriteNodeUSE_DECL (yyt); break;
  7782. case kONLY_USE_DECL: (void) fputs (Tree_NodeName [kONLY_USE_DECL], yyf); (void) fputc ('\n', yyf);
  7783.  yWriteNodeONLY_USE_DECL (yyt); break;
  7784. case kEQV_DECL: (void) fputs (Tree_NodeName [kEQV_DECL], yyf); (void) fputc ('\n', yyf);
  7785.  yWriteNodeEQV_DECL (yyt); break;
  7786. case kDATA_DECL: (void) fputs (Tree_NodeName [kDATA_DECL], yyf); (void) fputc ('\n', yyf);
  7787.  yWriteNodeDATA_DECL (yyt); break;
  7788. case kDIMENSION_DECL: (void) fputs (Tree_NodeName [kDIMENSION_DECL], yyf); (void) fputc ('\n', yyf);
  7789.  yWriteNodeDIMENSION_DECL (yyt); break;
  7790. case kINIT_DATA_DECL: (void) fputs (Tree_NodeName [kINIT_DATA_DECL], yyf); (void) fputc ('\n', yyf);
  7791.  yWriteNodeINIT_DATA_DECL (yyt); break;
  7792. case kTYPESPEC_DECL: (void) fputs (Tree_NodeName [kTYPESPEC_DECL], yyf); (void) fputc ('\n', yyf);
  7793.  yWriteNodeTYPESPEC_DECL (yyt); break;
  7794. case kALLOCATABLE_DECL: (void) fputs (Tree_NodeName [kALLOCATABLE_DECL], yyf); (void) fputc ('\n', yyf);
  7795.  yWriteNodeALLOCATABLE_DECL (yyt); break;
  7796. case kEXTERNAL_DECL: (void) fputs (Tree_NodeName [kEXTERNAL_DECL], yyf); (void) fputc ('\n', yyf);
  7797.  yWriteNodeEXTERNAL_DECL (yyt); break;
  7798. case kINTENT_DECL: (void) fputs (Tree_NodeName [kINTENT_DECL], yyf); (void) fputc ('\n', yyf);
  7799.  yWriteNodeINTENT_DECL (yyt); break;
  7800. case kINTRINSIC_DECL: (void) fputs (Tree_NodeName [kINTRINSIC_DECL], yyf); (void) fputc ('\n', yyf);
  7801.  yWriteNodeINTRINSIC_DECL (yyt); break;
  7802. case kOPTIONAL_DECL: (void) fputs (Tree_NodeName [kOPTIONAL_DECL], yyf); (void) fputc ('\n', yyf);
  7803.  yWriteNodeOPTIONAL_DECL (yyt); break;
  7804. case kPOINTER_DECL: (void) fputs (Tree_NodeName [kPOINTER_DECL], yyf); (void) fputc ('\n', yyf);
  7805.  yWriteNodePOINTER_DECL (yyt); break;
  7806. case kSAVE_DECL: (void) fputs (Tree_NodeName [kSAVE_DECL], yyf); (void) fputc ('\n', yyf);
  7807.  yWriteNodeSAVE_DECL (yyt); break;
  7808. case kTARGET_DECL: (void) fputs (Tree_NodeName [kTARGET_DECL], yyf); (void) fputc ('\n', yyf);
  7809.  yWriteNodeTARGET_DECL (yyt); break;
  7810. case kPARAMETER_DECL: (void) fputs (Tree_NodeName [kPARAMETER_DECL], yyf); (void) fputc ('\n', yyf);
  7811.  yWriteNodePARAMETER_DECL (yyt); break;
  7812. case kPUBLIC_DECL: (void) fputs (Tree_NodeName [kPUBLIC_DECL], yyf); (void) fputc ('\n', yyf);
  7813.  yWriteNodePUBLIC_DECL (yyt); break;
  7814. case kPRIVATE_DECL: (void) fputs (Tree_NodeName [kPRIVATE_DECL], yyf); (void) fputc ('\n', yyf);
  7815.  yWriteNodePRIVATE_DECL (yyt); break;
  7816. case kDISTRIBUTE_DECL: (void) fputs (Tree_NodeName [kDISTRIBUTE_DECL], yyf); (void) fputc ('\n', yyf);
  7817.  yWriteNodeDISTRIBUTE_DECL (yyt); break;
  7818. case kALIGN_DECL: (void) fputs (Tree_NodeName [kALIGN_DECL], yyf); (void) fputc ('\n', yyf);
  7819.  yWriteNodeALIGN_DECL (yyt); break;
  7820. case kDYNAMIC_DECL: (void) fputs (Tree_NodeName [kDYNAMIC_DECL], yyf); (void) fputc ('\n', yyf);
  7821.  yWriteNodeDYNAMIC_DECL (yyt); break;
  7822. case kSEQUENCE_DECL: (void) fputs (Tree_NodeName [kSEQUENCE_DECL], yyf); (void) fputc ('\n', yyf);
  7823.  yWriteNodeSEQUENCE_DECL (yyt); break;
  7824. case kNOSEQUENCE_DECL: (void) fputs (Tree_NodeName [kNOSEQUENCE_DECL], yyf); (void) fputc ('\n', yyf);
  7825.  yWriteNodeNOSEQUENCE_DECL (yyt); break;
  7826. case kDECL_NODE_LIST: (void) fputs (Tree_NodeName [kDECL_NODE_LIST], yyf); (void) fputc ('\n', yyf);
  7827.  break;
  7828. case kDECL_EMPTY: (void) fputs (Tree_NodeName [kDECL_EMPTY], yyf); (void) fputc ('\n', yyf);
  7829.  break;
  7830. case kDECL_LIST: (void) fputs (Tree_NodeName [kDECL_LIST], yyf); (void) fputc ('\n', yyf);
  7831.  yWriteNodeDECL_LIST (yyt); break;
  7832. case kDISTRIBUTION_SPEC: (void) fputs (Tree_NodeName [kDISTRIBUTION_SPEC], yyf); (void) fputc ('\n', yyf);
  7833.  break;
  7834. case kHOST_DISTRIBUTION: (void) fputs (Tree_NodeName [kHOST_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  7835.  break;
  7836. case kREPL_DISTRIBUTION: (void) fputs (Tree_NodeName [kREPL_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  7837.  break;
  7838. case kNODE_DISTRIBUTION: (void) fputs (Tree_NodeName [kNODE_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  7839.  yWriteNodeNODE_DISTRIBUTION (yyt); break;
  7840. case kDISTRIBUTION_FORMAT: (void) fputs (Tree_NodeName [kDISTRIBUTION_FORMAT], yyf); (void) fputc ('\n', yyf);
  7841.  break;
  7842. case kBLOCK_DISTRIBUTION: (void) fputs (Tree_NodeName [kBLOCK_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  7843.  yWriteNodeBLOCK_DISTRIBUTION (yyt); break;
  7844. case kCYCLIC_DISTRIBUTION: (void) fputs (Tree_NodeName [kCYCLIC_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  7845.  yWriteNodeCYCLIC_DISTRIBUTION (yyt); break;
  7846. case kSERIAL_DISTRIBUTION: (void) fputs (Tree_NodeName [kSERIAL_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  7847.  break;
  7848. case kDIST_FORMAT_LIST: (void) fputs (Tree_NodeName [kDIST_FORMAT_LIST], yyf); (void) fputc ('\n', yyf);
  7849.  break;
  7850. case kDIST_EMPTY: (void) fputs (Tree_NodeName [kDIST_EMPTY], yyf); (void) fputc ('\n', yyf);
  7851.  break;
  7852. case kDIST_LIST: (void) fputs (Tree_NodeName [kDIST_LIST], yyf); (void) fputc ('\n', yyf);
  7853.  yWriteNodeDIST_LIST (yyt); break;
  7854. case kGENERIC_SPEC: (void) fputs (Tree_NodeName [kGENERIC_SPEC], yyf); (void) fputc ('\n', yyf);
  7855.  break;
  7856. case kNO_GENERIC_SPEC: (void) fputs (Tree_NodeName [kNO_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf);
  7857.  break;
  7858. case kID_GENERIC_SPEC: (void) fputs (Tree_NodeName [kID_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf);
  7859.  yWriteNodeID_GENERIC_SPEC (yyt); break;
  7860. case kOP_GENERIC_SPEC: (void) fputs (Tree_NodeName [kOP_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf);
  7861.  yWriteNodeOP_GENERIC_SPEC (yyt); break;
  7862. case kASSIGN_GENERIC_SPEC: (void) fputs (Tree_NodeName [kASSIGN_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf);
  7863.  break;
  7864. case kACF_NODE_LIST: (void) fputs (Tree_NodeName [kACF_NODE_LIST], yyf); (void) fputc ('\n', yyf);
  7865.  break;
  7866. case kACF_EMPTY: (void) fputs (Tree_NodeName [kACF_EMPTY], yyf); (void) fputc ('\n', yyf);
  7867.  break;
  7868. case kACF_LIST: (void) fputs (Tree_NodeName [kACF_LIST], yyf); (void) fputc ('\n', yyf);
  7869.  yWriteNodeACF_LIST (yyt); break;
  7870. case kACF_NODE: (void) fputs (Tree_NodeName [kACF_NODE], yyf); (void) fputc ('\n', yyf);
  7871.  yWriteNodeACF_NODE (yyt); break;
  7872. case kACF_DUMMY: (void) fputs (Tree_NodeName [kACF_DUMMY], yyf); (void) fputc ('\n', yyf);
  7873.  yWriteNodeACF_DUMMY (yyt); break;
  7874. case kACF_BASIC: (void) fputs (Tree_NodeName [kACF_BASIC], yyf); (void) fputc ('\n', yyf);
  7875.  yWriteNodeACF_BASIC (yyt); break;
  7876. case kACF_IF: (void) fputs (Tree_NodeName [kACF_IF], yyf); (void) fputc ('\n', yyf);
  7877.  yWriteNodeACF_IF (yyt); break;
  7878. case kACF_WHERE: (void) fputs (Tree_NodeName [kACF_WHERE], yyf); (void) fputc ('\n', yyf);
  7879.  yWriteNodeACF_WHERE (yyt); break;
  7880. case kACF_SWITCH: (void) fputs (Tree_NodeName [kACF_SWITCH], yyf); (void) fputc ('\n', yyf);
  7881.  yWriteNodeACF_SWITCH (yyt); break;
  7882. case kACF_ALTER: (void) fputs (Tree_NodeName [kACF_ALTER], yyf); (void) fputc ('\n', yyf);
  7883.  yWriteNodeACF_ALTER (yyt); break;
  7884. case kACF_CASE: (void) fputs (Tree_NodeName [kACF_CASE], yyf); (void) fputc ('\n', yyf);
  7885.  yWriteNodeACF_CASE (yyt); break;
  7886. case kACF_WHILE: (void) fputs (Tree_NodeName [kACF_WHILE], yyf); (void) fputc ('\n', yyf);
  7887.  yWriteNodeACF_WHILE (yyt); break;
  7888. case kACF_REPEAT: (void) fputs (Tree_NodeName [kACF_REPEAT], yyf); (void) fputc ('\n', yyf);
  7889.  yWriteNodeACF_REPEAT (yyt); break;
  7890. case kACF_WITH: (void) fputs (Tree_NodeName [kACF_WITH], yyf); (void) fputc ('\n', yyf);
  7891.  yWriteNodeACF_WITH (yyt); break;
  7892. case kACF_LOOP: (void) fputs (Tree_NodeName [kACF_LOOP], yyf); (void) fputc ('\n', yyf);
  7893.  yWriteNodeACF_LOOP (yyt); break;
  7894. case kACF_DO: (void) fputs (Tree_NodeName [kACF_DO], yyf); (void) fputc ('\n', yyf);
  7895.  yWriteNodeACF_DO (yyt); break;
  7896. case kACF_DOLOCAL: (void) fputs (Tree_NodeName [kACF_DOLOCAL], yyf); (void) fputc ('\n', yyf);
  7897.  yWriteNodeACF_DOLOCAL (yyt); break;
  7898. case kACF_DOVEC: (void) fputs (Tree_NodeName [kACF_DOVEC], yyf); (void) fputc ('\n', yyf);
  7899.  yWriteNodeACF_DOVEC (yyt); break;
  7900. case kACF_DOALL: (void) fputs (Tree_NodeName [kACF_DOALL], yyf); (void) fputc ('\n', yyf);
  7901.  yWriteNodeACF_DOALL (yyt); break;
  7902. case kACF_FORALL: (void) fputs (Tree_NodeName [kACF_FORALL], yyf); (void) fputc ('\n', yyf);
  7903.  yWriteNodeACF_FORALL (yyt); break;
  7904. case kACF_ON: (void) fputs (Tree_NodeName [kACF_ON], yyf); (void) fputc ('\n', yyf);
  7905.  yWriteNodeACF_ON (yyt); break;
  7906. case kACF_BODY: (void) fputs (Tree_NodeName [kACF_BODY], yyf); (void) fputc ('\n', yyf);
  7907.  yWriteNodeACF_BODY (yyt); break;
  7908. case kACF_FLOW_GRAPH: (void) fputs (Tree_NodeName [kACF_FLOW_GRAPH], yyf); (void) fputc ('\n', yyf);
  7909.  yWriteNodeACF_FLOW_GRAPH (yyt); break;
  7910. case kACF_ENTRY: (void) fputs (Tree_NodeName [kACF_ENTRY], yyf); (void) fputc ('\n', yyf);
  7911.  yWriteNodeACF_ENTRY (yyt); break;
  7912. case kACF_FLOW_KIND: (void) fputs (Tree_NodeName [kACF_FLOW_KIND], yyf); (void) fputc ('\n', yyf);
  7913.  break;
  7914. case kACF_COMPLEX_FLOW: (void) fputs (Tree_NodeName [kACF_COMPLEX_FLOW], yyf); (void) fputc ('\n', yyf);
  7915.  break;
  7916. case kACF_INTERVAL_FLOW: (void) fputs (Tree_NodeName [kACF_INTERVAL_FLOW], yyf); (void) fputc ('\n', yyf);
  7917.  break;
  7918. case kACF_SIMPLE_FLOW: (void) fputs (Tree_NodeName [kACF_SIMPLE_FLOW], yyf); (void) fputc ('\n', yyf);
  7919.  break;
  7920. case kSELECTED_ACF_NODE_LIST: (void) fputs (Tree_NodeName [kSELECTED_ACF_NODE_LIST], yyf); (void) fputc ('\n', yyf);
  7921.  break;
  7922. case kSELECTED_ACF_EMPTY: (void) fputs (Tree_NodeName [kSELECTED_ACF_EMPTY], yyf); (void) fputc ('\n', yyf);
  7923.  break;
  7924. case kSELECTED_ACF_LIST: (void) fputs (Tree_NodeName [kSELECTED_ACF_LIST], yyf); (void) fputc ('\n', yyf);
  7925.  yWriteNodeSELECTED_ACF_LIST (yyt); break;
  7926. case kSELECTED_ACF_NODE: (void) fputs (Tree_NodeName [kSELECTED_ACF_NODE], yyf); (void) fputc ('\n', yyf);
  7927.  yWriteNodeSELECTED_ACF_NODE (yyt); break;
  7928. case kBT_STMT: (void) fputs (Tree_NodeName [kBT_STMT], yyf); (void) fputc ('\n', yyf);
  7929.  break;
  7930. case kEXP_STMT: (void) fputs (Tree_NodeName [kEXP_STMT], yyf); (void) fputc ('\n', yyf);
  7931.  yWriteNodeEXP_STMT (yyt); break;
  7932. case kASSIGN_STMT: (void) fputs (Tree_NodeName [kASSIGN_STMT], yyf); (void) fputc ('\n', yyf);
  7933.  yWriteNodeASSIGN_STMT (yyt); break;
  7934. case kPTR_ASSIGN_STMT: (void) fputs (Tree_NodeName [kPTR_ASSIGN_STMT], yyf); (void) fputc ('\n', yyf);
  7935.  yWriteNodePTR_ASSIGN_STMT (yyt); break;
  7936. case kLABEL_ASSIGN_STMT: (void) fputs (Tree_NodeName [kLABEL_ASSIGN_STMT], yyf); (void) fputc ('\n', yyf);
  7937.  yWriteNodeLABEL_ASSIGN_STMT (yyt); break;
  7938. case kCALL_STMT: (void) fputs (Tree_NodeName [kCALL_STMT], yyf); (void) fputc ('\n', yyf);
  7939.  yWriteNodeCALL_STMT (yyt); break;
  7940. case kIO_STMT: (void) fputs (Tree_NodeName [kIO_STMT], yyf); (void) fputc ('\n', yyf);
  7941.  yWriteNodeIO_STMT (yyt); break;
  7942. case kGOTO_STMT: (void) fputs (Tree_NodeName [kGOTO_STMT], yyf); (void) fputc ('\n', yyf);
  7943.  yWriteNodeGOTO_STMT (yyt); break;
  7944. case kASS_GOTO_STMT: (void) fputs (Tree_NodeName [kASS_GOTO_STMT], yyf); (void) fputc ('\n', yyf);
  7945.  yWriteNodeASS_GOTO_STMT (yyt); break;
  7946. case kCOMP_GOTO_STMT: (void) fputs (Tree_NodeName [kCOMP_GOTO_STMT], yyf); (void) fputc ('\n', yyf);
  7947.  yWriteNodeCOMP_GOTO_STMT (yyt); break;
  7948. case kCOMP_IF_STMT: (void) fputs (Tree_NodeName [kCOMP_IF_STMT], yyf); (void) fputc ('\n', yyf);
  7949.  yWriteNodeCOMP_IF_STMT (yyt); break;
  7950. case kRETURN_STMT: (void) fputs (Tree_NodeName [kRETURN_STMT], yyf); (void) fputc ('\n', yyf);
  7951.  yWriteNodeRETURN_STMT (yyt); break;
  7952. case kPAUSE_STMT: (void) fputs (Tree_NodeName [kPAUSE_STMT], yyf); (void) fputc ('\n', yyf);
  7953.  yWriteNodePAUSE_STMT (yyt); break;
  7954. case kEXIT_STMT: (void) fputs (Tree_NodeName [kEXIT_STMT], yyf); (void) fputc ('\n', yyf);
  7955.  yWriteNodeEXIT_STMT (yyt); break;
  7956. case kCYCLE_STMT: (void) fputs (Tree_NodeName [kCYCLE_STMT], yyf); (void) fputc ('\n', yyf);
  7957.  yWriteNodeCYCLE_STMT (yyt); break;
  7958. case kSTOP_STMT: (void) fputs (Tree_NodeName [kSTOP_STMT], yyf); (void) fputc ('\n', yyf);
  7959.  yWriteNodeSTOP_STMT (yyt); break;
  7960. case kFORMAT_STMT: (void) fputs (Tree_NodeName [kFORMAT_STMT], yyf); (void) fputc ('\n', yyf);
  7961.  yWriteNodeFORMAT_STMT (yyt); break;
  7962. case kALLOCATE_STMT: (void) fputs (Tree_NodeName [kALLOCATE_STMT], yyf); (void) fputc ('\n', yyf);
  7963.  yWriteNodeALLOCATE_STMT (yyt); break;
  7964. case kDEALLOCATE_STMT: (void) fputs (Tree_NodeName [kDEALLOCATE_STMT], yyf); (void) fputc ('\n', yyf);
  7965.  yWriteNodeDEALLOCATE_STMT (yyt); break;
  7966. case kNULLIFY_STMT: (void) fputs (Tree_NodeName [kNULLIFY_STMT], yyf); (void) fputc ('\n', yyf);
  7967.  yWriteNodeNULLIFY_STMT (yyt); break;
  7968. case kREDUCE_STMT: (void) fputs (Tree_NodeName [kREDUCE_STMT], yyf); (void) fputc ('\n', yyf);
  7969.  yWriteNodeREDUCE_STMT (yyt); break;
  7970. case kGLOBAL_STMT: (void) fputs (Tree_NodeName [kGLOBAL_STMT], yyf); (void) fputc ('\n', yyf);
  7971.  yWriteNodeGLOBAL_STMT (yyt); break;
  7972. case kALIGN_STMT: (void) fputs (Tree_NodeName [kALIGN_STMT], yyf); (void) fputc ('\n', yyf);
  7973.  yWriteNodeALIGN_STMT (yyt); break;
  7974. case kDISTRIBUTE_STMT: (void) fputs (Tree_NodeName [kDISTRIBUTE_STMT], yyf); (void) fputc ('\n', yyf);
  7975.  yWriteNodeDISTRIBUTE_STMT (yyt); break;
  7976. case kLABEL_USE_LIST: (void) fputs (Tree_NodeName [kLABEL_USE_LIST], yyf); (void) fputc ('\n', yyf);
  7977.  break;
  7978. case kLABEL_EMPTY: (void) fputs (Tree_NodeName [kLABEL_EMPTY], yyf); (void) fputc ('\n', yyf);
  7979.  break;
  7980. case kLABEL_LIST: (void) fputs (Tree_NodeName [kLABEL_LIST], yyf); (void) fputc ('\n', yyf);
  7981.  yWriteNodeLABEL_LIST (yyt); break;
  7982. case kOP: (void) fputs (Tree_NodeName [kOP], yyf); (void) fputc ('\n', yyf);
  7983.  break;
  7984. case kOP_EQ: (void) fputs (Tree_NodeName [kOP_EQ], yyf); (void) fputc ('\n', yyf);
  7985.  break;
  7986. case kOP_NE: (void) fputs (Tree_NodeName [kOP_NE], yyf); (void) fputc ('\n', yyf);
  7987.  break;
  7988. case kOP_LT: (void) fputs (Tree_NodeName [kOP_LT], yyf); (void) fputc ('\n', yyf);
  7989.  break;
  7990. case kOP_GT: (void) fputs (Tree_NodeName [kOP_GT], yyf); (void) fputc ('\n', yyf);
  7991.  break;
  7992. case kOP_GE: (void) fputs (Tree_NodeName [kOP_GE], yyf); (void) fputc ('\n', yyf);
  7993.  break;
  7994. case kOP_LE: (void) fputs (Tree_NodeName [kOP_LE], yyf); (void) fputc ('\n', yyf);
  7995.  break;
  7996. case kOP_PLUS: (void) fputs (Tree_NodeName [kOP_PLUS], yyf); (void) fputc ('\n', yyf);
  7997.  break;
  7998. case kOP_MINUS: (void) fputs (Tree_NodeName [kOP_MINUS], yyf); (void) fputc ('\n', yyf);
  7999.  break;
  8000. case kOP_XOR: (void) fputs (Tree_NodeName [kOP_XOR], yyf); (void) fputc ('\n', yyf);
  8001.  break;
  8002. case kOP_OR: (void) fputs (Tree_NodeName [kOP_OR], yyf); (void) fputc ('\n', yyf);
  8003.  break;
  8004. case kOP_CONCAT: (void) fputs (Tree_NodeName [kOP_CONCAT], yyf); (void) fputc ('\n', yyf);
  8005.  break;
  8006. case kOP_TIMES: (void) fputs (Tree_NodeName [kOP_TIMES], yyf); (void) fputc ('\n', yyf);
  8007.  break;
  8008. case kOP_DIVIDE: (void) fputs (Tree_NodeName [kOP_DIVIDE], yyf); (void) fputc ('\n', yyf);
  8009.  break;
  8010. case kOP_DIV: (void) fputs (Tree_NodeName [kOP_DIV], yyf); (void) fputc ('\n', yyf);
  8011.  break;
  8012. case kOP_AND: (void) fputs (Tree_NodeName [kOP_AND], yyf); (void) fputc ('\n', yyf);
  8013.  break;
  8014. case kOP_EQV: (void) fputs (Tree_NodeName [kOP_EQV], yyf); (void) fputc ('\n', yyf);
  8015.  break;
  8016. case kOP_NEQV: (void) fputs (Tree_NodeName [kOP_NEQV], yyf); (void) fputc ('\n', yyf);
  8017.  break;
  8018. case kOP_EXPO: (void) fputs (Tree_NodeName [kOP_EXPO], yyf); (void) fputc ('\n', yyf);
  8019.  break;
  8020. case kOP_MOD: (void) fputs (Tree_NodeName [kOP_MOD], yyf); (void) fputc ('\n', yyf);
  8021.  break;
  8022. case kOP_IN: (void) fputs (Tree_NodeName [kOP_IN], yyf); (void) fputc ('\n', yyf);
  8023.  break;
  8024. case kOP_DEFINED: (void) fputs (Tree_NodeName [kOP_DEFINED], yyf); (void) fputc ('\n', yyf);
  8025.  yWriteNodeOP_DEFINED (yyt); break;
  8026. case kOP_ASSIGN: (void) fputs (Tree_NodeName [kOP_ASSIGN], yyf); (void) fputc ('\n', yyf);
  8027.  break;
  8028. case kOP_LEFT: (void) fputs (Tree_NodeName [kOP_LEFT], yyf); (void) fputc ('\n', yyf);
  8029.  break;
  8030. case kOP_RIGHT: (void) fputs (Tree_NodeName [kOP_RIGHT], yyf); (void) fputc ('\n', yyf);
  8031.  break;
  8032. case kOP_LIST: (void) fputs (Tree_NodeName [kOP_LIST], yyf); (void) fputc ('\n', yyf);
  8033.  break;
  8034. case kOP_IOR: (void) fputs (Tree_NodeName [kOP_IOR], yyf); (void) fputc ('\n', yyf);
  8035.  break;
  8036. case kOP_IXOR: (void) fputs (Tree_NodeName [kOP_IXOR], yyf); (void) fputc ('\n', yyf);
  8037.  break;
  8038. case kOP_IAND: (void) fputs (Tree_NodeName [kOP_IAND], yyf); (void) fputc ('\n', yyf);
  8039.  break;
  8040. case kOP1_NOT: (void) fputs (Tree_NodeName [kOP1_NOT], yyf); (void) fputc ('\n', yyf);
  8041.  break;
  8042. case kOP1_SIGN: (void) fputs (Tree_NodeName [kOP1_SIGN], yyf); (void) fputc ('\n', yyf);
  8043.  break;
  8044. case kOP1_INOT: (void) fputs (Tree_NodeName [kOP1_INOT], yyf); (void) fputc ('\n', yyf);
  8045.  break;
  8046. case kOP1_SIZE: (void) fputs (Tree_NodeName [kOP1_SIZE], yyf); (void) fputc ('\n', yyf);
  8047.  break;
  8048. case kOP1_DEC: (void) fputs (Tree_NodeName [kOP1_DEC], yyf); (void) fputc ('\n', yyf);
  8049.  break;
  8050. case kOP1_INC: (void) fputs (Tree_NodeName [kOP1_INC], yyf); (void) fputc ('\n', yyf);
  8051.  break;
  8052. case kOP1_ADDRESS: (void) fputs (Tree_NodeName [kOP1_ADDRESS], yyf); (void) fputc ('\n', yyf);
  8053.  break;
  8054. case kOP1_DEREF: (void) fputs (Tree_NodeName [kOP1_DEREF], yyf); (void) fputc ('\n', yyf);
  8055.  break;
  8056. case kBT_EXP: (void) fputs (Tree_NodeName [kBT_EXP], yyf); (void) fputc ('\n', yyf);
  8057.  break;
  8058. case kDUMMY_EXP: (void) fputs (Tree_NodeName [kDUMMY_EXP], yyf); (void) fputc ('\n', yyf);
  8059.  break;
  8060. case kCONST_EXP: (void) fputs (Tree_NodeName [kCONST_EXP], yyf); (void) fputc ('\n', yyf);
  8061.  yWriteNodeCONST_EXP (yyt); break;
  8062. case kOP_EXP: (void) fputs (Tree_NodeName [kOP_EXP], yyf); (void) fputc ('\n', yyf);
  8063.  yWriteNodeOP_EXP (yyt); break;
  8064. case kOP1_EXP: (void) fputs (Tree_NodeName [kOP1_EXP], yyf); (void) fputc ('\n', yyf);
  8065.  yWriteNodeOP1_EXP (yyt); break;
  8066. case kSLICE_EXP: (void) fputs (Tree_NodeName [kSLICE_EXP], yyf); (void) fputc ('\n', yyf);
  8067.  yWriteNodeSLICE_EXP (yyt); break;
  8068. case kPOSTFIX_EXP: (void) fputs (Tree_NodeName [kPOSTFIX_EXP], yyf); (void) fputc ('\n', yyf);
  8069.  yWriteNodePOSTFIX_EXP (yyt); break;
  8070. case kCALL_EXP: (void) fputs (Tree_NodeName [kCALL_EXP], yyf); (void) fputc ('\n', yyf);
  8071.  yWriteNodeCALL_EXP (yyt); break;
  8072. case kCAST_EXP: (void) fputs (Tree_NodeName [kCAST_EXP], yyf); (void) fputc ('\n', yyf);
  8073.  yWriteNodeCAST_EXP (yyt); break;
  8074. case kINDEXED_EXP: (void) fputs (Tree_NodeName [kINDEXED_EXP], yyf); (void) fputc ('\n', yyf);
  8075.  yWriteNodeINDEXED_EXP (yyt); break;
  8076. case kSELECTED_EXP: (void) fputs (Tree_NodeName [kSELECTED_EXP], yyf); (void) fputc ('\n', yyf);
  8077.  yWriteNodeSELECTED_EXP (yyt); break;
  8078. case kASSIGN_EXP: (void) fputs (Tree_NodeName [kASSIGN_EXP], yyf); (void) fputc ('\n', yyf);
  8079.  yWriteNodeASSIGN_EXP (yyt); break;
  8080. case kUSED_EXP: (void) fputs (Tree_NodeName [kUSED_EXP], yyf); (void) fputc ('\n', yyf);
  8081.  yWriteNodeUSED_EXP (yyt); break;
  8082. case kCOND_EXP: (void) fputs (Tree_NodeName [kCOND_EXP], yyf); (void) fputc ('\n', yyf);
  8083.  yWriteNodeCOND_EXP (yyt); break;
  8084. case kVAR_EXP: (void) fputs (Tree_NodeName [kVAR_EXP], yyf); (void) fputc ('\n', yyf);
  8085.  yWriteNodeVAR_EXP (yyt); break;
  8086. case kFUNC_CALL_EXP: (void) fputs (Tree_NodeName [kFUNC_CALL_EXP], yyf); (void) fputc ('\n', yyf);
  8087.  yWriteNodeFUNC_CALL_EXP (yyt); break;
  8088. case kNAMED_EXP: (void) fputs (Tree_NodeName [kNAMED_EXP], yyf); (void) fputc ('\n', yyf);
  8089.  yWriteNodeNAMED_EXP (yyt); break;
  8090. case kDO_EXP: (void) fputs (Tree_NodeName [kDO_EXP], yyf); (void) fputc ('\n', yyf);
  8091.  yWriteNodeDO_EXP (yyt); break;
  8092. case kTYPE_EXP: (void) fputs (Tree_NodeName [kTYPE_EXP], yyf); (void) fputc ('\n', yyf);
  8093.  yWriteNodeTYPE_EXP (yyt); break;
  8094. case kARRAY_EXP: (void) fputs (Tree_NodeName [kARRAY_EXP], yyf); (void) fputc ('\n', yyf);
  8095.  yWriteNodeARRAY_EXP (yyt); break;
  8096. case kBT_EXP_LIST: (void) fputs (Tree_NodeName [kBT_EXP_LIST], yyf); (void) fputc ('\n', yyf);
  8097.  break;
  8098. case kBTE_EMPTY: (void) fputs (Tree_NodeName [kBTE_EMPTY], yyf); (void) fputc ('\n', yyf);
  8099.  break;
  8100. case kBTE_LIST: (void) fputs (Tree_NodeName [kBTE_LIST], yyf); (void) fputc ('\n', yyf);
  8101.  yWriteNodeBTE_LIST (yyt); break;
  8102. case kBT_VAR: (void) fputs (Tree_NodeName [kBT_VAR], yyf); (void) fputc ('\n', yyf);
  8103.  break;
  8104. case kDUMMY_VAR: (void) fputs (Tree_NodeName [kDUMMY_VAR], yyf); (void) fputc ('\n', yyf);
  8105.  break;
  8106. case kUSED_VAR: (void) fputs (Tree_NodeName [kUSED_VAR], yyf); (void) fputc ('\n', yyf);
  8107.  yWriteNodeUSED_VAR (yyt); break;
  8108. case kINDEXED_VAR: (void) fputs (Tree_NodeName [kINDEXED_VAR], yyf); (void) fputc ('\n', yyf);
  8109.  yWriteNodeINDEXED_VAR (yyt); break;
  8110. case kSUBSTRING_VAR: (void) fputs (Tree_NodeName [kSUBSTRING_VAR], yyf); (void) fputc ('\n', yyf);
  8111.  yWriteNodeSUBSTRING_VAR (yyt); break;
  8112. case kSELECTED_VAR: (void) fputs (Tree_NodeName [kSELECTED_VAR], yyf); (void) fputc ('\n', yyf);
  8113.  yWriteNodeSELECTED_VAR (yyt); break;
  8114. case kLOOP_VAR: (void) fputs (Tree_NodeName [kLOOP_VAR], yyf); (void) fputc ('\n', yyf);
  8115.  yWriteNodeLOOP_VAR (yyt); break;
  8116. case kADDR: (void) fputs (Tree_NodeName [kADDR], yyf); (void) fputc ('\n', yyf);
  8117.  yWriteNodeADDR (yyt); break;
  8118. case kDO_VAR: (void) fputs (Tree_NodeName [kDO_VAR], yyf); (void) fputc ('\n', yyf);
  8119.  yWriteNodeDO_VAR (yyt); break;
  8120. case kBT_VAR_LIST: (void) fputs (Tree_NodeName [kBT_VAR_LIST], yyf); (void) fputc ('\n', yyf);
  8121.  break;
  8122. case kBTV_EMPTY: (void) fputs (Tree_NodeName [kBTV_EMPTY], yyf); (void) fputc ('\n', yyf);
  8123.  break;
  8124. case kBTV_LIST: (void) fputs (Tree_NodeName [kBTV_LIST], yyf); (void) fputc ('\n', yyf);
  8125.  yWriteNodeBTV_LIST (yyt); break;
  8126. case kBT_PARAM: (void) fputs (Tree_NodeName [kBT_PARAM], yyf); (void) fputc ('\n', yyf);
  8127.  break;
  8128. case kVAR_PARAM: (void) fputs (Tree_NodeName [kVAR_PARAM], yyf); (void) fputc ('\n', yyf);
  8129.  yWriteNodeVAR_PARAM (yyt); break;
  8130. case kVALUE_PARAM: (void) fputs (Tree_NodeName [kVALUE_PARAM], yyf); (void) fputc ('\n', yyf);
  8131.  yWriteNodeVALUE_PARAM (yyt); break;
  8132. case kNAMED_PARAM: (void) fputs (Tree_NodeName [kNAMED_PARAM], yyf); (void) fputc ('\n', yyf);
  8133.  yWriteNodeNAMED_PARAM (yyt); break;
  8134. case kPROC_PARAM: (void) fputs (Tree_NodeName [kPROC_PARAM], yyf); (void) fputc ('\n', yyf);
  8135.  yWriteNodePROC_PARAM (yyt); break;
  8136. case kFUNC_PARAM: (void) fputs (Tree_NodeName [kFUNC_PARAM], yyf); (void) fputc ('\n', yyf);
  8137.  yWriteNodeFUNC_PARAM (yyt); break;
  8138. case kFORMAT_PARAM: (void) fputs (Tree_NodeName [kFORMAT_PARAM], yyf); (void) fputc ('\n', yyf);
  8139.  yWriteNodeFORMAT_PARAM (yyt); break;
  8140. case kRETURN_PARAM: (void) fputs (Tree_NodeName [kRETURN_PARAM], yyf); (void) fputc ('\n', yyf);
  8141.  yWriteNodeRETURN_PARAM (yyt); break;
  8142. case kNO_PARAM: (void) fputs (Tree_NodeName [kNO_PARAM], yyf); (void) fputc ('\n', yyf);
  8143.  break;
  8144. case kBT_PARAM_LIST: (void) fputs (Tree_NodeName [kBT_PARAM_LIST], yyf); (void) fputc ('\n', yyf);
  8145.  break;
  8146. case kBTP_EMPTY: (void) fputs (Tree_NodeName [kBTP_EMPTY], yyf); (void) fputc ('\n', yyf);
  8147.  break;
  8148. case kBTP_LIST: (void) fputs (Tree_NodeName [kBTP_LIST], yyf); (void) fputc ('\n', yyf);
  8149.  yWriteNodeBTP_LIST (yyt); break;
  8150. case kCONSTANT: (void) fputs (Tree_NodeName [kCONSTANT], yyf); (void) fputc ('\n', yyf);
  8151.  break;
  8152. case kBOOL_CONSTANT: (void) fputs (Tree_NodeName [kBOOL_CONSTANT], yyf); (void) fputc ('\n', yyf);
  8153.  yWriteNodeBOOL_CONSTANT (yyt); break;
  8154. case kINT_CONSTANT: (void) fputs (Tree_NodeName [kINT_CONSTANT], yyf); (void) fputc ('\n', yyf);
  8155.  yWriteNodeINT_CONSTANT (yyt); break;
  8156. case kREAL_CONSTANT: (void) fputs (Tree_NodeName [kREAL_CONSTANT], yyf); (void) fputc ('\n', yyf);
  8157.  yWriteNodeREAL_CONSTANT (yyt); break;
  8158. case kDREAL_CONSTANT: (void) fputs (Tree_NodeName [kDREAL_CONSTANT], yyf); (void) fputc ('\n', yyf);
  8159.  yWriteNodeDREAL_CONSTANT (yyt); break;
  8160. case kCHAR_CONSTANT: (void) fputs (Tree_NodeName [kCHAR_CONSTANT], yyf); (void) fputc ('\n', yyf);
  8161.  yWriteNodeCHAR_CONSTANT (yyt); break;
  8162. case kSTRING_CONSTANT: (void) fputs (Tree_NodeName [kSTRING_CONSTANT], yyf); (void) fputc ('\n', yyf);
  8163.  yWriteNodeSTRING_CONSTANT (yyt); break;
  8164. case kCOMPLEX_CONSTANT: (void) fputs (Tree_NodeName [kCOMPLEX_CONSTANT], yyf); (void) fputc ('\n', yyf);
  8165.  yWriteNodeCOMPLEX_CONSTANT (yyt); break;
  8166. case kPROC_OBJ: (void) fputs (Tree_NodeName [kPROC_OBJ], yyf); (void) fputc ('\n', yyf);
  8167.  yWriteNodePROC_OBJ (yyt); break;
  8168. case kVAR_OBJ: (void) fputs (Tree_NodeName [kVAR_OBJ], yyf); (void) fputc ('\n', yyf);
  8169.  yWriteNodeVAR_OBJ (yyt); break;
  8170. case kTYPE_OBJ: (void) fputs (Tree_NodeName [kTYPE_OBJ], yyf); (void) fputc ('\n', yyf);
  8171.  yWriteNodeTYPE_OBJ (yyt); break;
  8172. case kREC_COMP: (void) fputs (Tree_NodeName [kREC_COMP], yyf); (void) fputc ('\n', yyf);
  8173.  yWriteNodeREC_COMP (yyt); break;
  8174.  default: ;
  8175.  }
  8176. }
  8177.  
  8178. static short yyIndentLevel;
  8179.  
  8180. void WriteTree
  8181. # if defined __STDC__ | defined __cplusplus
  8182.  (FILE * yyyf, tTree yyt)
  8183. # else
  8184.  (yyyf, yyt) FILE * yyyf; tTree yyt;
  8185. # endif
  8186. {
  8187.  short yySaveLevel = yyIndentLevel;
  8188.  yyf = yyyf;
  8189.  if (yyRecursionLevel ++ == 0) yyLabelCount = 0;
  8190.  yyMark (yyt);
  8191.  yyIndentLevel = 0;
  8192.  yyWriteTree (yyt);
  8193.  yyIndentLevel = yySaveLevel;
  8194.  yyRecursionLevel --;
  8195. }
  8196.  
  8197. static void yyIndentSelector
  8198. # if defined __STDC__ | defined __cplusplus
  8199.  (char * yys)
  8200. # else
  8201.  (yys) char * yys;
  8202. # endif
  8203. {
  8204.  register int yyi;
  8205.  for (yyi = 1; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);
  8206.  yyWriteSelector (yys);
  8207. }
  8208.  
  8209. static void yyIndentSelectorTree
  8210. # if defined __STDC__ | defined __cplusplus
  8211.  (char * yys, tTree yyt)
  8212. # else
  8213.  (yys, yyt) char * yys; tTree yyt;
  8214. # endif
  8215. { yyIndentSelector (yys); writetTree (yyt) }
  8216.  
  8217. static void yWriteCOMP_UNIT
  8218. # if defined __STDC__ | defined __cplusplus
  8219.  (tTree yyt)
  8220. # else
  8221.  (yyt) tTree yyt;
  8222. # endif
  8223. {
  8224.  (void) fputs (Tree_NodeName [kCOMP_UNIT], yyf); (void) fputc ('\n', yyf);
  8225. }
  8226.  
  8227. static void yWriteBODY_NODE
  8228. # if defined __STDC__ | defined __cplusplus
  8229.  (tTree yyt)
  8230. # else
  8231.  (yyt) tTree yyt;
  8232. # endif
  8233. {
  8234.  (void) fputs (Tree_NodeName [kBODY_NODE], yyf); (void) fputc ('\n', yyf);
  8235.  yyIndentSelectorTree ("DECLS", yyt->BODY_NODE.DECLS);
  8236.  yyIndentSelectorTree ("STATS", yyt->BODY_NODE.STATS);
  8237. }
  8238.  
  8239. static void yWriteINTEGER_TYPE
  8240. # if defined __STDC__ | defined __cplusplus
  8241.  (tTree yyt)
  8242. # else
  8243.  (yyt) tTree yyt;
  8244. # endif
  8245. {
  8246.  (void) fputs (Tree_NodeName [kINTEGER_TYPE], yyf); (void) fputc ('\n', yyf);
  8247.  yyIndentSelector ("size"); writeint (yyt->INTEGER_TYPE.size) yyWriteNl ();
  8248. }
  8249.  
  8250. static void yWriteCARDINAL_TYPE
  8251. # if defined __STDC__ | defined __cplusplus
  8252.  (tTree yyt)
  8253. # else
  8254.  (yyt) tTree yyt;
  8255. # endif
  8256. {
  8257.  (void) fputs (Tree_NodeName [kCARDINAL_TYPE], yyf); (void) fputc ('\n', yyf);
  8258.  yyIndentSelector ("size"); writeint (yyt->CARDINAL_TYPE.size) yyWriteNl ();
  8259. }
  8260.  
  8261. static void yWriteREAL_TYPE
  8262. # if defined __STDC__ | defined __cplusplus
  8263.  (tTree yyt)
  8264. # else
  8265.  (yyt) tTree yyt;
  8266. # endif
  8267. {
  8268.  (void) fputs (Tree_NodeName [kREAL_TYPE], yyf); (void) fputc ('\n', yyf);
  8269.  yyIndentSelector ("size"); writeint (yyt->REAL_TYPE.size) yyWriteNl ();
  8270. }
  8271.  
  8272. static void yWriteBOOLEAN_TYPE
  8273. # if defined __STDC__ | defined __cplusplus
  8274.  (tTree yyt)
  8275. # else
  8276.  (yyt) tTree yyt;
  8277. # endif
  8278. {
  8279.  (void) fputs (Tree_NodeName [kBOOLEAN_TYPE], yyf); (void) fputc ('\n', yyf);
  8280.  yyIndentSelector ("size"); writeint (yyt->BOOLEAN_TYPE.size) yyWriteNl ();
  8281. }
  8282.  
  8283. static void yWriteCOMPLEX_TYPE
  8284. # if defined __STDC__ | defined __cplusplus
  8285.  (tTree yyt)
  8286. # else
  8287.  (yyt) tTree yyt;
  8288. # endif
  8289. {
  8290.  (void) fputs (Tree_NodeName [kCOMPLEX_TYPE], yyf); (void) fputc ('\n', yyf);
  8291.  yyIndentSelector ("size"); writeint (yyt->COMPLEX_TYPE.size) yyWriteNl ();
  8292. }
  8293.  
  8294. static void yWriteSTRING_TYPE
  8295. # if defined __STDC__ | defined __cplusplus
  8296.  (tTree yyt)
  8297. # else
  8298.  (yyt) tTree yyt;
  8299. # endif
  8300. {
  8301.  (void) fputs (Tree_NodeName [kSTRING_TYPE], yyf); (void) fputc ('\n', yyf);
  8302. }
  8303.  
  8304. static void yWriteINDEX_TYPE
  8305. # if defined __STDC__ | defined __cplusplus
  8306.  (tTree yyt)
  8307. # else
  8308.  (yyt) tTree yyt;
  8309. # endif
  8310. {
  8311.  (void) fputs (Tree_NodeName [kINDEX_TYPE], yyf); (void) fputc ('\n', yyf);
  8312.  yyIndentSelectorTree ("LOWER", yyt->INDEX_TYPE.LOWER);
  8313.  yyIndentSelector ("left_overlap"); writeint (yyt->INDEX_TYPE.left_overlap) yyWriteNl ();
  8314.  yyIndentSelector ("right_overlap"); writeint (yyt->INDEX_TYPE.right_overlap) yyWriteNl ();
  8315. }
  8316.  
  8317. static void yWriteTYPE_ID
  8318. # if defined __STDC__ | defined __cplusplus
  8319.  (tTree yyt)
  8320. # else
  8321.  (yyt) tTree yyt;
  8322. # endif
  8323. {
  8324.  (void) fputs (Tree_NodeName [kTYPE_ID], yyf); (void) fputc ('\n', yyf);
  8325. }
  8326.  
  8327. static void yWriteARRAY_TYPE
  8328. # if defined __STDC__ | defined __cplusplus
  8329.  (tTree yyt)
  8330. # else
  8331.  (yyt) tTree yyt;
  8332. # endif
  8333. {
  8334.  (void) fputs (Tree_NodeName [kARRAY_TYPE], yyf); (void) fputc ('\n', yyf);
  8335.  yyIndentSelectorTree ("ARRAY_INDEX_TYPES", yyt->ARRAY_TYPE.ARRAY_INDEX_TYPES);
  8336. }
  8337.  
  8338. static void yWriteRECORD_TYPE
  8339. # if defined __STDC__ | defined __cplusplus
  8340.  (tTree yyt)
  8341. # else
  8342.  (yyt) tTree yyt;
  8343. # endif
  8344. {
  8345.  (void) fputs (Tree_NodeName [kRECORD_TYPE], yyf); (void) fputc ('\n', yyf);
  8346.  yyIndentSelector ("Name"); writetIdent (yyt->RECORD_TYPE.Name) yyWriteNl ();
  8347. }
  8348.  
  8349. static void yWriteUNION_TYPE
  8350. # if defined __STDC__ | defined __cplusplus
  8351.  (tTree yyt)
  8352. # else
  8353.  (yyt) tTree yyt;
  8354. # endif
  8355. {
  8356.  (void) fputs (Tree_NodeName [kUNION_TYPE], yyf); (void) fputc ('\n', yyf);
  8357.  yyIndentSelector ("Name"); writetIdent (yyt->UNION_TYPE.Name) yyWriteNl ();
  8358. }
  8359.  
  8360. static void yWriteENUM_TYPE
  8361. # if defined __STDC__ | defined __cplusplus
  8362.  (tTree yyt)
  8363. # else
  8364.  (yyt) tTree yyt;
  8365. # endif
  8366. {
  8367.  (void) fputs (Tree_NodeName [kENUM_TYPE], yyf); (void) fputc ('\n', yyf);
  8368.  yyIndentSelector ("Name"); writetIdent (yyt->ENUM_TYPE.Name) yyWriteNl ();
  8369. }
  8370.  
  8371. static void yWriteDYNAMIC
  8372. # if defined __STDC__ | defined __cplusplus
  8373.  (tTree yyt)
  8374. # else
  8375.  (yyt) tTree yyt;
  8376. # endif
  8377. {
  8378.  (void) fputs (Tree_NodeName [kDYNAMIC], yyf); (void) fputc ('\n', yyf);
  8379.  yyIndentSelector ("Shape"); writetTree (yyt->DYNAMIC.Shape) yyWriteNl ();
  8380.  yyIndentSelector ("left_overlap"); writeint (yyt->DYNAMIC.left_overlap) yyWriteNl ();
  8381.  yyIndentSelector ("right_overlap"); writeint (yyt->DYNAMIC.right_overlap) yyWriteNl ();
  8382. }
  8383.  
  8384. static void yWritePOINTER_TYPE
  8385. # if defined __STDC__ | defined __cplusplus
  8386.  (tTree yyt)
  8387. # else
  8388.  (yyt) tTree yyt;
  8389. # endif
  8390. {
  8391.  (void) fputs (Tree_NodeName [kPOINTER_TYPE], yyf); (void) fputc ('\n', yyf);
  8392. }
  8393.  
  8394. static void yWriteARRAY1_TYPE
  8395. # if defined __STDC__ | defined __cplusplus
  8396.  (tTree yyt)
  8397. # else
  8398.  (yyt) tTree yyt;
  8399. # endif
  8400. {
  8401.  (void) fputs (Tree_NodeName [kARRAY1_TYPE], yyf); (void) fputc ('\n', yyf);
  8402.  yyIndentSelectorTree ("SIZE", yyt->ARRAY1_TYPE.SIZE);
  8403. }
  8404.  
  8405. static void yWriteFUNCTION_TYPE
  8406. # if defined __STDC__ | defined __cplusplus
  8407.  (tTree yyt)
  8408. # else
  8409.  (yyt) tTree yyt;
  8410. # endif
  8411. {
  8412.  (void) fputs (Tree_NodeName [kFUNCTION_TYPE], yyf); (void) fputc ('\n', yyf);
  8413.  yyIndentSelectorTree ("FORMALS", yyt->FUNCTION_TYPE.FORMALS);
  8414. }
  8415.  
  8416. static void yWriteTYPE_LIST
  8417. # if defined __STDC__ | defined __cplusplus
  8418.  (tTree yyt)
  8419. # else
  8420.  (yyt) tTree yyt;
  8421. # endif
  8422. {
  8423.  (void) fputs (Tree_NodeName [kTYPE_LIST], yyf); (void) fputc ('\n', yyf);
  8424.  yyIndentSelectorTree ("Elem", yyt->TYPE_LIST.Elem);
  8425. }
  8426.  
  8427. static void yWriteDECL_NODE
  8428. # if defined __STDC__ | defined __cplusplus
  8429.  (tTree yyt)
  8430. # else
  8431.  (yyt) tTree yyt;
  8432. # endif
  8433. {
  8434.  (void) fputs (Tree_NodeName [kDECL_NODE], yyf); (void) fputc ('\n', yyf);
  8435.  yyIndentSelector ("Name"); writetIdent (yyt->DECL_NODE.Name) yyWriteNl ();
  8436.  yyIndentSelector ("Pos"); writeint (yyt->DECL_NODE.Pos) yyWriteNl ();
  8437. }
  8438.  
  8439. static void yWriteMODULE_DECL
  8440. # if defined __STDC__ | defined __cplusplus
  8441.  (tTree yyt)
  8442. # else
  8443.  (yyt) tTree yyt;
  8444. # endif
  8445. {
  8446.  (void) fputs (Tree_NodeName [kMODULE_DECL], yyf); (void) fputc ('\n', yyf);
  8447.  yyIndentSelector ("Name"); writetIdent (yyt->MODULE_DECL.Name) yyWriteNl ();
  8448.  yyIndentSelector ("Pos"); writeint (yyt->MODULE_DECL.Pos) yyWriteNl ();
  8449. }
  8450.  
  8451. static void yWritePROGRAM_DECL
  8452. # if defined __STDC__ | defined __cplusplus
  8453.  (tTree yyt)
  8454. # else
  8455.  (yyt) tTree yyt;
  8456. # endif
  8457. {
  8458.  (void) fputs (Tree_NodeName [kPROGRAM_DECL], yyf); (void) fputc ('\n', yyf);
  8459.  yyIndentSelector ("Name"); writetIdent (yyt->PROGRAM_DECL.Name) yyWriteNl ();
  8460.  yyIndentSelector ("Pos"); writeint (yyt->PROGRAM_DECL.Pos) yyWriteNl ();
  8461.  yyIndentSelectorTree ("FORMALS", yyt->PROGRAM_DECL.FORMALS);
  8462. }
  8463.  
  8464. static void yWritePROC_DECL
  8465. # if defined __STDC__ | defined __cplusplus
  8466.  (tTree yyt)
  8467. # else
  8468.  (yyt) tTree yyt;
  8469. # endif
  8470. {
  8471.  (void) fputs (Tree_NodeName [kPROC_DECL], yyf); (void) fputc ('\n', yyf);
  8472.  yyIndentSelector ("Name"); writetIdent (yyt->PROC_DECL.Name) yyWriteNl ();
  8473.  yyIndentSelector ("Pos"); writeint (yyt->PROC_DECL.Pos) yyWriteNl ();
  8474.  yyIndentSelectorTree ("FORMALS", yyt->PROC_DECL.FORMALS);
  8475.  yyIndentSelector ("IsRecursive"); writebool (yyt->PROC_DECL.IsRecursive) yyWriteNl ();
  8476.  yyIndentSelector ("IsPure"); writebool (yyt->PROC_DECL.IsPure) yyWriteNl ();
  8477.  yyIndentSelector ("HPFExtrinsic"); writeint (yyt->PROC_DECL.HPFExtrinsic) yyWriteNl ();
  8478. }
  8479.  
  8480. static void yWriteFUNC_DECL
  8481. # if defined __STDC__ | defined __cplusplus
  8482.  (tTree yyt)
  8483. # else
  8484.  (yyt) tTree yyt;
  8485. # endif
  8486. {
  8487.  (void) fputs (Tree_NodeName [kFUNC_DECL], yyf); (void) fputc ('\n', yyf);
  8488.  yyIndentSelector ("Name"); writetIdent (yyt->FUNC_DECL.Name) yyWriteNl ();
  8489.  yyIndentSelector ("Pos"); writeint (yyt->FUNC_DECL.Pos) yyWriteNl ();
  8490.  yyIndentSelectorTree ("FORMALS", yyt->FUNC_DECL.FORMALS);
  8491.  yyIndentSelectorTree ("FUNC_BODY", yyt->FUNC_DECL.FUNC_BODY);
  8492.  yyIndentSelector ("RESULT_ID"); writetIdent (yyt->FUNC_DECL.RESULT_ID) yyWriteNl ();
  8493.  yyIndentSelector ("IsRecursive"); writebool (yyt->FUNC_DECL.IsRecursive) yyWriteNl ();
  8494.  yyIndentSelector ("IsPure"); writebool (yyt->FUNC_DECL.IsPure) yyWriteNl ();
  8495.  yyIndentSelector ("HPFExtrinsic"); writeint (yyt->FUNC_DECL.HPFExtrinsic) yyWriteNl ();
  8496. }
  8497.  
  8498. static void yWriteBLOCK_DATA_DECL
  8499. # if defined __STDC__ | defined __cplusplus
  8500.  (tTree yyt)
  8501. # else
  8502.  (yyt) tTree yyt;
  8503. # endif
  8504. {
  8505.  (void) fputs (Tree_NodeName [kBLOCK_DATA_DECL], yyf); (void) fputc ('\n', yyf);
  8506.  yyIndentSelector ("Name"); writetIdent (yyt->BLOCK_DATA_DECL.Name) yyWriteNl ();
  8507.  yyIndentSelector ("Pos"); writeint (yyt->BLOCK_DATA_DECL.Pos) yyWriteNl ();
  8508. }
  8509.  
  8510. static void yWriteTYPE_DECL
  8511. # if defined __STDC__ | defined __cplusplus
  8512.  (tTree yyt)
  8513. # else
  8514.  (yyt) tTree yyt;
  8515. # endif
  8516. {
  8517.  (void) fputs (Tree_NodeName [kTYPE_DECL], yyf); (void) fputc ('\n', yyf);
  8518.  yyIndentSelector ("Name"); writetIdent (yyt->TYPE_DECL.Name) yyWriteNl ();
  8519.  yyIndentSelector ("Pos"); writeint (yyt->TYPE_DECL.Pos) yyWriteNl ();
  8520. }
  8521.  
  8522. static void yWriteNAME_DECL
  8523. # if defined __STDC__ | defined __cplusplus
  8524.  (tTree yyt)
  8525. # else
  8526.  (yyt) tTree yyt;
  8527. # endif
  8528. {
  8529.  (void) fputs (Tree_NodeName [kNAME_DECL], yyf); (void) fputc ('\n', yyf);
  8530.  yyIndentSelector ("Name"); writetIdent (yyt->NAME_DECL.Name) yyWriteNl ();
  8531.  yyIndentSelector ("Pos"); writeint (yyt->NAME_DECL.Pos) yyWriteNl ();
  8532. }
  8533.  
  8534. static void yWriteRENAME_DECL
  8535. # if defined __STDC__ | defined __cplusplus
  8536.  (tTree yyt)
  8537. # else
  8538.  (yyt) tTree yyt;
  8539. # endif
  8540. {
  8541.  (void) fputs (Tree_NodeName [kRENAME_DECL], yyf); (void) fputc ('\n', yyf);
  8542.  yyIndentSelector ("Name"); writetIdent (yyt->RENAME_DECL.Name) yyWriteNl ();
  8543.  yyIndentSelector ("Pos"); writeint (yyt->RENAME_DECL.Pos) yyWriteNl ();
  8544.  yyIndentSelector ("oldname"); writetIdent (yyt->RENAME_DECL.oldname) yyWriteNl ();
  8545. }
  8546.  
  8547. static void yWriteENTITY_DECL
  8548. # if defined __STDC__ | defined __cplusplus
  8549.  (tTree yyt)
  8550. # else
  8551.  (yyt) tTree yyt;
  8552. # endif
  8553. {
  8554.  (void) fputs (Tree_NodeName [kENTITY_DECL], yyf); (void) fputc ('\n', yyf);
  8555.  yyIndentSelector ("Name"); writetIdent (yyt->ENTITY_DECL.Name) yyWriteNl ();
  8556.  yyIndentSelector ("Pos"); writeint (yyt->ENTITY_DECL.Pos) yyWriteNl ();
  8557. }
  8558.  
  8559. static void yWriteVAR_DECL
  8560. # if defined __STDC__ | defined __cplusplus
  8561.  (tTree yyt)
  8562. # else
  8563.  (yyt) tTree yyt;
  8564. # endif
  8565. {
  8566.  (void) fputs (Tree_NodeName [kVAR_DECL], yyf); (void) fputc ('\n', yyf);
  8567.  yyIndentSelector ("Name"); writetIdent (yyt->VAR_DECL.Name) yyWriteNl ();
  8568.  yyIndentSelector ("Pos"); writeint (yyt->VAR_DECL.Pos) yyWriteNl ();
  8569. }
  8570.  
  8571. static void yWriteCOMMON_DECL
  8572. # if defined __STDC__ | defined __cplusplus
  8573.  (tTree yyt)
  8574. # else
  8575.  (yyt) tTree yyt;
  8576. # endif
  8577. {
  8578.  (void) fputs (Tree_NodeName [kCOMMON_DECL], yyf); (void) fputc ('\n', yyf);
  8579.  yyIndentSelector ("Name"); writetIdent (yyt->COMMON_DECL.Name) yyWriteNl ();
  8580.  yyIndentSelector ("Pos"); writeint (yyt->COMMON_DECL.Pos) yyWriteNl ();
  8581. }
  8582.  
  8583. static void yWriteNAMELIST_DECL
  8584. # if defined __STDC__ | defined __cplusplus
  8585.  (tTree yyt)
  8586. # else
  8587.  (yyt) tTree yyt;
  8588. # endif
  8589. {
  8590.  (void) fputs (Tree_NodeName [kNAMELIST_DECL], yyf); (void) fputc ('\n', yyf);
  8591.  yyIndentSelector ("Name"); writetIdent (yyt->NAMELIST_DECL.Name) yyWriteNl ();
  8592.  yyIndentSelector ("Pos"); writeint (yyt->NAMELIST_DECL.Pos) yyWriteNl ();
  8593. }
  8594.  
  8595. static void yWriteTEMPLATE_DECL
  8596. # if defined __STDC__ | defined __cplusplus
  8597.  (tTree yyt)
  8598. # else
  8599.  (yyt) tTree yyt;
  8600. # endif
  8601. {
  8602.  (void) fputs (Tree_NodeName [kTEMPLATE_DECL], yyf); (void) fputc ('\n', yyf);
  8603.  yyIndentSelector ("Name"); writetIdent (yyt->TEMPLATE_DECL.Name) yyWriteNl ();
  8604.  yyIndentSelector ("Pos"); writeint (yyt->TEMPLATE_DECL.Pos) yyWriteNl ();
  8605. }
  8606.  
  8607. static void yWritePROCESSORS_DECL
  8608. # if defined __STDC__ | defined __cplusplus
  8609.  (tTree yyt)
  8610. # else
  8611.  (yyt) tTree yyt;
  8612. # endif
  8613. {
  8614.  (void) fputs (Tree_NodeName [kPROCESSORS_DECL], yyf); (void) fputc ('\n', yyf);
  8615.  yyIndentSelector ("Name"); writetIdent (yyt->PROCESSORS_DECL.Name) yyWriteNl ();
  8616.  yyIndentSelector ("Pos"); writeint (yyt->PROCESSORS_DECL.Pos) yyWriteNl ();
  8617. }
  8618.  
  8619. static void yWriteINHERIT_DECL
  8620. # if defined __STDC__ | defined __cplusplus
  8621.  (tTree yyt)
  8622. # else
  8623.  (yyt) tTree yyt;
  8624. # endif
  8625. {
  8626.  (void) fputs (Tree_NodeName [kINHERIT_DECL], yyf); (void) fputc ('\n', yyf);
  8627.  yyIndentSelector ("Name"); writetIdent (yyt->INHERIT_DECL.Name) yyWriteNl ();
  8628.  yyIndentSelector ("Pos"); writeint (yyt->INHERIT_DECL.Pos) yyWriteNl ();
  8629. }
  8630.  
  8631. static void yWriteSTMT_FUNC_DECL
  8632. # if defined __STDC__ | defined __cplusplus
  8633.  (tTree yyt)
  8634. # else
  8635.  (yyt) tTree yyt;
  8636. # endif
  8637. {
  8638.  (void) fputs (Tree_NodeName [kSTMT_FUNC_DECL], yyf); (void) fputc ('\n', yyf);
  8639.  yyIndentSelector ("Name"); writetIdent (yyt->STMT_FUNC_DECL.Name) yyWriteNl ();
  8640.  yyIndentSelector ("Pos"); writeint (yyt->STMT_FUNC_DECL.Pos) yyWriteNl ();
  8641.  yyIndentSelectorTree ("FORMALS", yyt->STMT_FUNC_DECL.FORMALS);
  8642.  yyIndentSelectorTree ("RESULT_TYPE", yyt->STMT_FUNC_DECL.RESULT_TYPE);
  8643. }
  8644.  
  8645. static void yWriteINTERFACE_DECL
  8646. # if defined __STDC__ | defined __cplusplus
  8647.  (tTree yyt)
  8648. # else
  8649.  (yyt) tTree yyt;
  8650. # endif
  8651. {
  8652.  (void) fputs (Tree_NodeName [kINTERFACE_DECL], yyf); (void) fputc ('\n', yyf);
  8653.  yyIndentSelector ("Name"); writetIdent (yyt->INTERFACE_DECL.Name) yyWriteNl ();
  8654.  yyIndentSelector ("Pos"); writeint (yyt->INTERFACE_DECL.Pos) yyWriteNl ();
  8655.  yyIndentSelectorTree ("SPEC", yyt->INTERFACE_DECL.SPEC);
  8656. }
  8657.  
  8658. static void yWriteEXT_PROC_DECL
  8659. # if defined __STDC__ | defined __cplusplus
  8660.  (tTree yyt)
  8661. # else
  8662.  (yyt) tTree yyt;
  8663. # endif
  8664. {
  8665.  (void) fputs (Tree_NodeName [kEXT_PROC_DECL], yyf); (void) fputc ('\n', yyf);
  8666.  yyIndentSelector ("Name"); writetIdent (yyt->EXT_PROC_DECL.Name) yyWriteNl ();
  8667.  yyIndentSelector ("Pos"); writeint (yyt->EXT_PROC_DECL.Pos) yyWriteNl ();
  8668. }
  8669.  
  8670. static void yWriteEXT_FUNC_DECL
  8671. # if defined __STDC__ | defined __cplusplus
  8672.  (tTree yyt)
  8673. # else
  8674.  (yyt) tTree yyt;
  8675. # endif
  8676. {
  8677.  (void) fputs (Tree_NodeName [kEXT_FUNC_DECL], yyf); (void) fputc ('\n', yyf);
  8678.  yyIndentSelector ("Name"); writetIdent (yyt->EXT_FUNC_DECL.Name) yyWriteNl ();
  8679.  yyIndentSelector ("Pos"); writeint (yyt->EXT_FUNC_DECL.Pos) yyWriteNl ();
  8680.  yyIndentSelectorTree ("FORMALS", yyt->EXT_FUNC_DECL.FORMALS);
  8681. }
  8682.  
  8683. static void yWriteVAL_PARAM_DECL
  8684. # if defined __STDC__ | defined __cplusplus
  8685.  (tTree yyt)
  8686. # else
  8687.  (yyt) tTree yyt;
  8688. # endif
  8689. {
  8690.  (void) fputs (Tree_NodeName [kVAL_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  8691.  yyIndentSelector ("Name"); writetIdent (yyt->VAL_PARAM_DECL.Name) yyWriteNl ();
  8692.  yyIndentSelector ("Pos"); writeint (yyt->VAL_PARAM_DECL.Pos) yyWriteNl ();
  8693. }
  8694.  
  8695. static void yWriteVAR_PARAM_DECL
  8696. # if defined __STDC__ | defined __cplusplus
  8697.  (tTree yyt)
  8698. # else
  8699.  (yyt) tTree yyt;
  8700. # endif
  8701. {
  8702.  (void) fputs (Tree_NodeName [kVAR_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  8703.  yyIndentSelector ("Name"); writetIdent (yyt->VAR_PARAM_DECL.Name) yyWriteNl ();
  8704.  yyIndentSelector ("Pos"); writeint (yyt->VAR_PARAM_DECL.Pos) yyWriteNl ();
  8705. }
  8706.  
  8707. static void yWritePROC_PARAM_DECL
  8708. # if defined __STDC__ | defined __cplusplus
  8709.  (tTree yyt)
  8710. # else
  8711.  (yyt) tTree yyt;
  8712. # endif
  8713. {
  8714.  (void) fputs (Tree_NodeName [kPROC_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  8715.  yyIndentSelector ("Name"); writetIdent (yyt->PROC_PARAM_DECL.Name) yyWriteNl ();
  8716.  yyIndentSelector ("Pos"); writeint (yyt->PROC_PARAM_DECL.Pos) yyWriteNl ();
  8717. }
  8718.  
  8719. static void yWriteFUNC_PARAM_DECL
  8720. # if defined __STDC__ | defined __cplusplus
  8721.  (tTree yyt)
  8722. # else
  8723.  (yyt) tTree yyt;
  8724. # endif
  8725. {
  8726.  (void) fputs (Tree_NodeName [kFUNC_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  8727.  yyIndentSelector ("Name"); writetIdent (yyt->FUNC_PARAM_DECL.Name) yyWriteNl ();
  8728.  yyIndentSelector ("Pos"); writeint (yyt->FUNC_PARAM_DECL.Pos) yyWriteNl ();
  8729.  yyIndentSelectorTree ("FORMAL", yyt->FUNC_PARAM_DECL.FORMAL);
  8730. }
  8731.  
  8732. static void yWriteELIPSIS_PARAM_DECL
  8733. # if defined __STDC__ | defined __cplusplus
  8734.  (tTree yyt)
  8735. # else
  8736.  (yyt) tTree yyt;
  8737. # endif
  8738. {
  8739.  (void) fputs (Tree_NodeName [kELIPSIS_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  8740.  yyIndentSelector ("Name"); writetIdent (yyt->ELIPSIS_PARAM_DECL.Name) yyWriteNl ();
  8741.  yyIndentSelector ("Pos"); writeint (yyt->ELIPSIS_PARAM_DECL.Pos) yyWriteNl ();
  8742. }
  8743.  
  8744. static void yWriteRET_PARAM_DECL
  8745. # if defined __STDC__ | defined __cplusplus
  8746.  (tTree yyt)
  8747. # else
  8748.  (yyt) tTree yyt;
  8749. # endif
  8750. {
  8751.  (void) fputs (Tree_NodeName [kRET_PARAM_DECL], yyf); (void) fputc ('\n', yyf);
  8752.  yyIndentSelector ("Name"); writetIdent (yyt->RET_PARAM_DECL.Name) yyWriteNl ();
  8753.  yyIndentSelector ("Pos"); writeint (yyt->RET_PARAM_DECL.Pos) yyWriteNl ();
  8754. }
  8755.  
  8756. static void yWriteIMPLICIT_DECL
  8757. # if defined __STDC__ | defined __cplusplus
  8758.  (tTree yyt)
  8759. # else
  8760.  (yyt) tTree yyt;
  8761. # endif
  8762. {
  8763.  (void) fputs (Tree_NodeName [kIMPLICIT_DECL], yyf); (void) fputc ('\n', yyf);
  8764.  yyIndentSelector ("Name"); writetIdent (yyt->IMPLICIT_DECL.Name) yyWriteNl ();
  8765.  yyIndentSelector ("Pos"); writeint (yyt->IMPLICIT_DECL.Pos) yyWriteNl ();
  8766.  yyIndentSelector ("first"); writetIdent (yyt->IMPLICIT_DECL.first) yyWriteNl ();
  8767.  yyIndentSelector ("last"); writetIdent (yyt->IMPLICIT_DECL.last) yyWriteNl ();
  8768. }
  8769.  
  8770. static void yWriteUSE_DECL
  8771. # if defined __STDC__ | defined __cplusplus
  8772.  (tTree yyt)
  8773. # else
  8774.  (yyt) tTree yyt;
  8775. # endif
  8776. {
  8777.  (void) fputs (Tree_NodeName [kUSE_DECL], yyf); (void) fputc ('\n', yyf);
  8778.  yyIndentSelector ("Name"); writetIdent (yyt->USE_DECL.Name) yyWriteNl ();
  8779.  yyIndentSelector ("Pos"); writeint (yyt->USE_DECL.Pos) yyWriteNl ();
  8780.  yyIndentSelector ("use"); writetIdent (yyt->USE_DECL.use) yyWriteNl ();
  8781. }
  8782.  
  8783. static void yWriteONLY_USE_DECL
  8784. # if defined __STDC__ | defined __cplusplus
  8785.  (tTree yyt)
  8786. # else
  8787.  (yyt) tTree yyt;
  8788. # endif
  8789. {
  8790.  (void) fputs (Tree_NodeName [kONLY_USE_DECL], yyf); (void) fputc ('\n', yyf);
  8791.  yyIndentSelector ("Name"); writetIdent (yyt->ONLY_USE_DECL.Name) yyWriteNl ();
  8792.  yyIndentSelector ("Pos"); writeint (yyt->ONLY_USE_DECL.Pos) yyWriteNl ();
  8793.  yyIndentSelector ("use"); writetIdent (yyt->ONLY_USE_DECL.use) yyWriteNl ();
  8794. }
  8795.  
  8796. static void yWriteEQV_DECL
  8797. # if defined __STDC__ | defined __cplusplus
  8798.  (tTree yyt)
  8799. # else
  8800.  (yyt) tTree yyt;
  8801. # endif
  8802. {
  8803.  (void) fputs (Tree_NodeName [kEQV_DECL], yyf); (void) fputc ('\n', yyf);
  8804.  yyIndentSelector ("Name"); writetIdent (yyt->EQV_DECL.Name) yyWriteNl ();
  8805.  yyIndentSelector ("Pos"); writeint (yyt->EQV_DECL.Pos) yyWriteNl ();
  8806. }
  8807.  
  8808. static void yWriteDATA_DECL
  8809. # if defined __STDC__ | defined __cplusplus
  8810.  (tTree yyt)
  8811. # else
  8812.  (yyt) tTree yyt;
  8813. # endif
  8814. {
  8815.  (void) fputs (Tree_NodeName [kDATA_DECL], yyf); (void) fputc ('\n', yyf);
  8816.  yyIndentSelector ("Name"); writetIdent (yyt->DATA_DECL.Name) yyWriteNl ();
  8817.  yyIndentSelector ("Pos"); writeint (yyt->DATA_DECL.Pos) yyWriteNl ();
  8818.  yyIndentSelectorTree ("VARS", yyt->DATA_DECL.VARS);
  8819. }
  8820.  
  8821. static void yWriteDIMENSION_DECL
  8822. # if defined __STDC__ | defined __cplusplus
  8823.  (tTree yyt)
  8824. # else
  8825.  (yyt) tTree yyt;
  8826. # endif
  8827. {
  8828.  (void) fputs (Tree_NodeName [kDIMENSION_DECL], yyf); (void) fputc ('\n', yyf);
  8829.  yyIndentSelector ("Name"); writetIdent (yyt->DIMENSION_DECL.Name) yyWriteNl ();
  8830.  yyIndentSelector ("Pos"); writeint (yyt->DIMENSION_DECL.Pos) yyWriteNl ();
  8831. }
  8832.  
  8833. static void yWriteINIT_DATA_DECL
  8834. # if defined __STDC__ | defined __cplusplus
  8835.  (tTree yyt)
  8836. # else
  8837.  (yyt) tTree yyt;
  8838. # endif
  8839. {
  8840.  (void) fputs (Tree_NodeName [kINIT_DATA_DECL], yyf); (void) fputc ('\n', yyf);
  8841.  yyIndentSelector ("Name"); writetIdent (yyt->INIT_DATA_DECL.Name) yyWriteNl ();
  8842.  yyIndentSelector ("Pos"); writeint (yyt->INIT_DATA_DECL.Pos) yyWriteNl ();
  8843. }
  8844.  
  8845. static void yWriteTYPESPEC_DECL
  8846. # if defined __STDC__ | defined __cplusplus
  8847.  (tTree yyt)
  8848. # else
  8849.  (yyt) tTree yyt;
  8850. # endif
  8851. {
  8852.  (void) fputs (Tree_NodeName [kTYPESPEC_DECL], yyf); (void) fputc ('\n', yyf);
  8853.  yyIndentSelector ("Name"); writetIdent (yyt->TYPESPEC_DECL.Name) yyWriteNl ();
  8854.  yyIndentSelector ("Pos"); writeint (yyt->TYPESPEC_DECL.Pos) yyWriteNl ();
  8855. }
  8856.  
  8857. static void yWriteALLOCATABLE_DECL
  8858. # if defined __STDC__ | defined __cplusplus
  8859.  (tTree yyt)
  8860. # else
  8861.  (yyt) tTree yyt;
  8862. # endif
  8863. {
  8864.  (void) fputs (Tree_NodeName [kALLOCATABLE_DECL], yyf); (void) fputc ('\n', yyf);
  8865.  yyIndentSelector ("Name"); writetIdent (yyt->ALLOCATABLE_DECL.Name) yyWriteNl ();
  8866.  yyIndentSelector ("Pos"); writeint (yyt->ALLOCATABLE_DECL.Pos) yyWriteNl ();
  8867. }
  8868.  
  8869. static void yWriteEXTERNAL_DECL
  8870. # if defined __STDC__ | defined __cplusplus
  8871.  (tTree yyt)
  8872. # else
  8873.  (yyt) tTree yyt;
  8874. # endif
  8875. {
  8876.  (void) fputs (Tree_NodeName [kEXTERNAL_DECL], yyf); (void) fputc ('\n', yyf);
  8877.  yyIndentSelector ("Name"); writetIdent (yyt->EXTERNAL_DECL.Name) yyWriteNl ();
  8878.  yyIndentSelector ("Pos"); writeint (yyt->EXTERNAL_DECL.Pos) yyWriteNl ();
  8879. }
  8880.  
  8881. static void yWriteINTENT_DECL
  8882. # if defined __STDC__ | defined __cplusplus
  8883.  (tTree yyt)
  8884. # else
  8885.  (yyt) tTree yyt;
  8886. # endif
  8887. {
  8888.  (void) fputs (Tree_NodeName [kINTENT_DECL], yyf); (void) fputc ('\n', yyf);
  8889.  yyIndentSelector ("Name"); writetIdent (yyt->INTENT_DECL.Name) yyWriteNl ();
  8890.  yyIndentSelector ("Pos"); writeint (yyt->INTENT_DECL.Pos) yyWriteNl ();
  8891.  yyIndentSelector ("intent"); writeint (yyt->INTENT_DECL.intent) yyWriteNl ();
  8892. }
  8893.  
  8894. static void yWriteINTRINSIC_DECL
  8895. # if defined __STDC__ | defined __cplusplus
  8896.  (tTree yyt)
  8897. # else
  8898.  (yyt) tTree yyt;
  8899. # endif
  8900. {
  8901.  (void) fputs (Tree_NodeName [kINTRINSIC_DECL], yyf); (void) fputc ('\n', yyf);
  8902.  yyIndentSelector ("Name"); writetIdent (yyt->INTRINSIC_DECL.Name) yyWriteNl ();
  8903.  yyIndentSelector ("Pos"); writeint (yyt->INTRINSIC_DECL.Pos) yyWriteNl ();
  8904. }
  8905.  
  8906. static void yWriteOPTIONAL_DECL
  8907. # if defined __STDC__ | defined __cplusplus
  8908.  (tTree yyt)
  8909. # else
  8910.  (yyt) tTree yyt;
  8911. # endif
  8912. {
  8913.  (void) fputs (Tree_NodeName [kOPTIONAL_DECL], yyf); (void) fputc ('\n', yyf);
  8914.  yyIndentSelector ("Name"); writetIdent (yyt->OPTIONAL_DECL.Name) yyWriteNl ();
  8915.  yyIndentSelector ("Pos"); writeint (yyt->OPTIONAL_DECL.Pos) yyWriteNl ();
  8916. }
  8917.  
  8918. static void yWritePOINTER_DECL
  8919. # if defined __STDC__ | defined __cplusplus
  8920.  (tTree yyt)
  8921. # else
  8922.  (yyt) tTree yyt;
  8923. # endif
  8924. {
  8925.  (void) fputs (Tree_NodeName [kPOINTER_DECL], yyf); (void) fputc ('\n', yyf);
  8926.  yyIndentSelector ("Name"); writetIdent (yyt->POINTER_DECL.Name) yyWriteNl ();
  8927.  yyIndentSelector ("Pos"); writeint (yyt->POINTER_DECL.Pos) yyWriteNl ();
  8928. }
  8929.  
  8930. static void yWriteSAVE_DECL
  8931. # if defined __STDC__ | defined __cplusplus
  8932.  (tTree yyt)
  8933. # else
  8934.  (yyt) tTree yyt;
  8935. # endif
  8936. {
  8937.  (void) fputs (Tree_NodeName [kSAVE_DECL], yyf); (void) fputc ('\n', yyf);
  8938.  yyIndentSelector ("Name"); writetIdent (yyt->SAVE_DECL.Name) yyWriteNl ();
  8939.  yyIndentSelector ("Pos"); writeint (yyt->SAVE_DECL.Pos) yyWriteNl ();
  8940. }
  8941.  
  8942. static void yWriteTARGET_DECL
  8943. # if defined __STDC__ | defined __cplusplus
  8944.  (tTree yyt)
  8945. # else
  8946.  (yyt) tTree yyt;
  8947. # endif
  8948. {
  8949.  (void) fputs (Tree_NodeName [kTARGET_DECL], yyf); (void) fputc ('\n', yyf);
  8950.  yyIndentSelector ("Name"); writetIdent (yyt->TARGET_DECL.Name) yyWriteNl ();
  8951.  yyIndentSelector ("Pos"); writeint (yyt->TARGET_DECL.Pos) yyWriteNl ();
  8952. }
  8953.  
  8954. static void yWritePARAMETER_DECL
  8955. # if defined __STDC__ | defined __cplusplus
  8956.  (tTree yyt)
  8957. # else
  8958.  (yyt) tTree yyt;
  8959. # endif
  8960. {
  8961.  (void) fputs (Tree_NodeName [kPARAMETER_DECL], yyf); (void) fputc ('\n', yyf);
  8962.  yyIndentSelector ("Name"); writetIdent (yyt->PARAMETER_DECL.Name) yyWriteNl ();
  8963.  yyIndentSelector ("Pos"); writeint (yyt->PARAMETER_DECL.Pos) yyWriteNl ();
  8964. }
  8965.  
  8966. static void yWritePUBLIC_DECL
  8967. # if defined __STDC__ | defined __cplusplus
  8968.  (tTree yyt)
  8969. # else
  8970.  (yyt) tTree yyt;
  8971. # endif
  8972. {
  8973.  (void) fputs (Tree_NodeName [kPUBLIC_DECL], yyf); (void) fputc ('\n', yyf);
  8974.  yyIndentSelector ("Name"); writetIdent (yyt->PUBLIC_DECL.Name) yyWriteNl ();
  8975.  yyIndentSelector ("Pos"); writeint (yyt->PUBLIC_DECL.Pos) yyWriteNl ();
  8976. }
  8977.  
  8978. static void yWritePRIVATE_DECL
  8979. # if defined __STDC__ | defined __cplusplus
  8980.  (tTree yyt)
  8981. # else
  8982.  (yyt) tTree yyt;
  8983. # endif
  8984. {
  8985.  (void) fputs (Tree_NodeName [kPRIVATE_DECL], yyf); (void) fputc ('\n', yyf);
  8986.  yyIndentSelector ("Name"); writetIdent (yyt->PRIVATE_DECL.Name) yyWriteNl ();
  8987.  yyIndentSelector ("Pos"); writeint (yyt->PRIVATE_DECL.Pos) yyWriteNl ();
  8988. }
  8989.  
  8990. static void yWriteDISTRIBUTE_DECL
  8991. # if defined __STDC__ | defined __cplusplus
  8992.  (tTree yyt)
  8993. # else
  8994.  (yyt) tTree yyt;
  8995. # endif
  8996. {
  8997.  (void) fputs (Tree_NodeName [kDISTRIBUTE_DECL], yyf); (void) fputc ('\n', yyf);
  8998.  yyIndentSelector ("Name"); writetIdent (yyt->DISTRIBUTE_DECL.Name) yyWriteNl ();
  8999.  yyIndentSelector ("Pos"); writeint (yyt->DISTRIBUTE_DECL.Pos) yyWriteNl ();
  9000.  yyIndentSelector ("target"); writetIdent (yyt->DISTRIBUTE_DECL.target) yyWriteNl ();
  9001. }
  9002.  
  9003. static void yWriteALIGN_DECL
  9004. # if defined __STDC__ | defined __cplusplus
  9005.  (tTree yyt)
  9006. # else
  9007.  (yyt) tTree yyt;
  9008. # endif
  9009. {
  9010.  (void) fputs (Tree_NodeName [kALIGN_DECL], yyf); (void) fputc ('\n', yyf);
  9011.  yyIndentSelector ("Name"); writetIdent (yyt->ALIGN_DECL.Name) yyWriteNl ();
  9012.  yyIndentSelector ("Pos"); writeint (yyt->ALIGN_DECL.Pos) yyWriteNl ();
  9013.  yyIndentSelectorTree ("ALIGN_SOURCE", yyt->ALIGN_DECL.ALIGN_SOURCE);
  9014. }
  9015.  
  9016. static void yWriteDYNAMIC_DECL
  9017. # if defined __STDC__ | defined __cplusplus
  9018.  (tTree yyt)
  9019. # else
  9020.  (yyt) tTree yyt;
  9021. # endif
  9022. {
  9023.  (void) fputs (Tree_NodeName [kDYNAMIC_DECL], yyf); (void) fputc ('\n', yyf);
  9024.  yyIndentSelector ("Name"); writetIdent (yyt->DYNAMIC_DECL.Name) yyWriteNl ();
  9025.  yyIndentSelector ("Pos"); writeint (yyt->DYNAMIC_DECL.Pos) yyWriteNl ();
  9026. }
  9027.  
  9028. static void yWriteSEQUENCE_DECL
  9029. # if defined __STDC__ | defined __cplusplus
  9030.  (tTree yyt)
  9031. # else
  9032.  (yyt) tTree yyt;
  9033. # endif
  9034. {
  9035.  (void) fputs (Tree_NodeName [kSEQUENCE_DECL], yyf); (void) fputc ('\n', yyf);
  9036.  yyIndentSelector ("Name"); writetIdent (yyt->SEQUENCE_DECL.Name) yyWriteNl ();
  9037.  yyIndentSelector ("Pos"); writeint (yyt->SEQUENCE_DECL.Pos) yyWriteNl ();
  9038. }
  9039.  
  9040. static void yWriteNOSEQUENCE_DECL
  9041. # if defined __STDC__ | defined __cplusplus
  9042.  (tTree yyt)
  9043. # else
  9044.  (yyt) tTree yyt;
  9045. # endif
  9046. {
  9047.  (void) fputs (Tree_NodeName [kNOSEQUENCE_DECL], yyf); (void) fputc ('\n', yyf);
  9048.  yyIndentSelector ("Name"); writetIdent (yyt->NOSEQUENCE_DECL.Name) yyWriteNl ();
  9049.  yyIndentSelector ("Pos"); writeint (yyt->NOSEQUENCE_DECL.Pos) yyWriteNl ();
  9050. }
  9051.  
  9052. static void yWriteDECL_LIST
  9053. # if defined __STDC__ | defined __cplusplus
  9054.  (tTree yyt)
  9055. # else
  9056.  (yyt) tTree yyt;
  9057. # endif
  9058. {
  9059.  (void) fputs (Tree_NodeName [kDECL_LIST], yyf); (void) fputc ('\n', yyf);
  9060.  yyIndentSelectorTree ("Elem", yyt->DECL_LIST.Elem);
  9061. }
  9062.  
  9063. static void yWriteNODE_DISTRIBUTION
  9064. # if defined __STDC__ | defined __cplusplus
  9065.  (tTree yyt)
  9066. # else
  9067.  (yyt) tTree yyt;
  9068. # endif
  9069. {
  9070.  (void) fputs (Tree_NodeName [kNODE_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  9071. }
  9072.  
  9073. static void yWriteBLOCK_DISTRIBUTION
  9074. # if defined __STDC__ | defined __cplusplus
  9075.  (tTree yyt)
  9076. # else
  9077.  (yyt) tTree yyt;
  9078. # endif
  9079. {
  9080.  (void) fputs (Tree_NodeName [kBLOCK_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  9081. }
  9082.  
  9083. static void yWriteCYCLIC_DISTRIBUTION
  9084. # if defined __STDC__ | defined __cplusplus
  9085.  (tTree yyt)
  9086. # else
  9087.  (yyt) tTree yyt;
  9088. # endif
  9089. {
  9090.  (void) fputs (Tree_NodeName [kCYCLIC_DISTRIBUTION], yyf); (void) fputc ('\n', yyf);
  9091. }
  9092.  
  9093. static void yWriteDIST_LIST
  9094. # if defined __STDC__ | defined __cplusplus
  9095.  (tTree yyt)
  9096. # else
  9097.  (yyt) tTree yyt;
  9098. # endif
  9099. {
  9100.  (void) fputs (Tree_NodeName [kDIST_LIST], yyf); (void) fputc ('\n', yyf);
  9101.  yyIndentSelectorTree ("Elem", yyt->DIST_LIST.Elem);
  9102. }
  9103.  
  9104. static void yWriteID_GENERIC_SPEC
  9105. # if defined __STDC__ | defined __cplusplus
  9106.  (tTree yyt)
  9107. # else
  9108.  (yyt) tTree yyt;
  9109. # endif
  9110. {
  9111.  (void) fputs (Tree_NodeName [kID_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf);
  9112.  yyIndentSelector ("name"); writetIdent (yyt->ID_GENERIC_SPEC.name) yyWriteNl ();
  9113. }
  9114.  
  9115. static void yWriteOP_GENERIC_SPEC
  9116. # if defined __STDC__ | defined __cplusplus
  9117.  (tTree yyt)
  9118. # else
  9119.  (yyt) tTree yyt;
  9120. # endif
  9121. {
  9122.  (void) fputs (Tree_NodeName [kOP_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf);
  9123. }
  9124.  
  9125. static void yWriteACF_LIST
  9126. # if defined __STDC__ | defined __cplusplus
  9127.  (tTree yyt)
  9128. # else
  9129.  (yyt) tTree yyt;
  9130. # endif
  9131. {
  9132.  (void) fputs (Tree_NodeName [kACF_LIST], yyf); (void) fputc ('\n', yyf);
  9133.  yyIndentSelectorTree ("Elem", yyt->ACF_LIST.Elem);
  9134. }
  9135.  
  9136. static void yWriteACF_NODE
  9137. # if defined __STDC__ | defined __cplusplus
  9138.  (tTree yyt)
  9139. # else
  9140.  (yyt) tTree yyt;
  9141. # endif
  9142. {
  9143.  (void) fputs (Tree_NodeName [kACF_NODE], yyf); (void) fputc ('\n', yyf);
  9144.  yyIndentSelector ("Label"); writeint (yyt->ACF_NODE.Label) yyWriteNl ();
  9145.  yyIndentSelector ("Line"); writeint (yyt->ACF_NODE.Line) yyWriteNl ();
  9146. }
  9147.  
  9148. static void yWriteACF_DUMMY
  9149. # if defined __STDC__ | defined __cplusplus
  9150.  (tTree yyt)
  9151. # else
  9152.  (yyt) tTree yyt;
  9153. # endif
  9154. {
  9155.  (void) fputs (Tree_NodeName [kACF_DUMMY], yyf); (void) fputc ('\n', yyf);
  9156.  yyIndentSelector ("Label"); writeint (yyt->ACF_DUMMY.Label) yyWriteNl ();
  9157.  yyIndentSelector ("Line"); writeint (yyt->ACF_DUMMY.Line) yyWriteNl ();
  9158. }
  9159.  
  9160. static void yWriteACF_BASIC
  9161. # if defined __STDC__ | defined __cplusplus
  9162.  (tTree yyt)
  9163. # else
  9164.  (yyt) tTree yyt;
  9165. # endif
  9166. {
  9167.  (void) fputs (Tree_NodeName [kACF_BASIC], yyf); (void) fputc ('\n', yyf);
  9168.  yyIndentSelector ("Label"); writeint (yyt->ACF_BASIC.Label) yyWriteNl ();
  9169.  yyIndentSelector ("Line"); writeint (yyt->ACF_BASIC.Line) yyWriteNl ();
  9170. }
  9171.  
  9172. static void yWriteACF_IF
  9173. # if defined __STDC__ | defined __cplusplus
  9174.  (tTree yyt)
  9175. # else
  9176.  (yyt) tTree yyt;
  9177. # endif
  9178. {
  9179.  (void) fputs (Tree_NodeName [kACF_IF], yyf); (void) fputc ('\n', yyf);
  9180.  yyIndentSelector ("Label"); writeint (yyt->ACF_IF.Label) yyWriteNl ();
  9181.  yyIndentSelector ("Line"); writeint (yyt->ACF_IF.Line) yyWriteNl ();
  9182.  yyIndentSelectorTree ("IF_EXP", yyt->ACF_IF.IF_EXP);
  9183.  yyIndentSelectorTree ("THEN_PART", yyt->ACF_IF.THEN_PART);
  9184. }
  9185.  
  9186. static void yWriteACF_WHERE
  9187. # if defined __STDC__ | defined __cplusplus
  9188.  (tTree yyt)
  9189. # else
  9190.  (yyt) tTree yyt;
  9191. # endif
  9192. {
  9193.  (void) fputs (Tree_NodeName [kACF_WHERE], yyf); (void) fputc ('\n', yyf);
  9194.  yyIndentSelector ("Label"); writeint (yyt->ACF_WHERE.Label) yyWriteNl ();
  9195.  yyIndentSelector ("Line"); writeint (yyt->ACF_WHERE.Line) yyWriteNl ();
  9196.  yyIndentSelectorTree ("WHERE_EXP", yyt->ACF_WHERE.WHERE_EXP);
  9197.  yyIndentSelectorTree ("TRUE_PART", yyt->ACF_WHERE.TRUE_PART);
  9198. }
  9199.  
  9200. static void yWriteACF_SWITCH
  9201. # if defined __STDC__ | defined __cplusplus
  9202.  (tTree yyt)
  9203. # else
  9204.  (yyt) tTree yyt;
  9205. # endif
  9206. {
  9207.  (void) fputs (Tree_NodeName [kACF_SWITCH], yyf); (void) fputc ('\n', yyf);
  9208.  yyIndentSelector ("Label"); writeint (yyt->ACF_SWITCH.Label) yyWriteNl ();
  9209.  yyIndentSelector ("Line"); writeint (yyt->ACF_SWITCH.Line) yyWriteNl ();
  9210.  yyIndentSelectorTree ("SWITCH_EXP", yyt->ACF_SWITCH.SWITCH_EXP);
  9211. }
  9212.  
  9213. static void yWriteACF_ALTER
  9214. # if defined __STDC__ | defined __cplusplus
  9215.  (tTree yyt)
  9216. # else
  9217.  (yyt) tTree yyt;
  9218. # endif
  9219. {
  9220.  (void) fputs (Tree_NodeName [kACF_ALTER], yyf); (void) fputc ('\n', yyf);
  9221.  yyIndentSelector ("Label"); writeint (yyt->ACF_ALTER.Label) yyWriteNl ();
  9222.  yyIndentSelector ("Line"); writeint (yyt->ACF_ALTER.Line) yyWriteNl ();
  9223.  yyIndentSelectorTree ("ALTER_EXP", yyt->ACF_ALTER.ALTER_EXP);
  9224. }
  9225.  
  9226. static void yWriteACF_CASE
  9227. # if defined __STDC__ | defined __cplusplus
  9228.  (tTree yyt)
  9229. # else
  9230.  (yyt) tTree yyt;
  9231. # endif
  9232. {
  9233.  (void) fputs (Tree_NodeName [kACF_CASE], yyf); (void) fputc ('\n', yyf);
  9234.  yyIndentSelector ("Label"); writeint (yyt->ACF_CASE.Label) yyWriteNl ();
  9235.  yyIndentSelector ("Line"); writeint (yyt->ACF_CASE.Line) yyWriteNl ();
  9236.  yyIndentSelectorTree ("CASE_EXP", yyt->ACF_CASE.CASE_EXP);
  9237.  yyIndentSelectorTree ("CASE_ALTS", yyt->ACF_CASE.CASE_ALTS);
  9238. }
  9239.  
  9240. static void yWriteACF_WHILE
  9241. # if defined __STDC__ | defined __cplusplus
  9242.  (tTree yyt)
  9243. # else
  9244.  (yyt) tTree yyt;
  9245. # endif
  9246. {
  9247.  (void) fputs (Tree_NodeName [kACF_WHILE], yyf); (void) fputc ('\n', yyf);
  9248.  yyIndentSelector ("Label"); writeint (yyt->ACF_WHILE.Label) yyWriteNl ();
  9249.  yyIndentSelector ("Line"); writeint (yyt->ACF_WHILE.Line) yyWriteNl ();
  9250.  yyIndentSelectorTree ("WHILE_EXP", yyt->ACF_WHILE.WHILE_EXP);
  9251. }
  9252.  
  9253. static void yWriteACF_REPEAT
  9254. # if defined __STDC__ | defined __cplusplus
  9255.  (tTree yyt)
  9256. # else
  9257.  (yyt) tTree yyt;
  9258. # endif
  9259. {
  9260.  (void) fputs (Tree_NodeName [kACF_REPEAT], yyf); (void) fputc ('\n', yyf);
  9261.  yyIndentSelector ("Label"); writeint (yyt->ACF_REPEAT.Label) yyWriteNl ();
  9262.  yyIndentSelector ("Line"); writeint (yyt->ACF_REPEAT.Line) yyWriteNl ();
  9263.  yyIndentSelectorTree ("REPEAT_BODY", yyt->ACF_REPEAT.REPEAT_BODY);
  9264. }
  9265.  
  9266. static void yWriteACF_WITH
  9267. # if defined __STDC__ | defined __cplusplus
  9268.  (tTree yyt)
  9269. # else
  9270.  (yyt) tTree yyt;
  9271. # endif
  9272. {
  9273.  (void) fputs (Tree_NodeName [kACF_WITH], yyf); (void) fputc ('\n', yyf);
  9274.  yyIndentSelector ("Label"); writeint (yyt->ACF_WITH.Label) yyWriteNl ();
  9275.  yyIndentSelector ("Line"); writeint (yyt->ACF_WITH.Line) yyWriteNl ();
  9276.  yyIndentSelectorTree ("WITH_VARS", yyt->ACF_WITH.WITH_VARS);
  9277. }
  9278.  
  9279. static void yWriteACF_LOOP
  9280. # if defined __STDC__ | defined __cplusplus
  9281.  (tTree yyt)
  9282. # else
  9283.  (yyt) tTree yyt;
  9284. # endif
  9285. {
  9286.  (void) fputs (Tree_NodeName [kACF_LOOP], yyf); (void) fputc ('\n', yyf);
  9287.  yyIndentSelector ("Label"); writeint (yyt->ACF_LOOP.Label) yyWriteNl ();
  9288.  yyIndentSelector ("Line"); writeint (yyt->ACF_LOOP.Line) yyWriteNl ();
  9289. }
  9290.  
  9291. static void yWriteACF_DO
  9292. # if defined __STDC__ | defined __cplusplus
  9293.  (tTree yyt)
  9294. # else
  9295.  (yyt) tTree yyt;
  9296. # endif
  9297. {
  9298.  (void) fputs (Tree_NodeName [kACF_DO], yyf); (void) fputc ('\n', yyf);
  9299.  yyIndentSelector ("Label"); writeint (yyt->ACF_DO.Label) yyWriteNl ();
  9300.  yyIndentSelector ("Line"); writeint (yyt->ACF_DO.Line) yyWriteNl ();
  9301.  yyIndentSelectorTree ("DO_ID", yyt->ACF_DO.DO_ID);
  9302.  yyIndentSelectorTree ("DO_RANGE", yyt->ACF_DO.DO_RANGE);
  9303. }
  9304.  
  9305. static void yWriteACF_DOLOCAL
  9306. # if defined __STDC__ | defined __cplusplus
  9307.  (tTree yyt)
  9308. # else
  9309.  (yyt) tTree yyt;
  9310. # endif
  9311. {
  9312.  (void) fputs (Tree_NodeName [kACF_DOLOCAL], yyf); (void) fputc ('\n', yyf);
  9313.  yyIndentSelector ("Label"); writeint (yyt->ACF_DOLOCAL.Label) yyWriteNl ();
  9314.  yyIndentSelector ("Line"); writeint (yyt->ACF_DOLOCAL.Line) yyWriteNl ();
  9315.  yyIndentSelectorTree ("DOLOCAL_ID", yyt->ACF_DOLOCAL.DOLOCAL_ID);
  9316.  yyIndentSelectorTree ("DOLOCAL_RANGE", yyt->ACF_DOLOCAL.DOLOCAL_RANGE);
  9317. }
  9318.  
  9319. static void yWriteACF_DOVEC
  9320. # if defined __STDC__ | defined __cplusplus
  9321.  (tTree yyt)
  9322. # else
  9323.  (yyt) tTree yyt;
  9324. # endif
  9325. {
  9326.  (void) fputs (Tree_NodeName [kACF_DOVEC], yyf); (void) fputc ('\n', yyf);
  9327.  yyIndentSelector ("Label"); writeint (yyt->ACF_DOVEC.Label) yyWriteNl ();
  9328.  yyIndentSelector ("Line"); writeint (yyt->ACF_DOVEC.Line) yyWriteNl ();
  9329.  yyIndentSelectorTree ("DOVEC_ID", yyt->ACF_DOVEC.DOVEC_ID);
  9330.  yyIndentSelectorTree ("DOVEC_RANGE", yyt->ACF_DOVEC.DOVEC_RANGE);
  9331. }
  9332.  
  9333. static void yWriteACF_DOALL
  9334. # if defined __STDC__ | defined __cplusplus
  9335.  (tTree yyt)
  9336. # else
  9337.  (yyt) tTree yyt;
  9338. # endif
  9339. {
  9340.  (void) fputs (Tree_NodeName [kACF_DOALL], yyf); (void) fputc ('\n', yyf);
  9341.  yyIndentSelector ("Label"); writeint (yyt->ACF_DOALL.Label) yyWriteNl ();
  9342.  yyIndentSelector ("Line"); writeint (yyt->ACF_DOALL.Line) yyWriteNl ();
  9343.  yyIndentSelectorTree ("DOALL_NEW", yyt->ACF_DOALL.DOALL_NEW);
  9344.  yyIndentSelectorTree ("DOALL_ID", yyt->ACF_DOALL.DOALL_ID);
  9345.  yyIndentSelectorTree ("DOALL_RANGE", yyt->ACF_DOALL.DOALL_RANGE);
  9346. }
  9347.  
  9348. static void yWriteACF_FORALL
  9349. # if defined __STDC__ | defined __cplusplus
  9350.  (tTree yyt)
  9351. # else
  9352.  (yyt) tTree yyt;
  9353. # endif
  9354. {
  9355.  (void) fputs (Tree_NodeName [kACF_FORALL], yyf); (void) fputc ('\n', yyf);
  9356.  yyIndentSelector ("Label"); writeint (yyt->ACF_FORALL.Label) yyWriteNl ();
  9357.  yyIndentSelector ("Line"); writeint (yyt->ACF_FORALL.Line) yyWriteNl ();
  9358.  yyIndentSelectorTree ("FORALL_ID", yyt->ACF_FORALL.FORALL_ID);
  9359.  yyIndentSelectorTree ("FORALL_RANGE", yyt->ACF_FORALL.FORALL_RANGE);
  9360. }
  9361.  
  9362. static void yWriteACF_ON
  9363. # if defined __STDC__ | defined __cplusplus
  9364.  (tTree yyt)
  9365. # else
  9366.  (yyt) tTree yyt;
  9367. # endif
  9368. {
  9369.  (void) fputs (Tree_NodeName [kACF_ON], yyf); (void) fputc ('\n', yyf);
  9370.  yyIndentSelector ("Label"); writeint (yyt->ACF_ON.Label) yyWriteNl ();
  9371.  yyIndentSelector ("Line"); writeint (yyt->ACF_ON.Line) yyWriteNl ();
  9372.  yyIndentSelectorTree ("ON_VAR", yyt->ACF_ON.ON_VAR);
  9373. }
  9374.  
  9375. static void yWriteACF_BODY
  9376. # if defined __STDC__ | defined __cplusplus
  9377.  (tTree yyt)
  9378. # else
  9379.  (yyt) tTree yyt;
  9380. # endif
  9381. {
  9382.  (void) fputs (Tree_NodeName [kACF_BODY], yyf); (void) fputc ('\n', yyf);
  9383.  yyIndentSelector ("Label"); writeint (yyt->ACF_BODY.Label) yyWriteNl ();
  9384.  yyIndentSelector ("Line"); writeint (yyt->ACF_BODY.Line) yyWriteNl ();
  9385.  yyIndentSelector ("Entries"); writetDefinitions (yyt->ACF_BODY.Entries) yyWriteNl ();
  9386. }
  9387.  
  9388. static void yWriteACF_FLOW_GRAPH
  9389. # if defined __STDC__ | defined __cplusplus
  9390.  (tTree yyt)
  9391. # else
  9392.  (yyt) tTree yyt;
  9393. # endif
  9394. {
  9395.  (void) fputs (Tree_NodeName [kACF_FLOW_GRAPH], yyf); (void) fputc ('\n', yyf);
  9396.  yyIndentSelector ("Label"); writeint (yyt->ACF_FLOW_GRAPH.Label) yyWriteNl ();
  9397.  yyIndentSelector ("Line"); writeint (yyt->ACF_FLOW_GRAPH.Line) yyWriteNl ();
  9398. }
  9399.  
  9400. static void yWriteACF_ENTRY
  9401. # if defined __STDC__ | defined __cplusplus
  9402.  (tTree yyt)
  9403. # else
  9404.  (yyt) tTree yyt;
  9405. # endif
  9406. {
  9407.  (void) fputs (Tree_NodeName [kACF_ENTRY], yyf); (void) fputc ('\n', yyf);
  9408.  yyIndentSelector ("Label"); writeint (yyt->ACF_ENTRY.Label) yyWriteNl ();
  9409.  yyIndentSelector ("Line"); writeint (yyt->ACF_ENTRY.Line) yyWriteNl ();
  9410. }
  9411.  
  9412. static void yWriteSELECTED_ACF_LIST
  9413. # if defined __STDC__ | defined __cplusplus
  9414.  (tTree yyt)
  9415. # else
  9416.  (yyt) tTree yyt;
  9417. # endif
  9418. {
  9419.  (void) fputs (Tree_NodeName [kSELECTED_ACF_LIST], yyf); (void) fputc ('\n', yyf);
  9420.  yyIndentSelectorTree ("Elem", yyt->SELECTED_ACF_LIST.Elem);
  9421. }
  9422.  
  9423. static void yWriteSELECTED_ACF_NODE
  9424. # if defined __STDC__ | defined __cplusplus
  9425.  (tTree yyt)
  9426. # else
  9427.  (yyt) tTree yyt;
  9428. # endif
  9429. {
  9430.  (void) fputs (Tree_NodeName [kSELECTED_ACF_NODE], yyf); (void) fputc ('\n', yyf);
  9431.  yyIndentSelectorTree ("SELECT_LIST", yyt->SELECTED_ACF_NODE.SELECT_LIST);
  9432. }
  9433.  
  9434. static void yWriteEXP_STMT
  9435. # if defined __STDC__ | defined __cplusplus
  9436.  (tTree yyt)
  9437. # else
  9438.  (yyt) tTree yyt;
  9439. # endif
  9440. {
  9441.  (void) fputs (Tree_NodeName [kEXP_STMT], yyf); (void) fputc ('\n', yyf);
  9442. }
  9443.  
  9444. static void yWriteASSIGN_STMT
  9445. # if defined __STDC__ | defined __cplusplus
  9446.  (tTree yyt)
  9447. # else
  9448.  (yyt) tTree yyt;
  9449. # endif
  9450. {
  9451.  (void) fputs (Tree_NodeName [kASSIGN_STMT], yyf); (void) fputc ('\n', yyf);
  9452.  yyIndentSelectorTree ("ASSIGN_VAR", yyt->ASSIGN_STMT.ASSIGN_VAR);
  9453. }
  9454.  
  9455. static void yWritePTR_ASSIGN_STMT
  9456. # if defined __STDC__ | defined __cplusplus
  9457.  (tTree yyt)
  9458. # else
  9459.  (yyt) tTree yyt;
  9460. # endif
  9461. {
  9462.  (void) fputs (Tree_NodeName [kPTR_ASSIGN_STMT], yyf); (void) fputc ('\n', yyf);
  9463.  yyIndentSelectorTree ("ASSIGN_VAR", yyt->PTR_ASSIGN_STMT.ASSIGN_VAR);
  9464. }
  9465.  
  9466. static void yWriteLABEL_ASSIGN_STMT
  9467. # if defined __STDC__ | defined __cplusplus
  9468.  (tTree yyt)
  9469. # else
  9470.  (yyt) tTree yyt;
  9471. # endif
  9472. {
  9473.  (void) fputs (Tree_NodeName [kLABEL_ASSIGN_STMT], yyf); (void) fputc ('\n', yyf);
  9474.  yyIndentSelector ("assign_label"); writeint (yyt->LABEL_ASSIGN_STMT.assign_label) yyWriteNl ();
  9475. }
  9476.  
  9477. static void yWriteCALL_STMT
  9478. # if defined __STDC__ | defined __cplusplus
  9479.  (tTree yyt)
  9480. # else
  9481.  (yyt) tTree yyt;
  9482. # endif
  9483. {
  9484.  (void) fputs (Tree_NodeName [kCALL_STMT], yyf); (void) fputc ('\n', yyf);
  9485.  yyIndentSelectorTree ("CALL_ID", yyt->CALL_STMT.CALL_ID);
  9486. }
  9487.  
  9488. static void yWriteIO_STMT
  9489. # if defined __STDC__ | defined __cplusplus
  9490.  (tTree yyt)
  9491. # else
  9492.  (yyt) tTree yyt;
  9493. # endif
  9494. {
  9495.  (void) fputs (Tree_NodeName [kIO_STMT], yyf); (void) fputc ('\n', yyf);
  9496.  yyIndentSelectorTree ("ID", yyt->IO_STMT.ID);
  9497.  yyIndentSelectorTree ("IO_SPECS", yyt->IO_STMT.IO_SPECS);
  9498. }
  9499.  
  9500. static void yWriteGOTO_STMT
  9501. # if defined __STDC__ | defined __cplusplus
  9502.  (tTree yyt)
  9503. # else
  9504.  (yyt) tTree yyt;
  9505. # endif
  9506. {
  9507.  (void) fputs (Tree_NodeName [kGOTO_STMT], yyf); (void) fputc ('\n', yyf);
  9508.  yyIndentSelector ("GOTO_LABEL"); writeint (yyt->GOTO_STMT.GOTO_LABEL) yyWriteNl ();
  9509. }
  9510.  
  9511. static void yWriteASS_GOTO_STMT
  9512. # if defined __STDC__ | defined __cplusplus
  9513.  (tTree yyt)
  9514. # else
  9515.  (yyt) tTree yyt;
  9516. # endif
  9517. {
  9518.  (void) fputs (Tree_NodeName [kASS_GOTO_STMT], yyf); (void) fputc ('\n', yyf);
  9519.  yyIndentSelectorTree ("GOTO_VAR", yyt->ASS_GOTO_STMT.GOTO_VAR);
  9520. }
  9521.  
  9522. static void yWriteCOMP_GOTO_STMT
  9523. # if defined __STDC__ | defined __cplusplus
  9524.  (tTree yyt)
  9525. # else
  9526.  (yyt) tTree yyt;
  9527. # endif
  9528. {
  9529.  (void) fputs (Tree_NodeName [kCOMP_GOTO_STMT], yyf); (void) fputc ('\n', yyf);
  9530.  yyIndentSelectorTree ("GOTO_LABELS", yyt->COMP_GOTO_STMT.GOTO_LABELS);
  9531. }
  9532.  
  9533. static void yWriteCOMP_IF_STMT
  9534. # if defined __STDC__ | defined __cplusplus
  9535.  (tTree yyt)
  9536. # else
  9537.  (yyt) tTree yyt;
  9538. # endif
  9539. {
  9540.  (void) fputs (Tree_NodeName [kCOMP_IF_STMT], yyf); (void) fputc ('\n', yyf);
  9541.  yyIndentSelector ("IF_LT_LABEL"); writeint (yyt->COMP_IF_STMT.IF_LT_LABEL) yyWriteNl ();
  9542.  yyIndentSelector ("IF_EQ_LABEL"); writeint (yyt->COMP_IF_STMT.IF_EQ_LABEL) yyWriteNl ();
  9543.  yyIndentSelector ("IF_GT_LABEL"); writeint (yyt->COMP_IF_STMT.IF_GT_LABEL) yyWriteNl ();
  9544. }
  9545.  
  9546. static void yWriteRETURN_STMT
  9547. # if defined __STDC__ | defined __cplusplus
  9548.  (tTree yyt)
  9549. # else
  9550.  (yyt) tTree yyt;
  9551. # endif
  9552. {
  9553.  (void) fputs (Tree_NodeName [kRETURN_STMT], yyf); (void) fputc ('\n', yyf);
  9554. }
  9555.  
  9556. static void yWritePAUSE_STMT
  9557. # if defined __STDC__ | defined __cplusplus
  9558.  (tTree yyt)
  9559. # else
  9560.  (yyt) tTree yyt;
  9561. # endif
  9562. {
  9563.  (void) fputs (Tree_NodeName [kPAUSE_STMT], yyf); (void) fputc ('\n', yyf);
  9564. }
  9565.  
  9566. static void yWriteEXIT_STMT
  9567. # if defined __STDC__ | defined __cplusplus
  9568.  (tTree yyt)
  9569. # else
  9570.  (yyt) tTree yyt;
  9571. # endif
  9572. {
  9573.  (void) fputs (Tree_NodeName [kEXIT_STMT], yyf); (void) fputc ('\n', yyf);
  9574.  yyIndentSelector ("loopid"); writetIdent (yyt->EXIT_STMT.loopid) yyWriteNl ();
  9575. }
  9576.  
  9577. static void yWriteCYCLE_STMT
  9578. # if defined __STDC__ | defined __cplusplus
  9579.  (tTree yyt)
  9580. # else
  9581.  (yyt) tTree yyt;
  9582. # endif
  9583. {
  9584.  (void) fputs (Tree_NodeName [kCYCLE_STMT], yyf); (void) fputc ('\n', yyf);
  9585.  yyIndentSelector ("loopid"); writetIdent (yyt->CYCLE_STMT.loopid) yyWriteNl ();
  9586. }
  9587.  
  9588. static void yWriteSTOP_STMT
  9589. # if defined __STDC__ | defined __cplusplus
  9590.  (tTree yyt)
  9591. # else
  9592.  (yyt) tTree yyt;
  9593. # endif
  9594. {
  9595.  (void) fputs (Tree_NodeName [kSTOP_STMT], yyf); (void) fputc ('\n', yyf);
  9596. }
  9597.  
  9598. static void yWriteFORMAT_STMT
  9599. # if defined __STDC__ | defined __cplusplus
  9600.  (tTree yyt)
  9601. # else
  9602.  (yyt) tTree yyt;
  9603. # endif
  9604. {
  9605.  (void) fputs (Tree_NodeName [kFORMAT_STMT], yyf); (void) fputc ('\n', yyf);
  9606. }
  9607.  
  9608. static void yWriteALLOCATE_STMT
  9609. # if defined __STDC__ | defined __cplusplus
  9610.  (tTree yyt)
  9611. # else
  9612.  (yyt) tTree yyt;
  9613. # endif
  9614. {
  9615.  (void) fputs (Tree_NodeName [kALLOCATE_STMT], yyf); (void) fputc ('\n', yyf);
  9616.  yyIndentSelectorTree ("PARAMS", yyt->ALLOCATE_STMT.PARAMS);
  9617. }
  9618.  
  9619. static void yWriteDEALLOCATE_STMT
  9620. # if defined __STDC__ | defined __cplusplus
  9621.  (tTree yyt)
  9622. # else
  9623.  (yyt) tTree yyt;
  9624. # endif
  9625. {
  9626.  (void) fputs (Tree_NodeName [kDEALLOCATE_STMT], yyf); (void) fputc ('\n', yyf);
  9627.  yyIndentSelectorTree ("PARAMS", yyt->DEALLOCATE_STMT.PARAMS);
  9628. }
  9629.  
  9630. static void yWriteNULLIFY_STMT
  9631. # if defined __STDC__ | defined __cplusplus
  9632.  (tTree yyt)
  9633. # else
  9634.  (yyt) tTree yyt;
  9635. # endif
  9636. {
  9637.  (void) fputs (Tree_NodeName [kNULLIFY_STMT], yyf); (void) fputc ('\n', yyf);
  9638. }
  9639.  
  9640. static void yWriteREDUCE_STMT
  9641. # if defined __STDC__ | defined __cplusplus
  9642.  (tTree yyt)
  9643. # else
  9644.  (yyt) tTree yyt;
  9645. # endif
  9646. {
  9647.  (void) fputs (Tree_NodeName [kREDUCE_STMT], yyf); (void) fputc ('\n', yyf);
  9648.  yyIndentSelectorTree ("RED_FUNC", yyt->REDUCE_STMT.RED_FUNC);
  9649. }
  9650.  
  9651. static void yWriteGLOBAL_STMT
  9652. # if defined __STDC__ | defined __cplusplus
  9653.  (tTree yyt)
  9654. # else
  9655.  (yyt) tTree yyt;
  9656. # endif
  9657. {
  9658.  (void) fputs (Tree_NodeName [kGLOBAL_STMT], yyf); (void) fputc ('\n', yyf);
  9659.  yyIndentSelector ("func"); writetIdent (yyt->GLOBAL_STMT.func) yyWriteNl ();
  9660.  yyIndentSelectorTree ("ARRAY", yyt->GLOBAL_STMT.ARRAY);
  9661.  yyIndentSelectorTree ("INDEXED_ARRAY", yyt->GLOBAL_STMT.INDEXED_ARRAY);
  9662.  yyIndentSelectorTree ("INDEXES", yyt->GLOBAL_STMT.INDEXES);
  9663. }
  9664.  
  9665. static void yWriteALIGN_STMT
  9666. # if defined __STDC__ | defined __cplusplus
  9667.  (tTree yyt)
  9668. # else
  9669.  (yyt) tTree yyt;
  9670. # endif
  9671. {
  9672.  (void) fputs (Tree_NodeName [kALIGN_STMT], yyf); (void) fputc ('\n', yyf);
  9673.  yyIndentSelectorTree ("ALIGNEE", yyt->ALIGN_STMT.ALIGNEE);
  9674. }
  9675.  
  9676. static void yWriteDISTRIBUTE_STMT
  9677. # if defined __STDC__ | defined __cplusplus
  9678.  (tTree yyt)
  9679. # else
  9680.  (yyt) tTree yyt;
  9681. # endif
  9682. {
  9683.  (void) fputs (Tree_NodeName [kDISTRIBUTE_STMT], yyf); (void) fputc ('\n', yyf);
  9684.  yyIndentSelectorTree ("DISTRIBUTEE", yyt->DISTRIBUTE_STMT.DISTRIBUTEE);
  9685.  yyIndentSelector ("target"); writetIdent (yyt->DISTRIBUTE_STMT.target) yyWriteNl ();
  9686. }
  9687.  
  9688. static void yWriteLABEL_LIST
  9689. # if defined __STDC__ | defined __cplusplus
  9690.  (tTree yyt)
  9691. # else
  9692.  (yyt) tTree yyt;
  9693. # endif
  9694. {
  9695.  (void) fputs (Tree_NodeName [kLABEL_LIST], yyf); (void) fputc ('\n', yyf);
  9696.  yyIndentSelector ("Elem"); writeint (yyt->LABEL_LIST.Elem) yyWriteNl ();
  9697. }
  9698.  
  9699. static void yWriteOP_DEFINED
  9700. # if defined __STDC__ | defined __cplusplus
  9701.  (tTree yyt)
  9702. # else
  9703.  (yyt) tTree yyt;
  9704. # endif
  9705. {
  9706.  (void) fputs (Tree_NodeName [kOP_DEFINED], yyf); (void) fputc ('\n', yyf);
  9707.  yyIndentSelector ("opname"); writetIdent (yyt->OP_DEFINED.opname) yyWriteNl ();
  9708. }
  9709.  
  9710. static void yWriteCONST_EXP
  9711. # if defined __STDC__ | defined __cplusplus
  9712.  (tTree yyt)
  9713. # else
  9714.  (yyt) tTree yyt;
  9715. # endif
  9716. {
  9717.  (void) fputs (Tree_NodeName [kCONST_EXP], yyf); (void) fputc ('\n', yyf);
  9718. }
  9719.  
  9720. static void yWriteOP_EXP
  9721. # if defined __STDC__ | defined __cplusplus
  9722.  (tTree yyt)
  9723. # else
  9724.  (yyt) tTree yyt;
  9725. # endif
  9726. {
  9727.  (void) fputs (Tree_NodeName [kOP_EXP], yyf); (void) fputc ('\n', yyf);
  9728.  yyIndentSelectorTree ("EXP_OP", yyt->OP_EXP.EXP_OP);
  9729.  yyIndentSelectorTree ("OPND1", yyt->OP_EXP.OPND1);
  9730. }
  9731.  
  9732. static void yWriteOP1_EXP
  9733. # if defined __STDC__ | defined __cplusplus
  9734.  (tTree yyt)
  9735. # else
  9736.  (yyt) tTree yyt;
  9737. # endif
  9738. {
  9739.  (void) fputs (Tree_NodeName [kOP1_EXP], yyf); (void) fputc ('\n', yyf);
  9740.  yyIndentSelectorTree ("EXP_OP1", yyt->OP1_EXP.EXP_OP1);
  9741. }
  9742.  
  9743. static void yWriteSLICE_EXP
  9744. # if defined __STDC__ | defined __cplusplus
  9745.  (tTree yyt)
  9746. # else
  9747.  (yyt) tTree yyt;
  9748. # endif
  9749. {
  9750.  (void) fputs (Tree_NodeName [kSLICE_EXP], yyf); (void) fputc ('\n', yyf);
  9751.  yyIndentSelectorTree ("START", yyt->SLICE_EXP.START);
  9752.  yyIndentSelectorTree ("STOP", yyt->SLICE_EXP.STOP);
  9753. }
  9754.  
  9755. static void yWritePOSTFIX_EXP
  9756. # if defined __STDC__ | defined __cplusplus
  9757.  (tTree yyt)
  9758. # else
  9759.  (yyt) tTree yyt;
  9760. # endif
  9761. {
  9762.  (void) fputs (Tree_NodeName [kPOSTFIX_EXP], yyf); (void) fputc ('\n', yyf);
  9763.  yyIndentSelectorTree ("POSTFIX_OP", yyt->POSTFIX_EXP.POSTFIX_OP);
  9764. }
  9765.  
  9766. static void yWriteCALL_EXP
  9767. # if defined __STDC__ | defined __cplusplus
  9768.  (tTree yyt)
  9769. # else
  9770.  (yyt) tTree yyt;
  9771. # endif
  9772. {
  9773.  (void) fputs (Tree_NodeName [kCALL_EXP], yyf); (void) fputc ('\n', yyf);
  9774.  yyIndentSelectorTree ("FUNC_ID", yyt->CALL_EXP.FUNC_ID);
  9775. }
  9776.  
  9777. static void yWriteCAST_EXP
  9778. # if defined __STDC__ | defined __cplusplus
  9779.  (tTree yyt)
  9780. # else
  9781.  (yyt) tTree yyt;
  9782. # endif
  9783. {
  9784.  (void) fputs (Tree_NodeName [kCAST_EXP], yyf); (void) fputc ('\n', yyf);
  9785.  yyIndentSelectorTree ("ID", yyt->CAST_EXP.ID);
  9786. }
  9787.  
  9788. static void yWriteINDEXED_EXP
  9789. # if defined __STDC__ | defined __cplusplus
  9790.  (tTree yyt)
  9791. # else
  9792.  (yyt) tTree yyt;
  9793. # endif
  9794. {
  9795.  (void) fputs (Tree_NodeName [kINDEXED_EXP], yyf); (void) fputc ('\n', yyf);
  9796.  yyIndentSelectorTree ("IND_EXP", yyt->INDEXED_EXP.IND_EXP);
  9797. }
  9798.  
  9799. static void yWriteSELECTED_EXP
  9800. # if defined __STDC__ | defined __cplusplus
  9801.  (tTree yyt)
  9802. # else
  9803.  (yyt) tTree yyt;
  9804. # endif
  9805. {
  9806.  (void) fputs (Tree_NodeName [kSELECTED_EXP], yyf); (void) fputc ('\n', yyf);
  9807.  yyIndentSelectorTree ("SELEC_EXP", yyt->SELECTED_EXP.SELEC_EXP);
  9808. }
  9809.  
  9810. static void yWriteASSIGN_EXP
  9811. # if defined __STDC__ | defined __cplusplus
  9812.  (tTree yyt)
  9813. # else
  9814.  (yyt) tTree yyt;
  9815. # endif
  9816. {
  9817.  (void) fputs (Tree_NodeName [kASSIGN_EXP], yyf); (void) fputc ('\n', yyf);
  9818.  yyIndentSelectorTree ("ASSIGN_OP", yyt->ASSIGN_EXP.ASSIGN_OP);
  9819.  yyIndentSelectorTree ("LHS", yyt->ASSIGN_EXP.LHS);
  9820. }
  9821.  
  9822. static void yWriteUSED_EXP
  9823. # if defined __STDC__ | defined __cplusplus
  9824.  (tTree yyt)
  9825. # else
  9826.  (yyt) tTree yyt;
  9827. # endif
  9828. {
  9829.  (void) fputs (Tree_NodeName [kUSED_EXP], yyf); (void) fputc ('\n', yyf);
  9830. }
  9831.  
  9832. static void yWriteCOND_EXP
  9833. # if defined __STDC__ | defined __cplusplus
  9834.  (tTree yyt)
  9835. # else
  9836.  (yyt) tTree yyt;
  9837. # endif
  9838. {
  9839.  (void) fputs (Tree_NodeName [kCOND_EXP], yyf); (void) fputc ('\n', yyf);
  9840.  yyIndentSelectorTree ("COND", yyt->COND_EXP.COND);
  9841.  yyIndentSelectorTree ("TRUE_EXP", yyt->COND_EXP.TRUE_EXP);
  9842. }
  9843.  
  9844. static void yWriteVAR_EXP
  9845. # if defined __STDC__ | defined __cplusplus
  9846.  (tTree yyt)
  9847. # else
  9848.  (yyt) tTree yyt;
  9849. # endif
  9850. {
  9851.  (void) fputs (Tree_NodeName [kVAR_EXP], yyf); (void) fputc ('\n', yyf);
  9852. }
  9853.  
  9854. static void yWriteFUNC_CALL_EXP
  9855. # if defined __STDC__ | defined __cplusplus
  9856.  (tTree yyt)
  9857. # else
  9858.  (yyt) tTree yyt;
  9859. # endif
  9860. {
  9861.  (void) fputs (Tree_NodeName [kFUNC_CALL_EXP], yyf); (void) fputc ('\n', yyf);
  9862.  yyIndentSelectorTree ("FUNC_ID", yyt->FUNC_CALL_EXP.FUNC_ID);
  9863. }
  9864.  
  9865. static void yWriteNAMED_EXP
  9866. # if defined __STDC__ | defined __cplusplus
  9867.  (tTree yyt)
  9868. # else
  9869.  (yyt) tTree yyt;
  9870. # endif
  9871. {
  9872.  (void) fputs (Tree_NodeName [kNAMED_EXP], yyf); (void) fputc ('\n', yyf);
  9873.  yyIndentSelector ("Name"); writetIdent (yyt->NAMED_EXP.Name) yyWriteNl ();
  9874. }
  9875.  
  9876. static void yWriteDO_EXP
  9877. # if defined __STDC__ | defined __cplusplus
  9878.  (tTree yyt)
  9879. # else
  9880.  (yyt) tTree yyt;
  9881. # endif
  9882. {
  9883.  (void) fputs (Tree_NodeName [kDO_EXP], yyf); (void) fputc ('\n', yyf);
  9884.  yyIndentSelectorTree ("DO_ID", yyt->DO_EXP.DO_ID);
  9885.  yyIndentSelectorTree ("RANGE", yyt->DO_EXP.RANGE);
  9886. }
  9887.  
  9888. static void yWriteTYPE_EXP
  9889. # if defined __STDC__ | defined __cplusplus
  9890.  (tTree yyt)
  9891. # else
  9892.  (yyt) tTree yyt;
  9893. # endif
  9894. {
  9895.  (void) fputs (Tree_NodeName [kTYPE_EXP], yyf); (void) fputc ('\n', yyf);
  9896.  yyIndentSelectorTree ("ID", yyt->TYPE_EXP.ID);
  9897. }
  9898.  
  9899. static void yWriteARRAY_EXP
  9900. # if defined __STDC__ | defined __cplusplus
  9901.  (tTree yyt)
  9902. # else
  9903.  (yyt) tTree yyt;
  9904. # endif
  9905. {
  9906.  (void) fputs (Tree_NodeName [kARRAY_EXP], yyf); (void) fputc ('\n', yyf);
  9907. }
  9908.  
  9909. static void yWriteBTE_LIST
  9910. # if defined __STDC__ | defined __cplusplus
  9911.  (tTree yyt)
  9912. # else
  9913.  (yyt) tTree yyt;
  9914. # endif
  9915. {
  9916.  (void) fputs (Tree_NodeName [kBTE_LIST], yyf); (void) fputc ('\n', yyf);
  9917.  yyIndentSelectorTree ("Elem", yyt->BTE_LIST.Elem);
  9918. }
  9919.  
  9920. static void yWriteUSED_VAR
  9921. # if defined __STDC__ | defined __cplusplus
  9922.  (tTree yyt)
  9923. # else
  9924.  (yyt) tTree yyt;
  9925. # endif
  9926. {
  9927.  (void) fputs (Tree_NodeName [kUSED_VAR], yyf); (void) fputc ('\n', yyf);
  9928. }
  9929.  
  9930. static void yWriteINDEXED_VAR
  9931. # if defined __STDC__ | defined __cplusplus
  9932.  (tTree yyt)
  9933. # else
  9934.  (yyt) tTree yyt;
  9935. # endif
  9936. {
  9937.  (void) fputs (Tree_NodeName [kINDEXED_VAR], yyf); (void) fputc ('\n', yyf);
  9938.  yyIndentSelectorTree ("IND_VAR", yyt->INDEXED_VAR.IND_VAR);
  9939. }
  9940.  
  9941. static void yWriteSUBSTRING_VAR
  9942. # if defined __STDC__ | defined __cplusplus
  9943.  (tTree yyt)
  9944. # else
  9945.  (yyt) tTree yyt;
  9946. # endif
  9947. {
  9948.  (void) fputs (Tree_NodeName [kSUBSTRING_VAR], yyf); (void) fputc ('\n', yyf);
  9949.  yyIndentSelectorTree ("IND_VAR", yyt->SUBSTRING_VAR.IND_VAR);
  9950. }
  9951.  
  9952. static void yWriteSELECTED_VAR
  9953. # if defined __STDC__ | defined __cplusplus
  9954.  (tTree yyt)
  9955. # else
  9956.  (yyt) tTree yyt;
  9957. # endif
  9958. {
  9959.  (void) fputs (Tree_NodeName [kSELECTED_VAR], yyf); (void) fputc ('\n', yyf);
  9960.  yyIndentSelectorTree ("SELEC_VAR", yyt->SELECTED_VAR.SELEC_VAR);
  9961. }
  9962.  
  9963. static void yWriteLOOP_VAR
  9964. # if defined __STDC__ | defined __cplusplus
  9965.  (tTree yyt)
  9966. # else
  9967.  (yyt) tTree yyt;
  9968. # endif
  9969. {
  9970.  (void) fputs (Tree_NodeName [kLOOP_VAR], yyf); (void) fputc ('\n', yyf);
  9971. }
  9972.  
  9973. static void yWriteADDR
  9974. # if defined __STDC__ | defined __cplusplus
  9975.  (tTree yyt)
  9976. # else
  9977.  (yyt) tTree yyt;
  9978. # endif
  9979. {
  9980.  (void) fputs (Tree_NodeName [kADDR], yyf); (void) fputc ('\n', yyf);
  9981. }
  9982.  
  9983. static void yWriteDO_VAR
  9984. # if defined __STDC__ | defined __cplusplus
  9985.  (tTree yyt)
  9986. # else
  9987.  (yyt) tTree yyt;
  9988. # endif
  9989. {
  9990.  (void) fputs (Tree_NodeName [kDO_VAR], yyf); (void) fputc ('\n', yyf);
  9991.  yyIndentSelectorTree ("DO_ID", yyt->DO_VAR.DO_ID);
  9992.  yyIndentSelectorTree ("RANGE", yyt->DO_VAR.RANGE);
  9993. }
  9994.  
  9995. static void yWriteBTV_LIST
  9996. # if defined __STDC__ | defined __cplusplus
  9997.  (tTree yyt)
  9998. # else
  9999.  (yyt) tTree yyt;
  10000. # endif
  10001. {
  10002.  (void) fputs (Tree_NodeName [kBTV_LIST], yyf); (void) fputc ('\n', yyf);
  10003.  yyIndentSelectorTree ("Elem", yyt->BTV_LIST.Elem);
  10004. }
  10005.  
  10006. static void yWriteVAR_PARAM
  10007. # if defined __STDC__ | defined __cplusplus
  10008.  (tTree yyt)
  10009. # else
  10010.  (yyt) tTree yyt;
  10011. # endif
  10012. {
  10013.  (void) fputs (Tree_NodeName [kVAR_PARAM], yyf); (void) fputc ('\n', yyf);
  10014. }
  10015.  
  10016. static void yWriteVALUE_PARAM
  10017. # if defined __STDC__ | defined __cplusplus
  10018.  (tTree yyt)
  10019. # else
  10020.  (yyt) tTree yyt;
  10021. # endif
  10022. {
  10023.  (void) fputs (Tree_NodeName [kVALUE_PARAM], yyf); (void) fputc ('\n', yyf);
  10024. }
  10025.  
  10026. static void yWriteNAMED_PARAM
  10027. # if defined __STDC__ | defined __cplusplus
  10028.  (tTree yyt)
  10029. # else
  10030.  (yyt) tTree yyt;
  10031. # endif
  10032. {
  10033.  (void) fputs (Tree_NodeName [kNAMED_PARAM], yyf); (void) fputc ('\n', yyf);
  10034.  yyIndentSelector ("Name"); writetIdent (yyt->NAMED_PARAM.Name) yyWriteNl ();
  10035. }
  10036.  
  10037. static void yWritePROC_PARAM
  10038. # if defined __STDC__ | defined __cplusplus
  10039.  (tTree yyt)
  10040. # else
  10041.  (yyt) tTree yyt;
  10042. # endif
  10043. {
  10044.  (void) fputs (Tree_NodeName [kPROC_PARAM], yyf); (void) fputc ('\n', yyf);
  10045. }
  10046.  
  10047. static void yWriteFUNC_PARAM
  10048. # if defined __STDC__ | defined __cplusplus
  10049.  (tTree yyt)
  10050. # else
  10051.  (yyt) tTree yyt;
  10052. # endif
  10053. {
  10054.  (void) fputs (Tree_NodeName [kFUNC_PARAM], yyf); (void) fputc ('\n', yyf);
  10055. }
  10056.  
  10057. static void yWriteFORMAT_PARAM
  10058. # if defined __STDC__ | defined __cplusplus
  10059.  (tTree yyt)
  10060. # else
  10061.  (yyt) tTree yyt;
  10062. # endif
  10063. {
  10064.  (void) fputs (Tree_NodeName [kFORMAT_PARAM], yyf); (void) fputc ('\n', yyf);
  10065.  yyIndentSelector ("S"); writetStringRef (yyt->FORMAT_PARAM.S) yyWriteNl ();
  10066. }
  10067.  
  10068. static void yWriteRETURN_PARAM
  10069. # if defined __STDC__ | defined __cplusplus
  10070.  (tTree yyt)
  10071. # else
  10072.  (yyt) tTree yyt;
  10073. # endif
  10074. {
  10075.  (void) fputs (Tree_NodeName [kRETURN_PARAM], yyf); (void) fputc ('\n', yyf);
  10076.  yyIndentSelector ("label"); writeint (yyt->RETURN_PARAM.label) yyWriteNl ();
  10077. }
  10078.  
  10079. static void yWriteBTP_LIST
  10080. # if defined __STDC__ | defined __cplusplus
  10081.  (tTree yyt)
  10082. # else
  10083.  (yyt) tTree yyt;
  10084. # endif
  10085. {
  10086.  (void) fputs (Tree_NodeName [kBTP_LIST], yyf); (void) fputc ('\n', yyf);
  10087.  yyIndentSelectorTree ("Elem", yyt->BTP_LIST.Elem);
  10088. }
  10089.  
  10090. static void yWriteBOOL_CONSTANT
  10091. # if defined __STDC__ | defined __cplusplus
  10092.  (tTree yyt)
  10093. # else
  10094.  (yyt) tTree yyt;
  10095. # endif
  10096. {
  10097.  (void) fputs (Tree_NodeName [kBOOL_CONSTANT], yyf); (void) fputc ('\n', yyf);
  10098.  yyIndentSelector ("value"); writeint (yyt->BOOL_CONSTANT.value) yyWriteNl ();
  10099. }
  10100.  
  10101. static void yWriteINT_CONSTANT
  10102. # if defined __STDC__ | defined __cplusplus
  10103.  (tTree yyt)
  10104. # else
  10105.  (yyt) tTree yyt;
  10106. # endif
  10107. {
  10108.  (void) fputs (Tree_NodeName [kINT_CONSTANT], yyf); (void) fputc ('\n', yyf);
  10109.  yyIndentSelector ("value"); writeint (yyt->INT_CONSTANT.value) yyWriteNl ();
  10110. }
  10111.  
  10112. static void yWriteREAL_CONSTANT
  10113. # if defined __STDC__ | defined __cplusplus
  10114.  (tTree yyt)
  10115. # else
  10116.  (yyt) tTree yyt;
  10117. # endif
  10118. {
  10119.  (void) fputs (Tree_NodeName [kREAL_CONSTANT], yyf); (void) fputc ('\n', yyf);
  10120.  yyIndentSelector ("value"); writetStringRef (yyt->REAL_CONSTANT.value) yyWriteNl ();
  10121. }
  10122.  
  10123. static void yWriteDREAL_CONSTANT
  10124. # if defined __STDC__ | defined __cplusplus
  10125.  (tTree yyt)
  10126. # else
  10127.  (yyt) tTree yyt;
  10128. # endif
  10129. {
  10130.  (void) fputs (Tree_NodeName [kDREAL_CONSTANT], yyf); (void) fputc ('\n', yyf);
  10131.  yyIndentSelector ("value"); writetStringRef (yyt->DREAL_CONSTANT.value) yyWriteNl ();
  10132. }
  10133.  
  10134. static void yWriteCHAR_CONSTANT
  10135. # if defined __STDC__ | defined __cplusplus
  10136.  (tTree yyt)
  10137. # else
  10138.  (yyt) tTree yyt;
  10139. # endif
  10140. {
  10141.  (void) fputs (Tree_NodeName [kCHAR_CONSTANT], yyf); (void) fputc ('\n', yyf);
  10142.  yyIndentSelector ("value"); writechar (yyt->CHAR_CONSTANT.value) yyWriteNl ();
  10143. }
  10144.  
  10145. static void yWriteSTRING_CONSTANT
  10146. # if defined __STDC__ | defined __cplusplus
  10147.  (tTree yyt)
  10148. # else
  10149.  (yyt) tTree yyt;
  10150. # endif
  10151. {
  10152.  (void) fputs (Tree_NodeName [kSTRING_CONSTANT], yyf); (void) fputc ('\n', yyf);
  10153.  yyIndentSelector ("value"); writetStringRef (yyt->STRING_CONSTANT.value) yyWriteNl ();
  10154. }
  10155.  
  10156. static void yWriteCOMPLEX_CONSTANT
  10157. # if defined __STDC__ | defined __cplusplus
  10158.  (tTree yyt)
  10159. # else
  10160.  (yyt) tTree yyt;
  10161. # endif
  10162. {
  10163.  (void) fputs (Tree_NodeName [kCOMPLEX_CONSTANT], yyf); (void) fputc ('\n', yyf);
  10164.  yyIndentSelector ("rvalue"); writetStringRef (yyt->COMPLEX_CONSTANT.rvalue) yyWriteNl ();
  10165.  yyIndentSelector ("ivalue"); writetStringRef (yyt->COMPLEX_CONSTANT.ivalue) yyWriteNl ();
  10166. }
  10167.  
  10168. static void yWritePROC_OBJ
  10169. # if defined __STDC__ | defined __cplusplus
  10170.  (tTree yyt)
  10171. # else
  10172.  (yyt) tTree yyt;
  10173. # endif
  10174. {
  10175.  (void) fputs (Tree_NodeName [kPROC_OBJ], yyf); (void) fputc ('\n', yyf);
  10176.  yyIndentSelector ("Ident"); writetIdent (yyt->PROC_OBJ.Ident) yyWriteNl ();
  10177.  yyIndentSelector ("Object"); writetDefinitions (yyt->PROC_OBJ.Object) yyWriteNl ();
  10178. }
  10179.  
  10180. static void yWriteVAR_OBJ
  10181. # if defined __STDC__ | defined __cplusplus
  10182.  (tTree yyt)
  10183. # else
  10184.  (yyt) tTree yyt;
  10185. # endif
  10186. {
  10187.  (void) fputs (Tree_NodeName [kVAR_OBJ], yyf); (void) fputc ('\n', yyf);
  10188.  yyIndentSelector ("Pos"); writeint (yyt->VAR_OBJ.Pos) yyWriteNl ();
  10189.  yyIndentSelector ("Ident"); writetIdent (yyt->VAR_OBJ.Ident) yyWriteNl ();
  10190.  yyIndentSelector ("Object"); writetDefinitions (yyt->VAR_OBJ.Object) yyWriteNl ();
  10191. }
  10192.  
  10193. static void yWriteTYPE_OBJ
  10194. # if defined __STDC__ | defined __cplusplus
  10195.  (tTree yyt)
  10196. # else
  10197.  (yyt) tTree yyt;
  10198. # endif
  10199. {
  10200.  (void) fputs (Tree_NodeName [kTYPE_OBJ], yyf); (void) fputc ('\n', yyf);
  10201.  yyIndentSelector ("Ident"); writetIdent (yyt->TYPE_OBJ.Ident) yyWriteNl ();
  10202.  yyIndentSelector ("Object"); writetDefinitions (yyt->TYPE_OBJ.Object) yyWriteNl ();
  10203. }
  10204.  
  10205. static void yWriteREC_COMP
  10206. # if defined __STDC__ | defined __cplusplus
  10207.  (tTree yyt)
  10208. # else
  10209.  (yyt) tTree yyt;
  10210. # endif
  10211. {
  10212.  (void) fputs (Tree_NodeName [kREC_COMP], yyf); (void) fputc ('\n', yyf);
  10213.  yyIndentSelector ("Ident"); writetIdent (yyt->REC_COMP.Ident) yyWriteNl ();
  10214.  yyIndentSelector ("Object"); writetDefinitions (yyt->REC_COMP.Object) yyWriteNl ();
  10215. }
  10216.  
  10217. static void yyWriteTree
  10218. # if defined __STDC__ | defined __cplusplus
  10219.  (tTree yyt)
  10220. # else
  10221.  (yyt) tTree yyt;
  10222. # endif
  10223. { unsigned short yyLevel = yyIndentLevel;
  10224.  for (;;) {
  10225.   if (yyt == NoTree) { (void) fputs (" NoTree\n", yyf); goto yyExit;
  10226.   } else if (yyt->yyHead.yyMark == 0) { (void) fprintf (yyf, "^%d\n", yyMapToLabel (yyt)); goto yyExit;
  10227.   } else if (yyt->yyHead.yyMark > 1) {
  10228.    register int yyi;
  10229.    (void) fprintf (yyf, "\n%06d:", yyMapToLabel (yyt));
  10230.    for (yyi = 8; yyi <= yyIndentLevel; yyi ++) (void) putc (' ', yyf);
  10231.   } else (void) putc (' ', yyf);
  10232.   yyt->yyHead.yyMark = 0;
  10233.   yyIndentLevel += 2;
  10234.  
  10235.   switch (yyt->Kind) {
  10236. case kCOMP_UNIT: yWriteCOMP_UNIT (yyt); yyIndentSelector ("COMP_ELEMENTS"); yyt = yyt->COMP_UNIT.COMP_ELEMENTS; break;
  10237. case kBODY_NODE: yWriteBODY_NODE (yyt); yyIndentSelector ("INTERNALS"); yyt = yyt->BODY_NODE.INTERNALS; break;
  10238. case kTYPE_NODE: (void) fputs (Tree_NodeName [kTYPE_NODE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10239. case kDUMMY_TYPE: (void) fputs (Tree_NodeName [kDUMMY_TYPE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10240. case kVOID_TYPE: (void) fputs (Tree_NodeName [kVOID_TYPE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10241. case kINTEGER_TYPE: yWriteINTEGER_TYPE (yyt); goto yyExit;
  10242. case kCARDINAL_TYPE: yWriteCARDINAL_TYPE (yyt); goto yyExit;
  10243. case kREAL_TYPE: yWriteREAL_TYPE (yyt); goto yyExit;
  10244. case kBOOLEAN_TYPE: yWriteBOOLEAN_TYPE (yyt); goto yyExit;
  10245. case kCOMPLEX_TYPE: yWriteCOMPLEX_TYPE (yyt); goto yyExit;
  10246. case kCHAR_TYPE: (void) fputs (Tree_NodeName [kCHAR_TYPE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10247. case kSTRING_TYPE: yWriteSTRING_TYPE (yyt); yyIndentSelector ("LENGTH"); yyt = yyt->STRING_TYPE.LENGTH; break;
  10248. case kINDEX_TYPE: yWriteINDEX_TYPE (yyt); yyIndentSelector ("UPPER"); yyt = yyt->INDEX_TYPE.UPPER; break;
  10249. case kTYPE_ID: yWriteTYPE_ID (yyt); yyIndentSelector ("ID"); yyt = yyt->TYPE_ID.ID; break;
  10250. case kARRAY_TYPE: yWriteARRAY_TYPE (yyt); yyIndentSelector ("ARRAY_COMP_TYPE"); yyt = yyt->ARRAY_TYPE.ARRAY_COMP_TYPE; break;
  10251. case kRECORD_TYPE: yWriteRECORD_TYPE (yyt); yyIndentSelector ("COMPONENTS"); yyt = yyt->RECORD_TYPE.COMPONENTS; break;
  10252. case kUNION_TYPE: yWriteUNION_TYPE (yyt); yyIndentSelector ("COMPONENTS"); yyt = yyt->UNION_TYPE.COMPONENTS; break;
  10253. case kENUM_TYPE: yWriteENUM_TYPE (yyt); yyIndentSelector ("COMPONENTS"); yyt = yyt->ENUM_TYPE.COMPONENTS; break;
  10254. case kDYNAMIC: yWriteDYNAMIC (yyt); goto yyExit;
  10255. case kPOINTER_TYPE: yWritePOINTER_TYPE (yyt); yyIndentSelector ("PTR_COMP"); yyt = yyt->POINTER_TYPE.PTR_COMP; break;
  10256. case kARRAY1_TYPE: yWriteARRAY1_TYPE (yyt); yyIndentSelector ("ARRAY1_COMP_TYPE"); yyt = yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE; break;
  10257. case kFUNCTION_TYPE: yWriteFUNCTION_TYPE (yyt); yyIndentSelector ("RESULT_TYPE"); yyt = yyt->FUNCTION_TYPE.RESULT_TYPE; break;
  10258. case kTYPE_NODE_LIST: (void) fputs (Tree_NodeName [kTYPE_NODE_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10259. case kTYPE_EMPTY: (void) fputs (Tree_NodeName [kTYPE_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10260. case kTYPE_LIST: yWriteTYPE_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->TYPE_LIST.Next; break;
  10261. case kDECL_NODE: yWriteDECL_NODE (yyt); goto yyExit;
  10262. case kMODULE_DECL: yWriteMODULE_DECL (yyt); yyIndentSelector ("MODULE_BODY"); yyt = yyt->MODULE_DECL.MODULE_BODY; break;
  10263. case kPROGRAM_DECL: yWritePROGRAM_DECL (yyt); yyIndentSelector ("PROGRAM_BODY"); yyt = yyt->PROGRAM_DECL.PROGRAM_BODY; break;
  10264. case kPROC_DECL: yWritePROC_DECL (yyt); yyIndentSelector ("PROC_BODY"); yyt = yyt->PROC_DECL.PROC_BODY; break;
  10265. case kFUNC_DECL: yWriteFUNC_DECL (yyt); yyIndentSelector ("RESULT_TYPE"); yyt = yyt->FUNC_DECL.RESULT_TYPE; break;
  10266. case kBLOCK_DATA_DECL: yWriteBLOCK_DATA_DECL (yyt); yyIndentSelector ("DATA_BODY"); yyt = yyt->BLOCK_DATA_DECL.DATA_BODY; break;
  10267. case kTYPE_DECL: yWriteTYPE_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->TYPE_DECL.VAL; break;
  10268. case kNAME_DECL: yWriteNAME_DECL (yyt); goto yyExit;
  10269. case kRENAME_DECL: yWriteRENAME_DECL (yyt); goto yyExit;
  10270. case kENTITY_DECL: yWriteENTITY_DECL (yyt); yyIndentSelector ("ATTRIBUTES"); yyt = yyt->ENTITY_DECL.ATTRIBUTES; break;
  10271. case kVAR_DECL: yWriteVAR_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->VAR_DECL.VAL; break;
  10272. case kCOMMON_DECL: yWriteCOMMON_DECL (yyt); yyIndentSelector ("IDS"); yyt = yyt->COMMON_DECL.IDS; break;
  10273. case kNAMELIST_DECL: yWriteNAMELIST_DECL (yyt); yyIndentSelector ("IDS"); yyt = yyt->NAMELIST_DECL.IDS; break;
  10274. case kTEMPLATE_DECL: yWriteTEMPLATE_DECL (yyt); yyIndentSelector ("DIMENSIONS"); yyt = yyt->TEMPLATE_DECL.DIMENSIONS; break;
  10275. case kPROCESSORS_DECL: yWritePROCESSORS_DECL (yyt); yyIndentSelector ("DIMENSIONS"); yyt = yyt->PROCESSORS_DECL.DIMENSIONS; break;
  10276. case kINHERIT_DECL: yWriteINHERIT_DECL (yyt); goto yyExit;
  10277. case kSTMT_FUNC_DECL: yWriteSTMT_FUNC_DECL (yyt); yyIndentSelector ("FFUNC_BODY"); yyt = yyt->STMT_FUNC_DECL.FFUNC_BODY; break;
  10278. case kINTERFACE_DECL: yWriteINTERFACE_DECL (yyt); yyIndentSelector ("ITEMS"); yyt = yyt->INTERFACE_DECL.ITEMS; break;
  10279. case kEXT_PROC_DECL: yWriteEXT_PROC_DECL (yyt); yyIndentSelector ("FORMALS"); yyt = yyt->EXT_PROC_DECL.FORMALS; break;
  10280. case kEXT_FUNC_DECL: yWriteEXT_FUNC_DECL (yyt); yyIndentSelector ("RESULT_TYPE"); yyt = yyt->EXT_FUNC_DECL.RESULT_TYPE; break;
  10281. case kVAL_PARAM_DECL: yWriteVAL_PARAM_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->VAL_PARAM_DECL.VAL; break;
  10282. case kVAR_PARAM_DECL: yWriteVAR_PARAM_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->VAR_PARAM_DECL.VAL; break;
  10283. case kPROC_PARAM_DECL: yWritePROC_PARAM_DECL (yyt); yyIndentSelector ("FORMAL"); yyt = yyt->PROC_PARAM_DECL.FORMAL; break;
  10284. case kFUNC_PARAM_DECL: yWriteFUNC_PARAM_DECL (yyt); yyIndentSelector ("RESULT_TYPE"); yyt = yyt->FUNC_PARAM_DECL.RESULT_TYPE; break;
  10285. case kELIPSIS_PARAM_DECL: yWriteELIPSIS_PARAM_DECL (yyt); goto yyExit;
  10286. case kRET_PARAM_DECL: yWriteRET_PARAM_DECL (yyt); goto yyExit;
  10287. case kIMPLICIT_DECL: yWriteIMPLICIT_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->IMPLICIT_DECL.VAL; break;
  10288. case kUSE_DECL: yWriteUSE_DECL (yyt); yyIndentSelector ("RENAMINGS"); yyt = yyt->USE_DECL.RENAMINGS; break;
  10289. case kONLY_USE_DECL: yWriteONLY_USE_DECL (yyt); yyIndentSelector ("NAMES"); yyt = yyt->ONLY_USE_DECL.NAMES; break;
  10290. case kEQV_DECL: yWriteEQV_DECL (yyt); yyIndentSelector ("VARS"); yyt = yyt->EQV_DECL.VARS; break;
  10291. case kDATA_DECL: yWriteDATA_DECL (yyt); yyIndentSelector ("VALS"); yyt = yyt->DATA_DECL.VALS; break;
  10292. case kDIMENSION_DECL: yWriteDIMENSION_DECL (yyt); yyIndentSelector ("INDEXES"); yyt = yyt->DIMENSION_DECL.INDEXES; break;
  10293. case kINIT_DATA_DECL: yWriteINIT_DATA_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->INIT_DATA_DECL.VAL; break;
  10294. case kTYPESPEC_DECL: yWriteTYPESPEC_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->TYPESPEC_DECL.VAL; break;
  10295. case kALLOCATABLE_DECL: yWriteALLOCATABLE_DECL (yyt); goto yyExit;
  10296. case kEXTERNAL_DECL: yWriteEXTERNAL_DECL (yyt); goto yyExit;
  10297. case kINTENT_DECL: yWriteINTENT_DECL (yyt); goto yyExit;
  10298. case kINTRINSIC_DECL: yWriteINTRINSIC_DECL (yyt); goto yyExit;
  10299. case kOPTIONAL_DECL: yWriteOPTIONAL_DECL (yyt); goto yyExit;
  10300. case kPOINTER_DECL: yWritePOINTER_DECL (yyt); goto yyExit;
  10301. case kSAVE_DECL: yWriteSAVE_DECL (yyt); goto yyExit;
  10302. case kTARGET_DECL: yWriteTARGET_DECL (yyt); goto yyExit;
  10303. case kPARAMETER_DECL: yWritePARAMETER_DECL (yyt); yyIndentSelector ("VAL"); yyt = yyt->PARAMETER_DECL.VAL; break;
  10304. case kPUBLIC_DECL: yWritePUBLIC_DECL (yyt); goto yyExit;
  10305. case kPRIVATE_DECL: yWritePRIVATE_DECL (yyt); goto yyExit;
  10306. case kDISTRIBUTE_DECL: yWriteDISTRIBUTE_DECL (yyt); yyIndentSelector ("DISTRIBUTION"); yyt = yyt->DISTRIBUTE_DECL.DISTRIBUTION; break;
  10307. case kALIGN_DECL: yWriteALIGN_DECL (yyt); yyIndentSelector ("ALIGN_SPEC"); yyt = yyt->ALIGN_DECL.ALIGN_SPEC; break;
  10308. case kDYNAMIC_DECL: yWriteDYNAMIC_DECL (yyt); goto yyExit;
  10309. case kSEQUENCE_DECL: yWriteSEQUENCE_DECL (yyt); goto yyExit;
  10310. case kNOSEQUENCE_DECL: yWriteNOSEQUENCE_DECL (yyt); goto yyExit;
  10311. case kDECL_NODE_LIST: (void) fputs (Tree_NodeName [kDECL_NODE_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10312. case kDECL_EMPTY: (void) fputs (Tree_NodeName [kDECL_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10313. case kDECL_LIST: yWriteDECL_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->DECL_LIST.Next; break;
  10314. case kDISTRIBUTION_SPEC: (void) fputs (Tree_NodeName [kDISTRIBUTION_SPEC], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10315. case kHOST_DISTRIBUTION: (void) fputs (Tree_NodeName [kHOST_DISTRIBUTION], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10316. case kREPL_DISTRIBUTION: (void) fputs (Tree_NodeName [kREPL_DISTRIBUTION], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10317. case kNODE_DISTRIBUTION: yWriteNODE_DISTRIBUTION (yyt); yyIndentSelector ("MAPPING"); yyt = yyt->NODE_DISTRIBUTION.MAPPING; break;
  10318. case kDISTRIBUTION_FORMAT: (void) fputs (Tree_NodeName [kDISTRIBUTION_FORMAT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10319. case kBLOCK_DISTRIBUTION: yWriteBLOCK_DISTRIBUTION (yyt); yyIndentSelector ("SIZE"); yyt = yyt->BLOCK_DISTRIBUTION.SIZE; break;
  10320. case kCYCLIC_DISTRIBUTION: yWriteCYCLIC_DISTRIBUTION (yyt); yyIndentSelector ("SIZE"); yyt = yyt->CYCLIC_DISTRIBUTION.SIZE; break;
  10321. case kSERIAL_DISTRIBUTION: (void) fputs (Tree_NodeName [kSERIAL_DISTRIBUTION], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10322. case kDIST_FORMAT_LIST: (void) fputs (Tree_NodeName [kDIST_FORMAT_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10323. case kDIST_EMPTY: (void) fputs (Tree_NodeName [kDIST_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10324. case kDIST_LIST: yWriteDIST_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->DIST_LIST.Next; break;
  10325. case kGENERIC_SPEC: (void) fputs (Tree_NodeName [kGENERIC_SPEC], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10326. case kNO_GENERIC_SPEC: (void) fputs (Tree_NodeName [kNO_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10327. case kID_GENERIC_SPEC: yWriteID_GENERIC_SPEC (yyt); goto yyExit;
  10328. case kOP_GENERIC_SPEC: yWriteOP_GENERIC_SPEC (yyt); yyIndentSelector ("OPERATOR"); yyt = yyt->OP_GENERIC_SPEC.OPERATOR; break;
  10329. case kASSIGN_GENERIC_SPEC: (void) fputs (Tree_NodeName [kASSIGN_GENERIC_SPEC], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10330. case kACF_NODE_LIST: (void) fputs (Tree_NodeName [kACF_NODE_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10331. case kACF_EMPTY: (void) fputs (Tree_NodeName [kACF_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10332. case kACF_LIST: yWriteACF_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->ACF_LIST.Next; break;
  10333. case kACF_NODE: yWriteACF_NODE (yyt); goto yyExit;
  10334. case kACF_DUMMY: yWriteACF_DUMMY (yyt); goto yyExit;
  10335. case kACF_BASIC: yWriteACF_BASIC (yyt); yyIndentSelector ("BASIC_STMT"); yyt = yyt->ACF_BASIC.BASIC_STMT; break;
  10336. case kACF_IF: yWriteACF_IF (yyt); yyIndentSelector ("ELSE_PART"); yyt = yyt->ACF_IF.ELSE_PART; break;
  10337. case kACF_WHERE: yWriteACF_WHERE (yyt); yyIndentSelector ("FALSE_PART"); yyt = yyt->ACF_WHERE.FALSE_PART; break;
  10338. case kACF_SWITCH: yWriteACF_SWITCH (yyt); yyIndentSelector ("SWITCH_STMT"); yyt = yyt->ACF_SWITCH.SWITCH_STMT; break;
  10339. case kACF_ALTER: yWriteACF_ALTER (yyt); yyIndentSelector ("ALTER_STMT"); yyt = yyt->ACF_ALTER.ALTER_STMT; break;
  10340. case kACF_CASE: yWriteACF_CASE (yyt); yyIndentSelector ("CASE_OTHERWISE"); yyt = yyt->ACF_CASE.CASE_OTHERWISE; break;
  10341. case kACF_WHILE: yWriteACF_WHILE (yyt); yyIndentSelector ("WHILE_BODY"); yyt = yyt->ACF_WHILE.WHILE_BODY; break;
  10342. case kACF_REPEAT: yWriteACF_REPEAT (yyt); yyIndentSelector ("REPEAT_EXP"); yyt = yyt->ACF_REPEAT.REPEAT_EXP; break;
  10343. case kACF_WITH: yWriteACF_WITH (yyt); yyIndentSelector ("WITH_BODY"); yyt = yyt->ACF_WITH.WITH_BODY; break;
  10344. case kACF_LOOP: yWriteACF_LOOP (yyt); yyIndentSelector ("LOOP_BODY"); yyt = yyt->ACF_LOOP.LOOP_BODY; break;
  10345. case kACF_DO: yWriteACF_DO (yyt); yyIndentSelector ("DO_BODY"); yyt = yyt->ACF_DO.DO_BODY; break;
  10346. case kACF_DOLOCAL: yWriteACF_DOLOCAL (yyt); yyIndentSelector ("DOLOCAL_BODY"); yyt = yyt->ACF_DOLOCAL.DOLOCAL_BODY; break;
  10347. case kACF_DOVEC: yWriteACF_DOVEC (yyt); yyIndentSelector ("DOVEC_BODY"); yyt = yyt->ACF_DOVEC.DOVEC_BODY; break;
  10348. case kACF_DOALL: yWriteACF_DOALL (yyt); yyIndentSelector ("DOALL_BODY"); yyt = yyt->ACF_DOALL.DOALL_BODY; break;
  10349. case kACF_FORALL: yWriteACF_FORALL (yyt); yyIndentSelector ("FORALL_BODY"); yyt = yyt->ACF_FORALL.FORALL_BODY; break;
  10350. case kACF_ON: yWriteACF_ON (yyt); yyIndentSelector ("ON_STMT"); yyt = yyt->ACF_ON.ON_STMT; break;
  10351. case kACF_BODY: yWriteACF_BODY (yyt); yyIndentSelector ("NEW_BODY"); yyt = yyt->ACF_BODY.NEW_BODY; break;
  10352. case kACF_FLOW_GRAPH: yWriteACF_FLOW_GRAPH (yyt); yyIndentSelector ("FLOW_NODES"); yyt = yyt->ACF_FLOW_GRAPH.FLOW_NODES; break;
  10353. case kACF_ENTRY: yWriteACF_ENTRY (yyt); yyIndentSelector ("ENTRY_DECL"); yyt = yyt->ACF_ENTRY.ENTRY_DECL; break;
  10354. case kACF_FLOW_KIND: (void) fputs (Tree_NodeName [kACF_FLOW_KIND], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10355. case kACF_COMPLEX_FLOW: (void) fputs (Tree_NodeName [kACF_COMPLEX_FLOW], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10356. case kACF_INTERVAL_FLOW: (void) fputs (Tree_NodeName [kACF_INTERVAL_FLOW], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10357. case kACF_SIMPLE_FLOW: (void) fputs (Tree_NodeName [kACF_SIMPLE_FLOW], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10358. case kSELECTED_ACF_NODE_LIST: (void) fputs (Tree_NodeName [kSELECTED_ACF_NODE_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10359. case kSELECTED_ACF_EMPTY: (void) fputs (Tree_NodeName [kSELECTED_ACF_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10360. case kSELECTED_ACF_LIST: yWriteSELECTED_ACF_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->SELECTED_ACF_LIST.Next; break;
  10361. case kSELECTED_ACF_NODE: yWriteSELECTED_ACF_NODE (yyt); yyIndentSelector ("SELECT_ACFS"); yyt = yyt->SELECTED_ACF_NODE.SELECT_ACFS; break;
  10362. case kBT_STMT: (void) fputs (Tree_NodeName [kBT_STMT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10363. case kEXP_STMT: yWriteEXP_STMT (yyt); yyIndentSelector ("STMT_EXP"); yyt = yyt->EXP_STMT.STMT_EXP; break;
  10364. case kASSIGN_STMT: yWriteASSIGN_STMT (yyt); yyIndentSelector ("ASSIGN_EXP"); yyt = yyt->ASSIGN_STMT.ASSIGN_EXP; break;
  10365. case kPTR_ASSIGN_STMT: yWritePTR_ASSIGN_STMT (yyt); yyIndentSelector ("ASSIGN_EXP"); yyt = yyt->PTR_ASSIGN_STMT.ASSIGN_EXP; break;
  10366. case kLABEL_ASSIGN_STMT: yWriteLABEL_ASSIGN_STMT (yyt); yyIndentSelector ("LABEL_VAR"); yyt = yyt->LABEL_ASSIGN_STMT.LABEL_VAR; break;
  10367. case kCALL_STMT: yWriteCALL_STMT (yyt); yyIndentSelector ("CALL_PARAMS"); yyt = yyt->CALL_STMT.CALL_PARAMS; break;
  10368. case kIO_STMT: yWriteIO_STMT (yyt); yyIndentSelector ("IO_ITEMS"); yyt = yyt->IO_STMT.IO_ITEMS; break;
  10369. case kGOTO_STMT: yWriteGOTO_STMT (yyt); goto yyExit;
  10370. case kASS_GOTO_STMT: yWriteASS_GOTO_STMT (yyt); yyIndentSelector ("LABELS"); yyt = yyt->ASS_GOTO_STMT.LABELS; break;
  10371. case kCOMP_GOTO_STMT: yWriteCOMP_GOTO_STMT (yyt); yyIndentSelector ("GOTO_EXP"); yyt = yyt->COMP_GOTO_STMT.GOTO_EXP; break;
  10372. case kCOMP_IF_STMT: yWriteCOMP_IF_STMT (yyt); yyIndentSelector ("IF_EXP"); yyt = yyt->COMP_IF_STMT.IF_EXP; break;
  10373. case kRETURN_STMT: yWriteRETURN_STMT (yyt); yyIndentSelector ("RETURN_EXP"); yyt = yyt->RETURN_STMT.RETURN_EXP; break;
  10374. case kPAUSE_STMT: yWritePAUSE_STMT (yyt); yyIndentSelector ("PAUSE_CONST"); yyt = yyt->PAUSE_STMT.PAUSE_CONST; break;
  10375. case kEXIT_STMT: yWriteEXIT_STMT (yyt); goto yyExit;
  10376. case kCYCLE_STMT: yWriteCYCLE_STMT (yyt); goto yyExit;
  10377. case kSTOP_STMT: yWriteSTOP_STMT (yyt); yyIndentSelector ("STOP_CONST"); yyt = yyt->STOP_STMT.STOP_CONST; break;
  10378. case kFORMAT_STMT: yWriteFORMAT_STMT (yyt); yyIndentSelector ("FORMAT_PARAMS"); yyt = yyt->FORMAT_STMT.FORMAT_PARAMS; break;
  10379. case kALLOCATE_STMT: yWriteALLOCATE_STMT (yyt); yyIndentSelector ("STAT"); yyt = yyt->ALLOCATE_STMT.STAT; break;
  10380. case kDEALLOCATE_STMT: yWriteDEALLOCATE_STMT (yyt); yyIndentSelector ("STAT"); yyt = yyt->DEALLOCATE_STMT.STAT; break;
  10381. case kNULLIFY_STMT: yWriteNULLIFY_STMT (yyt); yyIndentSelector ("PARAMS"); yyt = yyt->NULLIFY_STMT.PARAMS; break;
  10382. case kREDUCE_STMT: yWriteREDUCE_STMT (yyt); yyIndentSelector ("RED_PARAMS"); yyt = yyt->REDUCE_STMT.RED_PARAMS; break;
  10383. case kGLOBAL_STMT: yWriteGLOBAL_STMT (yyt); yyIndentSelector ("MASK"); yyt = yyt->GLOBAL_STMT.MASK; break;
  10384. case kALIGN_STMT: yWriteALIGN_STMT (yyt); yyIndentSelector ("ALIGN_SPEC"); yyt = yyt->ALIGN_STMT.ALIGN_SPEC; break;
  10385. case kDISTRIBUTE_STMT: yWriteDISTRIBUTE_STMT (yyt); yyIndentSelector ("DISTRIBUTION"); yyt = yyt->DISTRIBUTE_STMT.DISTRIBUTION; break;
  10386. case kLABEL_USE_LIST: (void) fputs (Tree_NodeName [kLABEL_USE_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10387. case kLABEL_EMPTY: (void) fputs (Tree_NodeName [kLABEL_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10388. case kLABEL_LIST: yWriteLABEL_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->LABEL_LIST.Next; break;
  10389. case kOP: (void) fputs (Tree_NodeName [kOP], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10390. case kOP_EQ: (void) fputs (Tree_NodeName [kOP_EQ], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10391. case kOP_NE: (void) fputs (Tree_NodeName [kOP_NE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10392. case kOP_LT: (void) fputs (Tree_NodeName [kOP_LT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10393. case kOP_GT: (void) fputs (Tree_NodeName [kOP_GT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10394. case kOP_GE: (void) fputs (Tree_NodeName [kOP_GE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10395. case kOP_LE: (void) fputs (Tree_NodeName [kOP_LE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10396. case kOP_PLUS: (void) fputs (Tree_NodeName [kOP_PLUS], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10397. case kOP_MINUS: (void) fputs (Tree_NodeName [kOP_MINUS], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10398. case kOP_XOR: (void) fputs (Tree_NodeName [kOP_XOR], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10399. case kOP_OR: (void) fputs (Tree_NodeName [kOP_OR], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10400. case kOP_CONCAT: (void) fputs (Tree_NodeName [kOP_CONCAT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10401. case kOP_TIMES: (void) fputs (Tree_NodeName [kOP_TIMES], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10402. case kOP_DIVIDE: (void) fputs (Tree_NodeName [kOP_DIVIDE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10403. case kOP_DIV: (void) fputs (Tree_NodeName [kOP_DIV], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10404. case kOP_AND: (void) fputs (Tree_NodeName [kOP_AND], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10405. case kOP_EQV: (void) fputs (Tree_NodeName [kOP_EQV], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10406. case kOP_NEQV: (void) fputs (Tree_NodeName [kOP_NEQV], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10407. case kOP_EXPO: (void) fputs (Tree_NodeName [kOP_EXPO], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10408. case kOP_MOD: (void) fputs (Tree_NodeName [kOP_MOD], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10409. case kOP_IN: (void) fputs (Tree_NodeName [kOP_IN], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10410. case kOP_DEFINED: yWriteOP_DEFINED (yyt); goto yyExit;
  10411. case kOP_ASSIGN: (void) fputs (Tree_NodeName [kOP_ASSIGN], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10412. case kOP_LEFT: (void) fputs (Tree_NodeName [kOP_LEFT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10413. case kOP_RIGHT: (void) fputs (Tree_NodeName [kOP_RIGHT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10414. case kOP_LIST: (void) fputs (Tree_NodeName [kOP_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10415. case kOP_IOR: (void) fputs (Tree_NodeName [kOP_IOR], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10416. case kOP_IXOR: (void) fputs (Tree_NodeName [kOP_IXOR], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10417. case kOP_IAND: (void) fputs (Tree_NodeName [kOP_IAND], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10418. case kOP1_NOT: (void) fputs (Tree_NodeName [kOP1_NOT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10419. case kOP1_SIGN: (void) fputs (Tree_NodeName [kOP1_SIGN], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10420. case kOP1_INOT: (void) fputs (Tree_NodeName [kOP1_INOT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10421. case kOP1_SIZE: (void) fputs (Tree_NodeName [kOP1_SIZE], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10422. case kOP1_DEC: (void) fputs (Tree_NodeName [kOP1_DEC], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10423. case kOP1_INC: (void) fputs (Tree_NodeName [kOP1_INC], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10424. case kOP1_ADDRESS: (void) fputs (Tree_NodeName [kOP1_ADDRESS], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10425. case kOP1_DEREF: (void) fputs (Tree_NodeName [kOP1_DEREF], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10426. case kBT_EXP: (void) fputs (Tree_NodeName [kBT_EXP], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10427. case kDUMMY_EXP: (void) fputs (Tree_NodeName [kDUMMY_EXP], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10428. case kCONST_EXP: yWriteCONST_EXP (yyt); yyIndentSelector ("C"); yyt = yyt->CONST_EXP.C; break;
  10429. case kOP_EXP: yWriteOP_EXP (yyt); yyIndentSelector ("OPND2"); yyt = yyt->OP_EXP.OPND2; break;
  10430. case kOP1_EXP: yWriteOP1_EXP (yyt); yyIndentSelector ("OPND"); yyt = yyt->OP1_EXP.OPND; break;
  10431. case kSLICE_EXP: yWriteSLICE_EXP (yyt); yyIndentSelector ("INC"); yyt = yyt->SLICE_EXP.INC; break;
  10432. case kPOSTFIX_EXP: yWritePOSTFIX_EXP (yyt); yyIndentSelector ("OPND"); yyt = yyt->POSTFIX_EXP.OPND; break;
  10433. case kCALL_EXP: yWriteCALL_EXP (yyt); yyIndentSelector ("FUNC_PARAMS"); yyt = yyt->CALL_EXP.FUNC_PARAMS; break;
  10434. case kCAST_EXP: yWriteCAST_EXP (yyt); yyIndentSelector ("CAST"); yyt = yyt->CAST_EXP.CAST; break;
  10435. case kINDEXED_EXP: yWriteINDEXED_EXP (yyt); yyIndentSelector ("INDEX"); yyt = yyt->INDEXED_EXP.INDEX; break;
  10436. case kSELECTED_EXP: yWriteSELECTED_EXP (yyt); yyIndentSelector ("SELECTOR"); yyt = yyt->SELECTED_EXP.SELECTOR; break;
  10437. case kASSIGN_EXP: yWriteASSIGN_EXP (yyt); yyIndentSelector ("RHS"); yyt = yyt->ASSIGN_EXP.RHS; break;
  10438. case kUSED_EXP: yWriteUSED_EXP (yyt); yyIndentSelector ("VARNAME"); yyt = yyt->USED_EXP.VARNAME; break;
  10439. case kCOND_EXP: yWriteCOND_EXP (yyt); yyIndentSelector ("FALSE_EXP"); yyt = yyt->COND_EXP.FALSE_EXP; break;
  10440. case kVAR_EXP: yWriteVAR_EXP (yyt); yyIndentSelector ("V"); yyt = yyt->VAR_EXP.V; break;
  10441. case kFUNC_CALL_EXP: yWriteFUNC_CALL_EXP (yyt); yyIndentSelector ("FUNC_PARAMS"); yyt = yyt->FUNC_CALL_EXP.FUNC_PARAMS; break;
  10442. case kNAMED_EXP: yWriteNAMED_EXP (yyt); yyIndentSelector ("VAL"); yyt = yyt->NAMED_EXP.VAL; break;
  10443. case kDO_EXP: yWriteDO_EXP (yyt); yyIndentSelector ("BODY"); yyt = yyt->DO_EXP.BODY; break;
  10444. case kTYPE_EXP: yWriteTYPE_EXP (yyt); yyIndentSelector ("ELEMENTS"); yyt = yyt->TYPE_EXP.ELEMENTS; break;
  10445. case kARRAY_EXP: yWriteARRAY_EXP (yyt); yyIndentSelector ("ELEMENTS"); yyt = yyt->ARRAY_EXP.ELEMENTS; break;
  10446. case kBT_EXP_LIST: (void) fputs (Tree_NodeName [kBT_EXP_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10447. case kBTE_EMPTY: (void) fputs (Tree_NodeName [kBTE_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10448. case kBTE_LIST: yWriteBTE_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->BTE_LIST.Next; break;
  10449. case kBT_VAR: (void) fputs (Tree_NodeName [kBT_VAR], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10450. case kDUMMY_VAR: (void) fputs (Tree_NodeName [kDUMMY_VAR], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10451. case kUSED_VAR: yWriteUSED_VAR (yyt); yyIndentSelector ("VARNAME"); yyt = yyt->USED_VAR.VARNAME; break;
  10452. case kINDEXED_VAR: yWriteINDEXED_VAR (yyt); yyIndentSelector ("IND_EXPS"); yyt = yyt->INDEXED_VAR.IND_EXPS; break;
  10453. case kSUBSTRING_VAR: yWriteSUBSTRING_VAR (yyt); yyIndentSelector ("IND_EXP"); yyt = yyt->SUBSTRING_VAR.IND_EXP; break;
  10454. case kSELECTED_VAR: yWriteSELECTED_VAR (yyt); yyIndentSelector ("SELECTOR"); yyt = yyt->SELECTED_VAR.SELECTOR; break;
  10455. case kLOOP_VAR: yWriteLOOP_VAR (yyt); yyIndentSelector ("LOOP_VARNAME"); yyt = yyt->LOOP_VAR.LOOP_VARNAME; break;
  10456. case kADDR: yWriteADDR (yyt); yyIndentSelector ("E"); yyt = yyt->ADDR.E; break;
  10457. case kDO_VAR: yWriteDO_VAR (yyt); yyIndentSelector ("BODY"); yyt = yyt->DO_VAR.BODY; break;
  10458. case kBT_VAR_LIST: (void) fputs (Tree_NodeName [kBT_VAR_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10459. case kBTV_EMPTY: (void) fputs (Tree_NodeName [kBTV_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10460. case kBTV_LIST: yWriteBTV_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->BTV_LIST.Next; break;
  10461. case kBT_PARAM: (void) fputs (Tree_NodeName [kBT_PARAM], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10462. case kVAR_PARAM: yWriteVAR_PARAM (yyt); yyIndentSelector ("V"); yyt = yyt->VAR_PARAM.V; break;
  10463. case kVALUE_PARAM: yWriteVALUE_PARAM (yyt); yyIndentSelector ("E"); yyt = yyt->VALUE_PARAM.E; break;
  10464. case kNAMED_PARAM: yWriteNAMED_PARAM (yyt); yyIndentSelector ("VAL"); yyt = yyt->NAMED_PARAM.VAL; break;
  10465. case kPROC_PARAM: yWritePROC_PARAM (yyt); yyIndentSelector ("P"); yyt = yyt->PROC_PARAM.P; break;
  10466. case kFUNC_PARAM: yWriteFUNC_PARAM (yyt); yyIndentSelector ("F"); yyt = yyt->FUNC_PARAM.F; break;
  10467. case kFORMAT_PARAM: yWriteFORMAT_PARAM (yyt); goto yyExit;
  10468. case kRETURN_PARAM: yWriteRETURN_PARAM (yyt); goto yyExit;
  10469. case kNO_PARAM: (void) fputs (Tree_NodeName [kNO_PARAM], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10470. case kBT_PARAM_LIST: (void) fputs (Tree_NodeName [kBT_PARAM_LIST], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10471. case kBTP_EMPTY: (void) fputs (Tree_NodeName [kBTP_EMPTY], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10472. case kBTP_LIST: yWriteBTP_LIST (yyt); yyIndentSelector ("Next"); yyt = yyt->BTP_LIST.Next; break;
  10473. case kCONSTANT: (void) fputs (Tree_NodeName [kCONSTANT], yyf); (void) fputc ('\n', yyf); goto yyExit;
  10474. case kBOOL_CONSTANT: yWriteBOOL_CONSTANT (yyt); goto yyExit;
  10475. case kINT_CONSTANT: yWriteINT_CONSTANT (yyt); goto yyExit;
  10476. case kREAL_CONSTANT: yWriteREAL_CONSTANT (yyt); goto yyExit;
  10477. case kDREAL_CONSTANT: yWriteDREAL_CONSTANT (yyt); goto yyExit;
  10478. case kCHAR_CONSTANT: yWriteCHAR_CONSTANT (yyt); goto yyExit;
  10479. case kSTRING_CONSTANT: yWriteSTRING_CONSTANT (yyt); goto yyExit;
  10480. case kCOMPLEX_CONSTANT: yWriteCOMPLEX_CONSTANT (yyt); goto yyExit;
  10481. case kPROC_OBJ: yWritePROC_OBJ (yyt); goto yyExit;
  10482. case kVAR_OBJ: yWriteVAR_OBJ (yyt); goto yyExit;
  10483. case kTYPE_OBJ: yWriteTYPE_OBJ (yyt); goto yyExit;
  10484. case kREC_COMP: yWriteREC_COMP (yyt); goto yyExit;
  10485.   default: goto yyExit;
  10486.   }
  10487.  }
  10488. yyExit:
  10489.  yyIndentLevel = yyLevel;
  10490. }
  10491.  
  10492. # define yyNil    0374
  10493. # define yyNoLabel    0375
  10494. # define yyLabelDef    0376
  10495. # define yyLabelUse    0377
  10496.  
  10497. tTree ReverseTree
  10498. # if defined __STDC__ | defined __cplusplus
  10499.  (tTree yyOld)
  10500. # else
  10501.  (yyOld) tTree yyOld;
  10502. # endif
  10503. {
  10504.  register tTree yyNew, yyNext, yyTail;
  10505.  yyNew = yyOld;
  10506.  yyTail = yyOld;
  10507.  for (;;) {
  10508.   switch (yyOld->Kind) {
  10509.   default: goto yyExit;
  10510.   }
  10511.   yyNew = yyOld;
  10512.   yyOld = yyNext;
  10513.  }
  10514. yyExit:
  10515.  switch (yyTail->Kind) {
  10516.  default: ;
  10517.  }
  10518.  return yyNew;
  10519. }
  10520.  
  10521. # define yyInitOldToNewStoreSize 32
  10522.  
  10523. typedef struct { tTree yyOld, yyNew; } yytOldToNew;
  10524. static unsigned long yyOldToNewStoreSize = yyInitOldToNewStoreSize;
  10525. static yytOldToNew yyOldToNewStore [yyInitOldToNewStoreSize];
  10526. static yytOldToNew * yyOldToNewStorePtr = yyOldToNewStore;
  10527. static int yyOldToNewCount;
  10528.  
  10529. static void yyStoreOldToNew
  10530. # if defined __STDC__ | defined __cplusplus
  10531.  (tTree yyOld, tTree yyNew)
  10532. # else
  10533.  (yyOld, yyNew) tTree yyOld, yyNew;
  10534. # endif
  10535. {
  10536.  if (++ yyOldToNewCount == yyOldToNewStoreSize)
  10537.   ExtendArray ((char * *) & yyOldToNewStorePtr, & yyOldToNewStoreSize, sizeof (yytOldToNew));
  10538.  yyOldToNewStorePtr [yyOldToNewCount].yyOld = yyOld;
  10539.  yyOldToNewStorePtr [yyOldToNewCount].yyNew = yyNew;
  10540. }
  10541.  
  10542. static tTree yyMapOldToNew
  10543. # if defined __STDC__ | defined __cplusplus
  10544.  (tTree yyOld)
  10545. # else
  10546.  (yyOld) tTree yyOld;
  10547. # endif
  10548. {
  10549.  register int yyi;
  10550.  for (yyi = 1; yyi <= yyOldToNewCount; yyi ++)
  10551.   if (yyOldToNewStorePtr [yyi].yyOld == yyOld) return yyOldToNewStorePtr [yyi].yyNew;
  10552. }
  10553.  
  10554. static tTree yyCopyTree
  10555. # if defined __STDC__ | defined __cplusplus
  10556.  (tTree yyt, yyPtrtTree yyNew)
  10557. # else
  10558.  (yyt, yyNew) tTree yyt; yyPtrtTree yyNew;
  10559. # endif
  10560. {
  10561.  for (;;) {
  10562.   if (yyt == NoTree) { * yyNew = NoTree; return; }
  10563.   if (yyt->yyHead.yyMark == 0) { * yyNew = yyMapOldToNew (yyt); return; }
  10564.   yyALLOC (* yyNew, Tree_NodeSize [yyt->Kind])
  10565.   if (yyt->yyHead.yyMark > 1) { yyStoreOldToNew (yyt, * yyNew); }
  10566.   yyt->yyHead.yyMark = 0;
  10567.  
  10568.   switch (yyt->Kind) {
  10569. case kCOMP_UNIT: (* yyNew)->COMP_UNIT = yyt->COMP_UNIT;
  10570. yyt = yyt->COMP_UNIT.COMP_ELEMENTS;
  10571. yyNew = & (* yyNew)->COMP_UNIT.COMP_ELEMENTS; break;
  10572. case kBODY_NODE: (* yyNew)->BODY_NODE = yyt->BODY_NODE;
  10573. copytTree ((* yyNew)->BODY_NODE.DECLS, yyt->BODY_NODE.DECLS)
  10574. copytTree ((* yyNew)->BODY_NODE.STATS, yyt->BODY_NODE.STATS)
  10575. yyt = yyt->BODY_NODE.INTERNALS;
  10576. yyNew = & (* yyNew)->BODY_NODE.INTERNALS; break;
  10577. case kTYPE_NODE: (* yyNew)->TYPE_NODE = yyt->TYPE_NODE;
  10578. return;
  10579. case kDUMMY_TYPE: (* yyNew)->DUMMY_TYPE = yyt->DUMMY_TYPE;
  10580. return;
  10581. case kVOID_TYPE: (* yyNew)->VOID_TYPE = yyt->VOID_TYPE;
  10582. return;
  10583. case kINTEGER_TYPE: (* yyNew)->INTEGER_TYPE = yyt->INTEGER_TYPE;
  10584. copyint ((* yyNew)->INTEGER_TYPE.size, yyt->INTEGER_TYPE.size)
  10585. return;
  10586. case kCARDINAL_TYPE: (* yyNew)->CARDINAL_TYPE = yyt->CARDINAL_TYPE;
  10587. copyint ((* yyNew)->CARDINAL_TYPE.size, yyt->CARDINAL_TYPE.size)
  10588. return;
  10589. case kREAL_TYPE: (* yyNew)->REAL_TYPE = yyt->REAL_TYPE;
  10590. copyint ((* yyNew)->REAL_TYPE.size, yyt->REAL_TYPE.size)
  10591. return;
  10592. case kBOOLEAN_TYPE: (* yyNew)->BOOLEAN_TYPE = yyt->BOOLEAN_TYPE;
  10593. copyint ((* yyNew)->BOOLEAN_TYPE.size, yyt->BOOLEAN_TYPE.size)
  10594. return;
  10595. case kCOMPLEX_TYPE: (* yyNew)->COMPLEX_TYPE = yyt->COMPLEX_TYPE;
  10596. copyint ((* yyNew)->COMPLEX_TYPE.size, yyt->COMPLEX_TYPE.size)
  10597. return;
  10598. case kCHAR_TYPE: (* yyNew)->CHAR_TYPE = yyt->CHAR_TYPE;
  10599. return;
  10600. case kSTRING_TYPE: (* yyNew)->STRING_TYPE = yyt->STRING_TYPE;
  10601. yyt = yyt->STRING_TYPE.LENGTH;
  10602. yyNew = & (* yyNew)->STRING_TYPE.LENGTH; break;
  10603. case kINDEX_TYPE: (* yyNew)->INDEX_TYPE = yyt->INDEX_TYPE;
  10604. copytTree ((* yyNew)->INDEX_TYPE.LOWER, yyt->INDEX_TYPE.LOWER)
  10605. copyint ((* yyNew)->INDEX_TYPE.left_overlap, yyt->INDEX_TYPE.left_overlap)
  10606. copyint ((* yyNew)->INDEX_TYPE.right_overlap, yyt->INDEX_TYPE.right_overlap)
  10607. yyt = yyt->INDEX_TYPE.UPPER;
  10608. yyNew = & (* yyNew)->INDEX_TYPE.UPPER; break;
  10609. case kTYPE_ID: (* yyNew)->TYPE_ID = yyt->TYPE_ID;
  10610. yyt = yyt->TYPE_ID.ID;
  10611. yyNew = & (* yyNew)->TYPE_ID.ID; break;
  10612. case kARRAY_TYPE: (* yyNew)->ARRAY_TYPE = yyt->ARRAY_TYPE;
  10613. copytTree ((* yyNew)->ARRAY_TYPE.ARRAY_INDEX_TYPES, yyt->ARRAY_TYPE.ARRAY_INDEX_TYPES)
  10614. yyt = yyt->ARRAY_TYPE.ARRAY_COMP_TYPE;
  10615. yyNew = & (* yyNew)->ARRAY_TYPE.ARRAY_COMP_TYPE; break;
  10616. case kRECORD_TYPE: (* yyNew)->RECORD_TYPE = yyt->RECORD_TYPE;
  10617. copytIdent ((* yyNew)->RECORD_TYPE.Name, yyt->RECORD_TYPE.Name)
  10618. yyt = yyt->RECORD_TYPE.COMPONENTS;
  10619. yyNew = & (* yyNew)->RECORD_TYPE.COMPONENTS; break;
  10620. case kUNION_TYPE: (* yyNew)->UNION_TYPE = yyt->UNION_TYPE;
  10621. copytIdent ((* yyNew)->UNION_TYPE.Name, yyt->UNION_TYPE.Name)
  10622. yyt = yyt->UNION_TYPE.COMPONENTS;
  10623. yyNew = & (* yyNew)->UNION_TYPE.COMPONENTS; break;
  10624. case kENUM_TYPE: (* yyNew)->ENUM_TYPE = yyt->ENUM_TYPE;
  10625. copytIdent ((* yyNew)->ENUM_TYPE.Name, yyt->ENUM_TYPE.Name)
  10626. yyt = yyt->ENUM_TYPE.COMPONENTS;
  10627. yyNew = & (* yyNew)->ENUM_TYPE.COMPONENTS; break;
  10628. case kDYNAMIC: (* yyNew)->DYNAMIC = yyt->DYNAMIC;
  10629. copytTree ((* yyNew)->DYNAMIC.Shape, yyt->DYNAMIC.Shape)
  10630. copyint ((* yyNew)->DYNAMIC.left_overlap, yyt->DYNAMIC.left_overlap)
  10631. copyint ((* yyNew)->DYNAMIC.right_overlap, yyt->DYNAMIC.right_overlap)
  10632. return;
  10633. case kPOINTER_TYPE: (* yyNew)->POINTER_TYPE = yyt->POINTER_TYPE;
  10634. yyt = yyt->POINTER_TYPE.PTR_COMP;
  10635. yyNew = & (* yyNew)->POINTER_TYPE.PTR_COMP; break;
  10636. case kARRAY1_TYPE: (* yyNew)->ARRAY1_TYPE = yyt->ARRAY1_TYPE;
  10637. copytTree ((* yyNew)->ARRAY1_TYPE.SIZE, yyt->ARRAY1_TYPE.SIZE)
  10638. yyt = yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE;
  10639. yyNew = & (* yyNew)->ARRAY1_TYPE.ARRAY1_COMP_TYPE; break;
  10640. case kFUNCTION_TYPE: (* yyNew)->FUNCTION_TYPE = yyt->FUNCTION_TYPE;
  10641. copytTree ((* yyNew)->FUNCTION_TYPE.FORMALS, yyt->FUNCTION_TYPE.FORMALS)
  10642. yyt = yyt->FUNCTION_TYPE.RESULT_TYPE;
  10643. yyNew = & (* yyNew)->FUNCTION_TYPE.RESULT_TYPE; break;
  10644. case kTYPE_NODE_LIST: (* yyNew)->TYPE_NODE_LIST = yyt->TYPE_NODE_LIST;
  10645. return;
  10646. case kTYPE_EMPTY: (* yyNew)->TYPE_EMPTY = yyt->TYPE_EMPTY;
  10647. return;
  10648. case kTYPE_LIST: (* yyNew)->TYPE_LIST = yyt->TYPE_LIST;
  10649. copytTree ((* yyNew)->TYPE_LIST.Elem, yyt->TYPE_LIST.Elem)
  10650. yyt = yyt->TYPE_LIST.Next;
  10651. yyNew = & (* yyNew)->TYPE_LIST.Next; break;
  10652. case kDECL_NODE: (* yyNew)->DECL_NODE = yyt->DECL_NODE;
  10653. copytIdent ((* yyNew)->DECL_NODE.Name, yyt->DECL_NODE.Name)
  10654. copyint ((* yyNew)->DECL_NODE.Pos, yyt->DECL_NODE.Pos)
  10655. return;
  10656. case kMODULE_DECL: (* yyNew)->MODULE_DECL = yyt->MODULE_DECL;
  10657. copytIdent ((* yyNew)->MODULE_DECL.Name, yyt->MODULE_DECL.Name)
  10658. copyint ((* yyNew)->MODULE_DECL.Pos, yyt->MODULE_DECL.Pos)
  10659. yyt = yyt->MODULE_DECL.MODULE_BODY;
  10660. yyNew = & (* yyNew)->MODULE_DECL.MODULE_BODY; break;
  10661. case kPROGRAM_DECL: (* yyNew)->PROGRAM_DECL = yyt->PROGRAM_DECL;
  10662. copytIdent ((* yyNew)->PROGRAM_DECL.Name, yyt->PROGRAM_DECL.Name)
  10663. copyint ((* yyNew)->PROGRAM_DECL.Pos, yyt->PROGRAM_DECL.Pos)
  10664. copytTree ((* yyNew)->PROGRAM_DECL.FORMALS, yyt->PROGRAM_DECL.FORMALS)
  10665. yyt = yyt->PROGRAM_DECL.PROGRAM_BODY;
  10666. yyNew = & (* yyNew)->PROGRAM_DECL.PROGRAM_BODY; break;
  10667. case kPROC_DECL: (* yyNew)->PROC_DECL = yyt->PROC_DECL;
  10668. copytIdent ((* yyNew)->PROC_DECL.Name, yyt->PROC_DECL.Name)
  10669. copyint ((* yyNew)->PROC_DECL.Pos, yyt->PROC_DECL.Pos)
  10670. copytTree ((* yyNew)->PROC_DECL.FORMALS, yyt->PROC_DECL.FORMALS)
  10671. copybool ((* yyNew)->PROC_DECL.IsRecursive, yyt->PROC_DECL.IsRecursive)
  10672. copybool ((* yyNew)->PROC_DECL.IsPure, yyt->PROC_DECL.IsPure)
  10673. copyint ((* yyNew)->PROC_DECL.HPFExtrinsic, yyt->PROC_DECL.HPFExtrinsic)
  10674. yyt = yyt->PROC_DECL.PROC_BODY;
  10675. yyNew = & (* yyNew)->PROC_DECL.PROC_BODY; break;
  10676. case kFUNC_DECL: (* yyNew)->FUNC_DECL = yyt->FUNC_DECL;
  10677. copytIdent ((* yyNew)->FUNC_DECL.Name, yyt->FUNC_DECL.Name)
  10678. copyint ((* yyNew)->FUNC_DECL.Pos, yyt->FUNC_DECL.Pos)
  10679. copytTree ((* yyNew)->FUNC_DECL.FORMALS, yyt->FUNC_DECL.FORMALS)
  10680. copytTree ((* yyNew)->FUNC_DECL.FUNC_BODY, yyt->FUNC_DECL.FUNC_BODY)
  10681. copytIdent ((* yyNew)->FUNC_DECL.RESULT_ID, yyt->FUNC_DECL.RESULT_ID)
  10682. copybool ((* yyNew)->FUNC_DECL.IsRecursive, yyt->FUNC_DECL.IsRecursive)
  10683. copybool ((* yyNew)->FUNC_DECL.IsPure, yyt->FUNC_DECL.IsPure)
  10684. copyint ((* yyNew)->FUNC_DECL.HPFExtrinsic, yyt->FUNC_DECL.HPFExtrinsic)
  10685. yyt = yyt->FUNC_DECL.RESULT_TYPE;
  10686. yyNew = & (* yyNew)->FUNC_DECL.RESULT_TYPE; break;
  10687. case kBLOCK_DATA_DECL: (* yyNew)->BLOCK_DATA_DECL = yyt->BLOCK_DATA_DECL;
  10688. copytIdent ((* yyNew)->BLOCK_DATA_DECL.Name, yyt->BLOCK_DATA_DECL.Name)
  10689. copyint ((* yyNew)->BLOCK_DATA_DECL.Pos, yyt->BLOCK_DATA_DECL.Pos)
  10690. yyt = yyt->BLOCK_DATA_DECL.DATA_BODY;
  10691. yyNew = & (* yyNew)->BLOCK_DATA_DECL.DATA_BODY; break;
  10692. case kTYPE_DECL: (* yyNew)->TYPE_DECL = yyt->TYPE_DECL;
  10693. copytIdent ((* yyNew)->TYPE_DECL.Name, yyt->TYPE_DECL.Name)
  10694. copyint ((* yyNew)->TYPE_DECL.Pos, yyt->TYPE_DECL.Pos)
  10695. yyt = yyt->TYPE_DECL.VAL;
  10696. yyNew = & (* yyNew)->TYPE_DECL.VAL; break;
  10697. case kNAME_DECL: (* yyNew)->NAME_DECL = yyt->NAME_DECL;
  10698. copytIdent ((* yyNew)->NAME_DECL.Name, yyt->NAME_DECL.Name)
  10699. copyint ((* yyNew)->NAME_DECL.Pos, yyt->NAME_DECL.Pos)
  10700. return;
  10701. case kRENAME_DECL: (* yyNew)->RENAME_DECL = yyt->RENAME_DECL;
  10702. copytIdent ((* yyNew)->RENAME_DECL.Name, yyt->RENAME_DECL.Name)
  10703. copyint ((* yyNew)->RENAME_DECL.Pos, yyt->RENAME_DECL.Pos)
  10704. copytIdent ((* yyNew)->RENAME_DECL.oldname, yyt->RENAME_DECL.oldname)
  10705. return;
  10706. case kENTITY_DECL: (* yyNew)->ENTITY_DECL = yyt->ENTITY_DECL;
  10707. copytIdent ((* yyNew)->ENTITY_DECL.Name, yyt->ENTITY_DECL.Name)
  10708. copyint ((* yyNew)->ENTITY_DECL.Pos, yyt->ENTITY_DECL.Pos)
  10709. yyt = yyt->ENTITY_DECL.ATTRIBUTES;
  10710. yyNew = & (* yyNew)->ENTITY_DECL.ATTRIBUTES; break;
  10711. case kVAR_DECL: (* yyNew)->VAR_DECL = yyt->VAR_DECL;
  10712. copytIdent ((* yyNew)->VAR_DECL.Name, yyt->VAR_DECL.Name)
  10713. copyint ((* yyNew)->VAR_DECL.Pos, yyt->VAR_DECL.Pos)
  10714. yyt = yyt->VAR_DECL.VAL;
  10715. yyNew = & (* yyNew)->VAR_DECL.VAL; break;
  10716. case kCOMMON_DECL: (* yyNew)->COMMON_DECL = yyt->COMMON_DECL;
  10717. copytIdent ((* yyNew)->COMMON_DECL.Name, yyt->COMMON_DECL.Name)
  10718. copyint ((* yyNew)->COMMON_DECL.Pos, yyt->COMMON_DECL.Pos)
  10719. yyt = yyt->COMMON_DECL.IDS;
  10720. yyNew = & (* yyNew)->COMMON_DECL.IDS; break;
  10721. case kNAMELIST_DECL: (* yyNew)->NAMELIST_DECL = yyt->NAMELIST_DECL;
  10722. copytIdent ((* yyNew)->NAMELIST_DECL.Name, yyt->NAMELIST_DECL.Name)
  10723. copyint ((* yyNew)->NAMELIST_DECL.Pos, yyt->NAMELIST_DECL.Pos)
  10724. yyt = yyt->NAMELIST_DECL.IDS;
  10725. yyNew = & (* yyNew)->NAMELIST_DECL.IDS; break;
  10726. case kTEMPLATE_DECL: (* yyNew)->TEMPLATE_DECL = yyt->TEMPLATE_DECL;
  10727. copytIdent ((* yyNew)->TEMPLATE_DECL.Name, yyt->TEMPLATE_DECL.Name)
  10728. copyint ((* yyNew)->TEMPLATE_DECL.Pos, yyt->TEMPLATE_DECL.Pos)
  10729. yyt = yyt->TEMPLATE_DECL.DIMENSIONS;
  10730. yyNew = & (* yyNew)->TEMPLATE_DECL.DIMENSIONS; break;
  10731. case kPROCESSORS_DECL: (* yyNew)->PROCESSORS_DECL = yyt->PROCESSORS_DECL;
  10732. copytIdent ((* yyNew)->PROCESSORS_DECL.Name, yyt->PROCESSORS_DECL.Name)
  10733. copyint ((* yyNew)->PROCESSORS_DECL.Pos, yyt->PROCESSORS_DECL.Pos)
  10734. yyt = yyt->PROCESSORS_DECL.DIMENSIONS;
  10735. yyNew = & (* yyNew)->PROCESSORS_DECL.DIMENSIONS; break;
  10736. case kINHERIT_DECL: (* yyNew)->INHERIT_DECL = yyt->INHERIT_DECL;
  10737. copytIdent ((* yyNew)->INHERIT_DECL.Name, yyt->INHERIT_DECL.Name)
  10738. copyint ((* yyNew)->INHERIT_DECL.Pos, yyt->INHERIT_DECL.Pos)
  10739. return;
  10740. case kSTMT_FUNC_DECL: (* yyNew)->STMT_FUNC_DECL = yyt->STMT_FUNC_DECL;
  10741. copytIdent ((* yyNew)->STMT_FUNC_DECL.Name, yyt->STMT_FUNC_DECL.Name)
  10742. copyint ((* yyNew)->STMT_FUNC_DECL.Pos, yyt->STMT_FUNC_DECL.Pos)
  10743. copytTree ((* yyNew)->STMT_FUNC_DECL.FORMALS, yyt->STMT_FUNC_DECL.FORMALS)
  10744. copytTree ((* yyNew)->STMT_FUNC_DECL.RESULT_TYPE, yyt->STMT_FUNC_DECL.RESULT_TYPE)
  10745. yyt = yyt->STMT_FUNC_DECL.FFUNC_BODY;
  10746. yyNew = & (* yyNew)->STMT_FUNC_DECL.FFUNC_BODY; break;
  10747. case kINTERFACE_DECL: (* yyNew)->INTERFACE_DECL = yyt->INTERFACE_DECL;
  10748. copytIdent ((* yyNew)->INTERFACE_DECL.Name, yyt->INTERFACE_DECL.Name)
  10749. copyint ((* yyNew)->INTERFACE_DECL.Pos, yyt->INTERFACE_DECL.Pos)
  10750. copytTree ((* yyNew)->INTERFACE_DECL.SPEC, yyt->INTERFACE_DECL.SPEC)
  10751. yyt = yyt->INTERFACE_DECL.ITEMS;
  10752. yyNew = & (* yyNew)->INTERFACE_DECL.ITEMS; break;
  10753. case kEXT_PROC_DECL: (* yyNew)->EXT_PROC_DECL = yyt->EXT_PROC_DECL;
  10754. copytIdent ((* yyNew)->EXT_PROC_DECL.Name, yyt->EXT_PROC_DECL.Name)
  10755. copyint ((* yyNew)->EXT_PROC_DECL.Pos, yyt->EXT_PROC_DECL.Pos)
  10756. yyt = yyt->EXT_PROC_DECL.FORMALS;
  10757. yyNew = & (* yyNew)->EXT_PROC_DECL.FORMALS; break;
  10758. case kEXT_FUNC_DECL: (* yyNew)->EXT_FUNC_DECL = yyt->EXT_FUNC_DECL;
  10759. copytIdent ((* yyNew)->EXT_FUNC_DECL.Name, yyt->EXT_FUNC_DECL.Name)
  10760. copyint ((* yyNew)->EXT_FUNC_DECL.Pos, yyt->EXT_FUNC_DECL.Pos)
  10761. copytTree ((* yyNew)->EXT_FUNC_DECL.FORMALS, yyt->EXT_FUNC_DECL.FORMALS)
  10762. yyt = yyt->EXT_FUNC_DECL.RESULT_TYPE;
  10763. yyNew = & (* yyNew)->EXT_FUNC_DECL.RESULT_TYPE; break;
  10764. case kVAL_PARAM_DECL: (* yyNew)->VAL_PARAM_DECL = yyt->VAL_PARAM_DECL;
  10765. copytIdent ((* yyNew)->VAL_PARAM_DECL.Name, yyt->VAL_PARAM_DECL.Name)
  10766. copyint ((* yyNew)->VAL_PARAM_DECL.Pos, yyt->VAL_PARAM_DECL.Pos)
  10767. yyt = yyt->VAL_PARAM_DECL.VAL;
  10768. yyNew = & (* yyNew)->VAL_PARAM_DECL.VAL; break;
  10769. case kVAR_PARAM_DECL: (* yyNew)->VAR_PARAM_DECL = yyt->VAR_PARAM_DECL;
  10770. copytIdent ((* yyNew)->VAR_PARAM_DECL.Name, yyt->VAR_PARAM_DECL.Name)
  10771. copyint ((* yyNew)->VAR_PARAM_DECL.Pos, yyt->VAR_PARAM_DECL.Pos)
  10772. yyt = yyt->VAR_PARAM_DECL.VAL;
  10773. yyNew = & (* yyNew)->VAR_PARAM_DECL.VAL; break;
  10774. case kPROC_PARAM_DECL: (* yyNew)->PROC_PARAM_DECL = yyt->PROC_PARAM_DECL;
  10775. copytIdent ((* yyNew)->PROC_PARAM_DECL.Name, yyt->PROC_PARAM_DECL.Name)
  10776. copyint ((* yyNew)->PROC_PARAM_DECL.Pos, yyt->PROC_PARAM_DECL.Pos)
  10777. yyt = yyt->PROC_PARAM_DECL.FORMAL;
  10778. yyNew = & (* yyNew)->PROC_PARAM_DECL.FORMAL; break;
  10779. case kFUNC_PARAM_DECL: (* yyNew)->FUNC_PARAM_DECL = yyt->FUNC_PARAM_DECL;
  10780. copytIdent ((* yyNew)->FUNC_PARAM_DECL.Name, yyt->FUNC_PARAM_DECL.Name)
  10781. copyint ((* yyNew)->FUNC_PARAM_DECL.Pos, yyt->FUNC_PARAM_DECL.Pos)
  10782. copytTree ((* yyNew)->FUNC_PARAM_DECL.FORMAL, yyt->FUNC_PARAM_DECL.FORMAL)
  10783. yyt = yyt->FUNC_PARAM_DECL.RESULT_TYPE;
  10784. yyNew = & (* yyNew)->FUNC_PARAM_DECL.RESULT_TYPE; break;
  10785. case kELIPSIS_PARAM_DECL: (* yyNew)->ELIPSIS_PARAM_DECL = yyt->ELIPSIS_PARAM_DECL;
  10786. copytIdent ((* yyNew)->ELIPSIS_PARAM_DECL.Name, yyt->ELIPSIS_PARAM_DECL.Name)
  10787. copyint ((* yyNew)->ELIPSIS_PARAM_DECL.Pos, yyt->ELIPSIS_PARAM_DECL.Pos)
  10788. return;
  10789. case kRET_PARAM_DECL: (* yyNew)->RET_PARAM_DECL = yyt->RET_PARAM_DECL;
  10790. copytIdent ((* yyNew)->RET_PARAM_DECL.Name, yyt->RET_PARAM_DECL.Name)
  10791. copyint ((* yyNew)->RET_PARAM_DECL.Pos, yyt->RET_PARAM_DECL.Pos)
  10792. return;
  10793. case kIMPLICIT_DECL: (* yyNew)->IMPLICIT_DECL = yyt->IMPLICIT_DECL;
  10794. copytIdent ((* yyNew)->IMPLICIT_DECL.Name, yyt->IMPLICIT_DECL.Name)
  10795. copyint ((* yyNew)->IMPLICIT_DECL.Pos, yyt->IMPLICIT_DECL.Pos)
  10796. copytIdent ((* yyNew)->IMPLICIT_DECL.first, yyt->IMPLICIT_DECL.first)
  10797. copytIdent ((* yyNew)->IMPLICIT_DECL.last, yyt->IMPLICIT_DECL.last)
  10798. yyt = yyt->IMPLICIT_DECL.VAL;
  10799. yyNew = & (* yyNew)->IMPLICIT_DECL.VAL; break;
  10800. case kUSE_DECL: (* yyNew)->USE_DECL = yyt->USE_DECL;
  10801. copytIdent ((* yyNew)->USE_DECL.Name, yyt->USE_DECL.Name)
  10802. copyint ((* yyNew)->USE_DECL.Pos, yyt->USE_DECL.Pos)
  10803. copytIdent ((* yyNew)->USE_DECL.use, yyt->USE_DECL.use)
  10804. yyt = yyt->USE_DECL.RENAMINGS;
  10805. yyNew = & (* yyNew)->USE_DECL.RENAMINGS; break;
  10806. case kONLY_USE_DECL: (* yyNew)->ONLY_USE_DECL = yyt->ONLY_USE_DECL;
  10807. copytIdent ((* yyNew)->ONLY_USE_DECL.Name, yyt->ONLY_USE_DECL.Name)
  10808. copyint ((* yyNew)->ONLY_USE_DECL.Pos, yyt->ONLY_USE_DECL.Pos)
  10809. copytIdent ((* yyNew)->ONLY_USE_DECL.use, yyt->ONLY_USE_DECL.use)
  10810. yyt = yyt->ONLY_USE_DECL.NAMES;
  10811. yyNew = & (* yyNew)->ONLY_USE_DECL.NAMES; break;
  10812. case kEQV_DECL: (* yyNew)->EQV_DECL = yyt->EQV_DECL;
  10813. copytIdent ((* yyNew)->EQV_DECL.Name, yyt->EQV_DECL.Name)
  10814. copyint ((* yyNew)->EQV_DECL.Pos, yyt->EQV_DECL.Pos)
  10815. yyt = yyt->EQV_DECL.VARS;
  10816. yyNew = & (* yyNew)->EQV_DECL.VARS; break;
  10817. case kDATA_DECL: (* yyNew)->DATA_DECL = yyt->DATA_DECL;
  10818. copytIdent ((* yyNew)->DATA_DECL.Name, yyt->DATA_DECL.Name)
  10819. copyint ((* yyNew)->DATA_DECL.Pos, yyt->DATA_DECL.Pos)
  10820. copytTree ((* yyNew)->DATA_DECL.VARS, yyt->DATA_DECL.VARS)
  10821. yyt = yyt->DATA_DECL.VALS;
  10822. yyNew = & (* yyNew)->DATA_DECL.VALS; break;
  10823. case kDIMENSION_DECL: (* yyNew)->DIMENSION_DECL = yyt->DIMENSION_DECL;
  10824. copytIdent ((* yyNew)->DIMENSION_DECL.Name, yyt->DIMENSION_DECL.Name)
  10825. copyint ((* yyNew)->DIMENSION_DECL.Pos, yyt->DIMENSION_DECL.Pos)
  10826. yyt = yyt->DIMENSION_DECL.INDEXES;
  10827. yyNew = & (* yyNew)->DIMENSION_DECL.INDEXES; break;
  10828. case kINIT_DATA_DECL: (* yyNew)->INIT_DATA_DECL = yyt->INIT_DATA_DECL;
  10829. copytIdent ((* yyNew)->INIT_DATA_DECL.Name, yyt->INIT_DATA_DECL.Name)
  10830. copyint ((* yyNew)->INIT_DATA_DECL.Pos, yyt->INIT_DATA_DECL.Pos)
  10831. yyt = yyt->INIT_DATA_DECL.VAL;
  10832. yyNew = & (* yyNew)->INIT_DATA_DECL.VAL; break;
  10833. case kTYPESPEC_DECL: (* yyNew)->TYPESPEC_DECL = yyt->TYPESPEC_DECL;
  10834. copytIdent ((* yyNew)->TYPESPEC_DECL.Name, yyt->TYPESPEC_DECL.Name)
  10835. copyint ((* yyNew)->TYPESPEC_DECL.Pos, yyt->TYPESPEC_DECL.Pos)
  10836. yyt = yyt->TYPESPEC_DECL.VAL;
  10837. yyNew = & (* yyNew)->TYPESPEC_DECL.VAL; break;
  10838. case kALLOCATABLE_DECL: (* yyNew)->ALLOCATABLE_DECL = yyt->ALLOCATABLE_DECL;
  10839. copytIdent ((* yyNew)->ALLOCATABLE_DECL.Name, yyt->ALLOCATABLE_DECL.Name)
  10840. copyint ((* yyNew)->ALLOCATABLE_DECL.Pos, yyt->ALLOCATABLE_DECL.Pos)
  10841. return;
  10842. case kEXTERNAL_DECL: (* yyNew)->EXTERNAL_DECL = yyt->EXTERNAL_DECL;
  10843. copytIdent ((* yyNew)->EXTERNAL_DECL.Name, yyt->EXTERNAL_DECL.Name)
  10844. copyint ((* yyNew)->EXTERNAL_DECL.Pos, yyt->EXTERNAL_DECL.Pos)
  10845. return;
  10846. case kINTENT_DECL: (* yyNew)->INTENT_DECL = yyt->INTENT_DECL;
  10847. copytIdent ((* yyNew)->INTENT_DECL.Name, yyt->INTENT_DECL.Name)
  10848. copyint ((* yyNew)->INTENT_DECL.Pos, yyt->INTENT_DECL.Pos)
  10849. copyint ((* yyNew)->INTENT_DECL.intent, yyt->INTENT_DECL.intent)
  10850. return;
  10851. case kINTRINSIC_DECL: (* yyNew)->INTRINSIC_DECL = yyt->INTRINSIC_DECL;
  10852. copytIdent ((* yyNew)->INTRINSIC_DECL.Name, yyt->INTRINSIC_DECL.Name)
  10853. copyint ((* yyNew)->INTRINSIC_DECL.Pos, yyt->INTRINSIC_DECL.Pos)
  10854. return;
  10855. case kOPTIONAL_DECL: (* yyNew)->OPTIONAL_DECL = yyt->OPTIONAL_DECL;
  10856. copytIdent ((* yyNew)->OPTIONAL_DECL.Name, yyt->OPTIONAL_DECL.Name)
  10857. copyint ((* yyNew)->OPTIONAL_DECL.Pos, yyt->OPTIONAL_DECL.Pos)
  10858. return;
  10859. case kPOINTER_DECL: (* yyNew)->POINTER_DECL = yyt->POINTER_DECL;
  10860. copytIdent ((* yyNew)->POINTER_DECL.Name, yyt->POINTER_DECL.Name)
  10861. copyint ((* yyNew)->POINTER_DECL.Pos, yyt->POINTER_DECL.Pos)
  10862. return;
  10863. case kSAVE_DECL: (* yyNew)->SAVE_DECL = yyt->SAVE_DECL;
  10864. copytIdent ((* yyNew)->SAVE_DECL.Name, yyt->SAVE_DECL.Name)
  10865. copyint ((* yyNew)->SAVE_DECL.Pos, yyt->SAVE_DECL.Pos)
  10866. return;
  10867. case kTARGET_DECL: (* yyNew)->TARGET_DECL = yyt->TARGET_DECL;
  10868. copytIdent ((* yyNew)->TARGET_DECL.Name, yyt->TARGET_DECL.Name)
  10869. copyint ((* yyNew)->TARGET_DECL.Pos, yyt->TARGET_DECL.Pos)
  10870. return;
  10871. case kPARAMETER_DECL: (* yyNew)->PARAMETER_DECL = yyt->PARAMETER_DECL;
  10872. copytIdent ((* yyNew)->PARAMETER_DECL.Name, yyt->PARAMETER_DECL.Name)
  10873. copyint ((* yyNew)->PARAMETER_DECL.Pos, yyt->PARAMETER_DECL.Pos)
  10874. yyt = yyt->PARAMETER_DECL.VAL;
  10875. yyNew = & (* yyNew)->PARAMETER_DECL.VAL; break;
  10876. case kPUBLIC_DECL: (* yyNew)->PUBLIC_DECL = yyt->PUBLIC_DECL;
  10877. copytIdent ((* yyNew)->PUBLIC_DECL.Name, yyt->PUBLIC_DECL.Name)
  10878. copyint ((* yyNew)->PUBLIC_DECL.Pos, yyt->PUBLIC_DECL.Pos)
  10879. return;
  10880. case kPRIVATE_DECL: (* yyNew)->PRIVATE_DECL = yyt->PRIVATE_DECL;
  10881. copytIdent ((* yyNew)->PRIVATE_DECL.Name, yyt->PRIVATE_DECL.Name)
  10882. copyint ((* yyNew)->PRIVATE_DECL.Pos, yyt->PRIVATE_DECL.Pos)
  10883. return;
  10884. case kDISTRIBUTE_DECL: (* yyNew)->DISTRIBUTE_DECL = yyt->DISTRIBUTE_DECL;
  10885. copytIdent ((* yyNew)->DISTRIBUTE_DECL.Name, yyt->DISTRIBUTE_DECL.Name)
  10886. copyint ((* yyNew)->DISTRIBUTE_DECL.Pos, yyt->DISTRIBUTE_DECL.Pos)
  10887. copytIdent ((* yyNew)->DISTRIBUTE_DECL.target, yyt->DISTRIBUTE_DECL.target)
  10888. yyt = yyt->DISTRIBUTE_DECL.DISTRIBUTION;
  10889. yyNew = & (* yyNew)->DISTRIBUTE_DECL.DISTRIBUTION; break;
  10890. case kALIGN_DECL: (* yyNew)->ALIGN_DECL = yyt->ALIGN_DECL;
  10891. copytIdent ((* yyNew)->ALIGN_DECL.Name, yyt->ALIGN_DECL.Name)
  10892. copyint ((* yyNew)->ALIGN_DECL.Pos, yyt->ALIGN_DECL.Pos)
  10893. copytTree ((* yyNew)->ALIGN_DECL.ALIGN_SOURCE, yyt->ALIGN_DECL.ALIGN_SOURCE)
  10894. yyt = yyt->ALIGN_DECL.ALIGN_SPEC;
  10895. yyNew = & (* yyNew)->ALIGN_DECL.ALIGN_SPEC; break;
  10896. case kDYNAMIC_DECL: (* yyNew)->DYNAMIC_DECL = yyt->DYNAMIC_DECL;
  10897. copytIdent ((* yyNew)->DYNAMIC_DECL.Name, yyt->DYNAMIC_DECL.Name)
  10898. copyint ((* yyNew)->DYNAMIC_DECL.Pos, yyt->DYNAMIC_DECL.Pos)
  10899. return;
  10900. case kSEQUENCE_DECL: (* yyNew)->SEQUENCE_DECL = yyt->SEQUENCE_DECL;
  10901. copytIdent ((* yyNew)->SEQUENCE_DECL.Name, yyt->SEQUENCE_DECL.Name)
  10902. copyint ((* yyNew)->SEQUENCE_DECL.Pos, yyt->SEQUENCE_DECL.Pos)
  10903. return;
  10904. case kNOSEQUENCE_DECL: (* yyNew)->NOSEQUENCE_DECL = yyt->NOSEQUENCE_DECL;
  10905. copytIdent ((* yyNew)->NOSEQUENCE_DECL.Name, yyt->NOSEQUENCE_DECL.Name)
  10906. copyint ((* yyNew)->NOSEQUENCE_DECL.Pos, yyt->NOSEQUENCE_DECL.Pos)
  10907. return;
  10908. case kDECL_NODE_LIST: (* yyNew)->DECL_NODE_LIST = yyt->DECL_NODE_LIST;
  10909. return;
  10910. case kDECL_EMPTY: (* yyNew)->DECL_EMPTY = yyt->DECL_EMPTY;
  10911. return;
  10912. case kDECL_LIST: (* yyNew)->DECL_LIST = yyt->DECL_LIST;
  10913. copytTree ((* yyNew)->DECL_LIST.Elem, yyt->DECL_LIST.Elem)
  10914. yyt = yyt->DECL_LIST.Next;
  10915. yyNew = & (* yyNew)->DECL_LIST.Next; break;
  10916. case kDISTRIBUTION_SPEC: (* yyNew)->DISTRIBUTION_SPEC = yyt->DISTRIBUTION_SPEC;
  10917. return;
  10918. case kHOST_DISTRIBUTION: (* yyNew)->HOST_DISTRIBUTION = yyt->HOST_DISTRIBUTION;
  10919. return;
  10920. case kREPL_DISTRIBUTION: (* yyNew)->REPL_DISTRIBUTION = yyt->REPL_DISTRIBUTION;
  10921. return;
  10922. case kNODE_DISTRIBUTION: (* yyNew)->NODE_DISTRIBUTION = yyt->NODE_DISTRIBUTION;
  10923. yyt = yyt->NODE_DISTRIBUTION.MAPPING;
  10924. yyNew = & (* yyNew)->NODE_DISTRIBUTION.MAPPING; break;
  10925. case kDISTRIBUTION_FORMAT: (* yyNew)->DISTRIBUTION_FORMAT = yyt->DISTRIBUTION_FORMAT;
  10926. return;
  10927. case kBLOCK_DISTRIBUTION: (* yyNew)->BLOCK_DISTRIBUTION = yyt->BLOCK_DISTRIBUTION;
  10928. yyt = yyt->BLOCK_DISTRIBUTION.SIZE;
  10929. yyNew = & (* yyNew)->BLOCK_DISTRIBUTION.SIZE; break;
  10930. case kCYCLIC_DISTRIBUTION: (* yyNew)->CYCLIC_DISTRIBUTION = yyt->CYCLIC_DISTRIBUTION;
  10931. yyt = yyt->CYCLIC_DISTRIBUTION.SIZE;
  10932. yyNew = & (* yyNew)->CYCLIC_DISTRIBUTION.SIZE; break;
  10933. case kSERIAL_DISTRIBUTION: (* yyNew)->SERIAL_DISTRIBUTION = yyt->SERIAL_DISTRIBUTION;
  10934. return;
  10935. case kDIST_FORMAT_LIST: (* yyNew)->DIST_FORMAT_LIST = yyt->DIST_FORMAT_LIST;
  10936. return;
  10937. case kDIST_EMPTY: (* yyNew)->DIST_EMPTY = yyt->DIST_EMPTY;
  10938. return;
  10939. case kDIST_LIST: (* yyNew)->DIST_LIST = yyt->DIST_LIST;
  10940. copytTree ((* yyNew)->DIST_LIST.Elem, yyt->DIST_LIST.Elem)
  10941. yyt = yyt->DIST_LIST.Next;
  10942. yyNew = & (* yyNew)->DIST_LIST.Next; break;
  10943. case kGENERIC_SPEC: (* yyNew)->GENERIC_SPEC = yyt->GENERIC_SPEC;
  10944. return;
  10945. case kNO_GENERIC_SPEC: (* yyNew)->NO_GENERIC_SPEC = yyt->NO_GENERIC_SPEC;
  10946. return;
  10947. case kID_GENERIC_SPEC: (* yyNew)->ID_GENERIC_SPEC = yyt->ID_GENERIC_SPEC;
  10948. copytIdent ((* yyNew)->ID_GENERIC_SPEC.name, yyt->ID_GENERIC_SPEC.name)
  10949. return;
  10950. case kOP_GENERIC_SPEC: (* yyNew)->OP_GENERIC_SPEC = yyt->OP_GENERIC_SPEC;
  10951. yyt = yyt->OP_GENERIC_SPEC.OPERATOR;
  10952. yyNew = & (* yyNew)->OP_GENERIC_SPEC.OPERATOR; break;
  10953. case kASSIGN_GENERIC_SPEC: (* yyNew)->ASSIGN_GENERIC_SPEC = yyt->ASSIGN_GENERIC_SPEC;
  10954. return;
  10955. case kACF_NODE_LIST: (* yyNew)->ACF_NODE_LIST = yyt->ACF_NODE_LIST;
  10956. return;
  10957. case kACF_EMPTY: (* yyNew)->ACF_EMPTY = yyt->ACF_EMPTY;
  10958. return;
  10959. case kACF_LIST: (* yyNew)->ACF_LIST = yyt->ACF_LIST;
  10960. copytTree ((* yyNew)->ACF_LIST.Elem, yyt->ACF_LIST.Elem)
  10961. yyt = yyt->ACF_LIST.Next;
  10962. yyNew = & (* yyNew)->ACF_LIST.Next; break;
  10963. case kACF_NODE: (* yyNew)->ACF_NODE = yyt->ACF_NODE;
  10964. copyint ((* yyNew)->ACF_NODE.Label, yyt->ACF_NODE.Label)
  10965. copyint ((* yyNew)->ACF_NODE.Line, yyt->ACF_NODE.Line)
  10966. return;
  10967. case kACF_DUMMY: (* yyNew)->ACF_DUMMY = yyt->ACF_DUMMY;
  10968. copyint ((* yyNew)->ACF_DUMMY.Label, yyt->ACF_DUMMY.Label)
  10969. copyint ((* yyNew)->ACF_DUMMY.Line, yyt->ACF_DUMMY.Line)
  10970. return;
  10971. case kACF_BASIC: (* yyNew)->ACF_BASIC = yyt->ACF_BASIC;
  10972. copyint ((* yyNew)->ACF_BASIC.Label, yyt->ACF_BASIC.Label)
  10973. copyint ((* yyNew)->ACF_BASIC.Line, yyt->ACF_BASIC.Line)
  10974. yyt = yyt->ACF_BASIC.BASIC_STMT;
  10975. yyNew = & (* yyNew)->ACF_BASIC.BASIC_STMT; break;
  10976. case kACF_IF: (* yyNew)->ACF_IF = yyt->ACF_IF;
  10977. copyint ((* yyNew)->ACF_IF.Label, yyt->ACF_IF.Label)
  10978. copyint ((* yyNew)->ACF_IF.Line, yyt->ACF_IF.Line)
  10979. copytTree ((* yyNew)->ACF_IF.IF_EXP, yyt->ACF_IF.IF_EXP)
  10980. copytTree ((* yyNew)->ACF_IF.THEN_PART, yyt->ACF_IF.THEN_PART)
  10981. yyt = yyt->ACF_IF.ELSE_PART;
  10982. yyNew = & (* yyNew)->ACF_IF.ELSE_PART; break;
  10983. case kACF_WHERE: (* yyNew)->ACF_WHERE = yyt->ACF_WHERE;
  10984. copyint ((* yyNew)->ACF_WHERE.Label, yyt->ACF_WHERE.Label)
  10985. copyint ((* yyNew)->ACF_WHERE.Line, yyt->ACF_WHERE.Line)
  10986. copytTree ((* yyNew)->ACF_WHERE.WHERE_EXP, yyt->ACF_WHERE.WHERE_EXP)
  10987. copytTree ((* yyNew)->ACF_WHERE.TRUE_PART, yyt->ACF_WHERE.TRUE_PART)
  10988. yyt = yyt->ACF_WHERE.FALSE_PART;
  10989. yyNew = & (* yyNew)->ACF_WHERE.FALSE_PART; break;
  10990. case kACF_SWITCH: (* yyNew)->ACF_SWITCH = yyt->ACF_SWITCH;
  10991. copyint ((* yyNew)->ACF_SWITCH.Label, yyt->ACF_SWITCH.Label)
  10992. copyint ((* yyNew)->ACF_SWITCH.Line, yyt->ACF_SWITCH.Line)
  10993. copytTree ((* yyNew)->ACF_SWITCH.SWITCH_EXP, yyt->ACF_SWITCH.SWITCH_EXP)
  10994. yyt = yyt->ACF_SWITCH.SWITCH_STMT;
  10995. yyNew = & (* yyNew)->ACF_SWITCH.SWITCH_STMT; break;
  10996. case kACF_ALTER: (* yyNew)->ACF_ALTER = yyt->ACF_ALTER;
  10997. copyint ((* yyNew)->ACF_ALTER.Label, yyt->ACF_ALTER.Label)
  10998. copyint ((* yyNew)->ACF_ALTER.Line, yyt->ACF_ALTER.Line)
  10999. copytTree ((* yyNew)->ACF_ALTER.ALTER_EXP, yyt->ACF_ALTER.ALTER_EXP)
  11000. yyt = yyt->ACF_ALTER.ALTER_STMT;
  11001. yyNew = & (* yyNew)->ACF_ALTER.ALTER_STMT; break;
  11002. case kACF_CASE: (* yyNew)->ACF_CASE = yyt->ACF_CASE;
  11003. copyint ((* yyNew)->ACF_CASE.Label, yyt->ACF_CASE.Label)
  11004. copyint ((* yyNew)->ACF_CASE.Line, yyt->ACF_CASE.Line)
  11005. copytTree ((* yyNew)->ACF_CASE.CASE_EXP, yyt->ACF_CASE.CASE_EXP)
  11006. copytTree ((* yyNew)->ACF_CASE.CASE_ALTS, yyt->ACF_CASE.CASE_ALTS)
  11007. yyt = yyt->ACF_CASE.CASE_OTHERWISE;
  11008. yyNew = & (* yyNew)->ACF_CASE.CASE_OTHERWISE; break;
  11009. case kACF_WHILE: (* yyNew)->ACF_WHILE = yyt->ACF_WHILE;
  11010. copyint ((* yyNew)->ACF_WHILE.Label, yyt->ACF_WHILE.Label)
  11011. copyint ((* yyNew)->ACF_WHILE.Line, yyt->ACF_WHILE.Line)
  11012. copytTree ((* yyNew)->ACF_WHILE.WHILE_EXP, yyt->ACF_WHILE.WHILE_EXP)
  11013. yyt = yyt->ACF_WHILE.WHILE_BODY;
  11014. yyNew = & (* yyNew)->ACF_WHILE.WHILE_BODY; break;
  11015. case kACF_REPEAT: (* yyNew)->ACF_REPEAT = yyt->ACF_REPEAT;
  11016. copyint ((* yyNew)->ACF_REPEAT.Label, yyt->ACF_REPEAT.Label)
  11017. copyint ((* yyNew)->ACF_REPEAT.Line, yyt->ACF_REPEAT.Line)
  11018. copytTree ((* yyNew)->ACF_REPEAT.REPEAT_BODY, yyt->ACF_REPEAT.REPEAT_BODY)
  11019. yyt = yyt->ACF_REPEAT.REPEAT_EXP;
  11020. yyNew = & (* yyNew)->ACF_REPEAT.REPEAT_EXP; break;
  11021. case kACF_WITH: (* yyNew)->ACF_WITH = yyt->ACF_WITH;
  11022. copyint ((* yyNew)->ACF_WITH.Label, yyt->ACF_WITH.Label)
  11023. copyint ((* yyNew)->ACF_WITH.Line, yyt->ACF_WITH.Line)
  11024. copytTree ((* yyNew)->ACF_WITH.WITH_VARS, yyt->ACF_WITH.WITH_VARS)
  11025. yyt = yyt->ACF_WITH.WITH_BODY;
  11026. yyNew = & (* yyNew)->ACF_WITH.WITH_BODY; break;
  11027. case kACF_LOOP: (* yyNew)->ACF_LOOP = yyt->ACF_LOOP;
  11028. copyint ((* yyNew)->ACF_LOOP.Label, yyt->ACF_LOOP.Label)
  11029. copyint ((* yyNew)->ACF_LOOP.Line, yyt->ACF_LOOP.Line)
  11030. yyt = yyt->ACF_LOOP.LOOP_BODY;
  11031. yyNew = & (* yyNew)->ACF_LOOP.LOOP_BODY; break;
  11032. case kACF_DO: (* yyNew)->ACF_DO = yyt->ACF_DO;
  11033. copyint ((* yyNew)->ACF_DO.Label, yyt->ACF_DO.Label)
  11034. copyint ((* yyNew)->ACF_DO.Line, yyt->ACF_DO.Line)
  11035. copytTree ((* yyNew)->ACF_DO.DO_ID, yyt->ACF_DO.DO_ID)
  11036. copytTree ((* yyNew)->ACF_DO.DO_RANGE, yyt->ACF_DO.DO_RANGE)
  11037. yyt = yyt->ACF_DO.DO_BODY;
  11038. yyNew = & (* yyNew)->ACF_DO.DO_BODY; break;
  11039. case kACF_DOLOCAL: (* yyNew)->ACF_DOLOCAL = yyt->ACF_DOLOCAL;
  11040. copyint ((* yyNew)->ACF_DOLOCAL.Label, yyt->ACF_DOLOCAL.Label)
  11041. copyint ((* yyNew)->ACF_DOLOCAL.Line, yyt->ACF_DOLOCAL.Line)
  11042. copytTree ((* yyNew)->ACF_DOLOCAL.DOLOCAL_ID, yyt->ACF_DOLOCAL.DOLOCAL_ID)
  11043. copytTree ((* yyNew)->ACF_DOLOCAL.DOLOCAL_RANGE, yyt->ACF_DOLOCAL.DOLOCAL_RANGE)
  11044. yyt = yyt->ACF_DOLOCAL.DOLOCAL_BODY;
  11045. yyNew = & (* yyNew)->ACF_DOLOCAL.DOLOCAL_BODY; break;
  11046. case kACF_DOVEC: (* yyNew)->ACF_DOVEC = yyt->ACF_DOVEC;
  11047. copyint ((* yyNew)->ACF_DOVEC.Label, yyt->ACF_DOVEC.Label)
  11048. copyint ((* yyNew)->ACF_DOVEC.Line, yyt->ACF_DOVEC.Line)
  11049. copytTree ((* yyNew)->ACF_DOVEC.DOVEC_ID, yyt->ACF_DOVEC.DOVEC_ID)
  11050. copytTree ((* yyNew)->ACF_DOVEC.DOVEC_RANGE, yyt->ACF_DOVEC.DOVEC_RANGE)
  11051. yyt = yyt->ACF_DOVEC.DOVEC_BODY;
  11052. yyNew = & (* yyNew)->ACF_DOVEC.DOVEC_BODY; break;
  11053. case kACF_DOALL: (* yyNew)->ACF_DOALL = yyt->ACF_DOALL;
  11054. copyint ((* yyNew)->ACF_DOALL.Label, yyt->ACF_DOALL.Label)
  11055. copyint ((* yyNew)->ACF_DOALL.Line, yyt->ACF_DOALL.Line)
  11056. copytTree ((* yyNew)->ACF_DOALL.DOALL_NEW, yyt->ACF_DOALL.DOALL_NEW)
  11057. copytTree ((* yyNew)->ACF_DOALL.DOALL_ID, yyt->ACF_DOALL.DOALL_ID)
  11058. copytTree ((* yyNew)->ACF_DOALL.DOALL_RANGE, yyt->ACF_DOALL.DOALL_RANGE)
  11059. yyt = yyt->ACF_DOALL.DOALL_BODY;
  11060. yyNew = & (* yyNew)->ACF_DOALL.DOALL_BODY; break;
  11061. case kACF_FORALL: (* yyNew)->ACF_FORALL = yyt->ACF_FORALL;
  11062. copyint ((* yyNew)->ACF_FORALL.Label, yyt->ACF_FORALL.Label)
  11063. copyint ((* yyNew)->ACF_FORALL.Line, yyt->ACF_FORALL.Line)
  11064. copytTree ((* yyNew)->ACF_FORALL.FORALL_ID, yyt->ACF_FORALL.FORALL_ID)
  11065. copytTree ((* yyNew)->ACF_FORALL.FORALL_RANGE, yyt->ACF_FORALL.FORALL_RANGE)
  11066. yyt = yyt->ACF_FORALL.FORALL_BODY;
  11067. yyNew = & (* yyNew)->ACF_FORALL.FORALL_BODY; break;
  11068. case kACF_ON: (* yyNew)->ACF_ON = yyt->ACF_ON;
  11069. copyint ((* yyNew)->ACF_ON.Label, yyt->ACF_ON.Label)
  11070. copyint ((* yyNew)->ACF_ON.Line, yyt->ACF_ON.Line)
  11071. copytTree ((* yyNew)->ACF_ON.ON_VAR, yyt->ACF_ON.ON_VAR)
  11072. yyt = yyt->ACF_ON.ON_STMT;
  11073. yyNew = & (* yyNew)->ACF_ON.ON_STMT; break;
  11074. case kACF_BODY: (* yyNew)->ACF_BODY = yyt->ACF_BODY;
  11075. copyint ((* yyNew)->ACF_BODY.Label, yyt->ACF_BODY.Label)
  11076. copyint ((* yyNew)->ACF_BODY.Line, yyt->ACF_BODY.Line)
  11077. copytDefinitions ((* yyNew)->ACF_BODY.Entries, yyt->ACF_BODY.Entries)
  11078. yyt = yyt->ACF_BODY.NEW_BODY;
  11079. yyNew = & (* yyNew)->ACF_BODY.NEW_BODY; break;
  11080. case kACF_FLOW_GRAPH: (* yyNew)->ACF_FLOW_GRAPH = yyt->ACF_FLOW_GRAPH;
  11081. copyint ((* yyNew)->ACF_FLOW_GRAPH.Label, yyt->ACF_FLOW_GRAPH.Label)
  11082. copyint ((* yyNew)->ACF_FLOW_GRAPH.Line, yyt->ACF_FLOW_GRAPH.Line)
  11083. yyt = yyt->ACF_FLOW_GRAPH.FLOW_NODES;
  11084. yyNew = & (* yyNew)->ACF_FLOW_GRAPH.FLOW_NODES; break;
  11085. case kACF_ENTRY: (* yyNew)->ACF_ENTRY = yyt->ACF_ENTRY;
  11086. copyint ((* yyNew)->ACF_ENTRY.Label, yyt->ACF_ENTRY.Label)
  11087. copyint ((* yyNew)->ACF_ENTRY.Line, yyt->ACF_ENTRY.Line)
  11088. yyt = yyt->ACF_ENTRY.ENTRY_DECL;
  11089. yyNew = & (* yyNew)->ACF_ENTRY.ENTRY_DECL; break;
  11090. case kACF_FLOW_KIND: (* yyNew)->ACF_FLOW_KIND = yyt->ACF_FLOW_KIND;
  11091. return;
  11092. case kACF_COMPLEX_FLOW: (* yyNew)->ACF_COMPLEX_FLOW = yyt->ACF_COMPLEX_FLOW;
  11093. return;
  11094. case kACF_INTERVAL_FLOW: (* yyNew)->ACF_INTERVAL_FLOW = yyt->ACF_INTERVAL_FLOW;
  11095. return;
  11096. case kACF_SIMPLE_FLOW: (* yyNew)->ACF_SIMPLE_FLOW = yyt->ACF_SIMPLE_FLOW;
  11097. return;
  11098. case kSELECTED_ACF_NODE_LIST: (* yyNew)->SELECTED_ACF_NODE_LIST = yyt->SELECTED_ACF_NODE_LIST;
  11099. return;
  11100. case kSELECTED_ACF_EMPTY: (* yyNew)->SELECTED_ACF_EMPTY = yyt->SELECTED_ACF_EMPTY;
  11101. return;
  11102. case kSELECTED_ACF_LIST: (* yyNew)->SELECTED_ACF_LIST = yyt->SELECTED_ACF_LIST;
  11103. copytTree ((* yyNew)->SELECTED_ACF_LIST.Elem, yyt->SELECTED_ACF_LIST.Elem)
  11104. yyt = yyt->SELECTED_ACF_LIST.Next;
  11105. yyNew = & (* yyNew)->SELECTED_ACF_LIST.Next; break;
  11106. case kSELECTED_ACF_NODE: (* yyNew)->SELECTED_ACF_NODE = yyt->SELECTED_ACF_NODE;
  11107. copytTree ((* yyNew)->SELECTED_ACF_NODE.SELECT_LIST, yyt->SELECTED_ACF_NODE.SELECT_LIST)
  11108. yyt = yyt->SELECTED_ACF_NODE.SELECT_ACFS;
  11109. yyNew = & (* yyNew)->SELECTED_ACF_NODE.SELECT_ACFS; break;
  11110. case kBT_STMT: (* yyNew)->BT_STMT = yyt->BT_STMT;
  11111. return;
  11112. case kEXP_STMT: (* yyNew)->EXP_STMT = yyt->EXP_STMT;
  11113. yyt = yyt->EXP_STMT.STMT_EXP;
  11114. yyNew = & (* yyNew)->EXP_STMT.STMT_EXP; break;
  11115. case kASSIGN_STMT: (* yyNew)->ASSIGN_STMT = yyt->ASSIGN_STMT;
  11116. copytTree ((* yyNew)->ASSIGN_STMT.ASSIGN_VAR, yyt->ASSIGN_STMT.ASSIGN_VAR)
  11117. yyt = yyt->ASSIGN_STMT.ASSIGN_EXP;
  11118. yyNew = & (* yyNew)->ASSIGN_STMT.ASSIGN_EXP; break;
  11119. case kPTR_ASSIGN_STMT: (* yyNew)->PTR_ASSIGN_STMT = yyt->PTR_ASSIGN_STMT;
  11120. copytTree ((* yyNew)->PTR_ASSIGN_STMT.ASSIGN_VAR, yyt->PTR_ASSIGN_STMT.ASSIGN_VAR)
  11121. yyt = yyt->PTR_ASSIGN_STMT.ASSIGN_EXP;
  11122. yyNew = & (* yyNew)->PTR_ASSIGN_STMT.ASSIGN_EXP; break;
  11123. case kLABEL_ASSIGN_STMT: (* yyNew)->LABEL_ASSIGN_STMT = yyt->LABEL_ASSIGN_STMT;
  11124. copyint ((* yyNew)->LABEL_ASSIGN_STMT.assign_label, yyt->LABEL_ASSIGN_STMT.assign_label)
  11125. yyt = yyt->LABEL_ASSIGN_STMT.LABEL_VAR;
  11126. yyNew = & (* yyNew)->LABEL_ASSIGN_STMT.LABEL_VAR; break;
  11127. case kCALL_STMT: (* yyNew)->CALL_STMT = yyt->CALL_STMT;
  11128. copytTree ((* yyNew)->CALL_STMT.CALL_ID, yyt->CALL_STMT.CALL_ID)
  11129. yyt = yyt->CALL_STMT.CALL_PARAMS;
  11130. yyNew = & (* yyNew)->CALL_STMT.CALL_PARAMS; break;
  11131. case kIO_STMT: (* yyNew)->IO_STMT = yyt->IO_STMT;
  11132. copytTree ((* yyNew)->IO_STMT.ID, yyt->IO_STMT.ID)
  11133. copytTree ((* yyNew)->IO_STMT.IO_SPECS, yyt->IO_STMT.IO_SPECS)
  11134. yyt = yyt->IO_STMT.IO_ITEMS;
  11135. yyNew = & (* yyNew)->IO_STMT.IO_ITEMS; break;
  11136. case kGOTO_STMT: (* yyNew)->GOTO_STMT = yyt->GOTO_STMT;
  11137. copyint ((* yyNew)->GOTO_STMT.GOTO_LABEL, yyt->GOTO_STMT.GOTO_LABEL)
  11138. return;
  11139. case kASS_GOTO_STMT: (* yyNew)->ASS_GOTO_STMT = yyt->ASS_GOTO_STMT;
  11140. copytTree ((* yyNew)->ASS_GOTO_STMT.GOTO_VAR, yyt->ASS_GOTO_STMT.GOTO_VAR)
  11141. yyt = yyt->ASS_GOTO_STMT.LABELS;
  11142. yyNew = & (* yyNew)->ASS_GOTO_STMT.LABELS; break;
  11143. case kCOMP_GOTO_STMT: (* yyNew)->COMP_GOTO_STMT = yyt->COMP_GOTO_STMT;
  11144. copytTree ((* yyNew)->COMP_GOTO_STMT.GOTO_LABELS, yyt->COMP_GOTO_STMT.GOTO_LABELS)
  11145. yyt = yyt->COMP_GOTO_STMT.GOTO_EXP;
  11146. yyNew = & (* yyNew)->COMP_GOTO_STMT.GOTO_EXP; break;
  11147. case kCOMP_IF_STMT: (* yyNew)->COMP_IF_STMT = yyt->COMP_IF_STMT;
  11148. copyint ((* yyNew)->COMP_IF_STMT.IF_LT_LABEL, yyt->COMP_IF_STMT.IF_LT_LABEL)
  11149. copyint ((* yyNew)->COMP_IF_STMT.IF_EQ_LABEL, yyt->COMP_IF_STMT.IF_EQ_LABEL)
  11150. copyint ((* yyNew)->COMP_IF_STMT.IF_GT_LABEL, yyt->COMP_IF_STMT.IF_GT_LABEL)
  11151. yyt = yyt->COMP_IF_STMT.IF_EXP;
  11152. yyNew = & (* yyNew)->COMP_IF_STMT.IF_EXP; break;
  11153. case kRETURN_STMT: (* yyNew)->RETURN_STMT = yyt->RETURN_STMT;
  11154. yyt = yyt->RETURN_STMT.RETURN_EXP;
  11155. yyNew = & (* yyNew)->RETURN_STMT.RETURN_EXP; break;
  11156. case kPAUSE_STMT: (* yyNew)->PAUSE_STMT = yyt->PAUSE_STMT;
  11157. yyt = yyt->PAUSE_STMT.PAUSE_CONST;
  11158. yyNew = & (* yyNew)->PAUSE_STMT.PAUSE_CONST; break;
  11159. case kEXIT_STMT: (* yyNew)->EXIT_STMT = yyt->EXIT_STMT;
  11160. copytIdent ((* yyNew)->EXIT_STMT.loopid, yyt->EXIT_STMT.loopid)
  11161. return;
  11162. case kCYCLE_STMT: (* yyNew)->CYCLE_STMT = yyt->CYCLE_STMT;
  11163. copytIdent ((* yyNew)->CYCLE_STMT.loopid, yyt->CYCLE_STMT.loopid)
  11164. return;
  11165. case kSTOP_STMT: (* yyNew)->STOP_STMT = yyt->STOP_STMT;
  11166. yyt = yyt->STOP_STMT.STOP_CONST;
  11167. yyNew = & (* yyNew)->STOP_STMT.STOP_CONST; break;
  11168. case kFORMAT_STMT: (* yyNew)->FORMAT_STMT = yyt->FORMAT_STMT;
  11169. yyt = yyt->FORMAT_STMT.FORMAT_PARAMS;
  11170. yyNew = & (* yyNew)->FORMAT_STMT.FORMAT_PARAMS; break;
  11171. case kALLOCATE_STMT: (* yyNew)->ALLOCATE_STMT = yyt->ALLOCATE_STMT;
  11172. copytTree ((* yyNew)->ALLOCATE_STMT.PARAMS, yyt->ALLOCATE_STMT.PARAMS)
  11173. yyt = yyt->ALLOCATE_STMT.STAT;
  11174. yyNew = & (* yyNew)->ALLOCATE_STMT.STAT; break;
  11175. case kDEALLOCATE_STMT: (* yyNew)->DEALLOCATE_STMT = yyt->DEALLOCATE_STMT;
  11176. copytTree ((* yyNew)->DEALLOCATE_STMT.PARAMS, yyt->DEALLOCATE_STMT.PARAMS)
  11177. yyt = yyt->DEALLOCATE_STMT.STAT;
  11178. yyNew = & (* yyNew)->DEALLOCATE_STMT.STAT; break;
  11179. case kNULLIFY_STMT: (* yyNew)->NULLIFY_STMT = yyt->NULLIFY_STMT;
  11180. yyt = yyt->NULLIFY_STMT.PARAMS;
  11181. yyNew = & (* yyNew)->NULLIFY_STMT.PARAMS; break;
  11182. case kREDUCE_STMT: (* yyNew)->REDUCE_STMT = yyt->REDUCE_STMT;
  11183. copytTree ((* yyNew)->REDUCE_STMT.RED_FUNC, yyt->REDUCE_STMT.RED_FUNC)
  11184. yyt = yyt->REDUCE_STMT.RED_PARAMS;
  11185. yyNew = & (* yyNew)->REDUCE_STMT.RED_PARAMS; break;
  11186. case kGLOBAL_STMT: (* yyNew)->GLOBAL_STMT = yyt->GLOBAL_STMT;
  11187. copytIdent ((* yyNew)->GLOBAL_STMT.func, yyt->GLOBAL_STMT.func)
  11188. copytTree ((* yyNew)->GLOBAL_STMT.ARRAY, yyt->GLOBAL_STMT.ARRAY)
  11189. copytTree ((* yyNew)->GLOBAL_STMT.INDEXED_ARRAY, yyt->GLOBAL_STMT.INDEXED_ARRAY)
  11190. copytTree ((* yyNew)->GLOBAL_STMT.INDEXES, yyt->GLOBAL_STMT.INDEXES)
  11191. yyt = yyt->GLOBAL_STMT.MASK;
  11192. yyNew = & (* yyNew)->GLOBAL_STMT.MASK; break;
  11193. case kALIGN_STMT: (* yyNew)->ALIGN_STMT = yyt->ALIGN_STMT;
  11194. copytTree ((* yyNew)->ALIGN_STMT.ALIGNEE, yyt->ALIGN_STMT.ALIGNEE)
  11195. yyt = yyt->ALIGN_STMT.ALIGN_SPEC;
  11196. yyNew = & (* yyNew)->ALIGN_STMT.ALIGN_SPEC; break;
  11197. case kDISTRIBUTE_STMT: (* yyNew)->DISTRIBUTE_STMT = yyt->DISTRIBUTE_STMT;
  11198. copytTree ((* yyNew)->DISTRIBUTE_STMT.DISTRIBUTEE, yyt->DISTRIBUTE_STMT.DISTRIBUTEE)
  11199. copytIdent ((* yyNew)->DISTRIBUTE_STMT.target, yyt->DISTRIBUTE_STMT.target)
  11200. yyt = yyt->DISTRIBUTE_STMT.DISTRIBUTION;
  11201. yyNew = & (* yyNew)->DISTRIBUTE_STMT.DISTRIBUTION; break;
  11202. case kLABEL_USE_LIST: (* yyNew)->LABEL_USE_LIST = yyt->LABEL_USE_LIST;
  11203. return;
  11204. case kLABEL_EMPTY: (* yyNew)->LABEL_EMPTY = yyt->LABEL_EMPTY;
  11205. return;
  11206. case kLABEL_LIST: (* yyNew)->LABEL_LIST = yyt->LABEL_LIST;
  11207. copyint ((* yyNew)->LABEL_LIST.Elem, yyt->LABEL_LIST.Elem)
  11208. yyt = yyt->LABEL_LIST.Next;
  11209. yyNew = & (* yyNew)->LABEL_LIST.Next; break;
  11210. case kOP: (* yyNew)->OP = yyt->OP;
  11211. return;
  11212. case kOP_EQ: (* yyNew)->OP_EQ = yyt->OP_EQ;
  11213. return;
  11214. case kOP_NE: (* yyNew)->OP_NE = yyt->OP_NE;
  11215. return;
  11216. case kOP_LT: (* yyNew)->OP_LT = yyt->OP_LT;
  11217. return;
  11218. case kOP_GT: (* yyNew)->OP_GT = yyt->OP_GT;
  11219. return;
  11220. case kOP_GE: (* yyNew)->OP_GE = yyt->OP_GE;
  11221. return;
  11222. case kOP_LE: (* yyNew)->OP_LE = yyt->OP_LE;
  11223. return;
  11224. case kOP_PLUS: (* yyNew)->OP_PLUS = yyt->OP_PLUS;
  11225. return;
  11226. case kOP_MINUS: (* yyNew)->OP_MINUS = yyt->OP_MINUS;
  11227. return;
  11228. case kOP_XOR: (* yyNew)->OP_XOR = yyt->OP_XOR;
  11229. return;
  11230. case kOP_OR: (* yyNew)->OP_OR = yyt->OP_OR;
  11231. return;
  11232. case kOP_CONCAT: (* yyNew)->OP_CONCAT = yyt->OP_CONCAT;
  11233. return;
  11234. case kOP_TIMES: (* yyNew)->OP_TIMES = yyt->OP_TIMES;
  11235. return;
  11236. case kOP_DIVIDE: (* yyNew)->OP_DIVIDE = yyt->OP_DIVIDE;
  11237. return;
  11238. case kOP_DIV: (* yyNew)->OP_DIV = yyt->OP_DIV;
  11239. return;
  11240. case kOP_AND: (* yyNew)->OP_AND = yyt->OP_AND;
  11241. return;
  11242. case kOP_EQV: (* yyNew)->OP_EQV = yyt->OP_EQV;
  11243. return;
  11244. case kOP_NEQV: (* yyNew)->OP_NEQV = yyt->OP_NEQV;
  11245. return;
  11246. case kOP_EXPO: (* yyNew)->OP_EXPO = yyt->OP_EXPO;
  11247. return;
  11248. case kOP_MOD: (* yyNew)->OP_MOD = yyt->OP_MOD;
  11249. return;
  11250. case kOP_IN: (* yyNew)->OP_IN = yyt->OP_IN;
  11251. return;
  11252. case kOP_DEFINED: (* yyNew)->OP_DEFINED = yyt->OP_DEFINED;
  11253. copytIdent ((* yyNew)->OP_DEFINED.opname, yyt->OP_DEFINED.opname)
  11254. return;
  11255. case kOP_ASSIGN: (* yyNew)->OP_ASSIGN = yyt->OP_ASSIGN;
  11256. return;
  11257. case kOP_LEFT: (* yyNew)->OP_LEFT = yyt->OP_LEFT;
  11258. return;
  11259. case kOP_RIGHT: (* yyNew)->OP_RIGHT = yyt->OP_RIGHT;
  11260. return;
  11261. case kOP_LIST: (* yyNew)->OP_LIST = yyt->OP_LIST;
  11262. return;
  11263. case kOP_IOR: (* yyNew)->OP_IOR = yyt->OP_IOR;
  11264. return;
  11265. case kOP_IXOR: (* yyNew)->OP_IXOR = yyt->OP_IXOR;
  11266. return;
  11267. case kOP_IAND: (* yyNew)->OP_IAND = yyt->OP_IAND;
  11268. return;
  11269. case kOP1_NOT: (* yyNew)->OP1_NOT = yyt->OP1_NOT;
  11270. return;
  11271. case kOP1_SIGN: (* yyNew)->OP1_SIGN = yyt->OP1_SIGN;
  11272. return;
  11273. case kOP1_INOT: (* yyNew)->OP1_INOT = yyt->OP1_INOT;
  11274. return;
  11275. case kOP1_SIZE: (* yyNew)->OP1_SIZE = yyt->OP1_SIZE;
  11276. return;
  11277. case kOP1_DEC: (* yyNew)->OP1_DEC = yyt->OP1_DEC;
  11278. return;
  11279. case kOP1_INC: (* yyNew)->OP1_INC = yyt->OP1_INC;
  11280. return;
  11281. case kOP1_ADDRESS: (* yyNew)->OP1_ADDRESS = yyt->OP1_ADDRESS;
  11282. return;
  11283. case kOP1_DEREF: (* yyNew)->OP1_DEREF = yyt->OP1_DEREF;
  11284. return;
  11285. case kBT_EXP: (* yyNew)->BT_EXP = yyt->BT_EXP;
  11286. return;
  11287. case kDUMMY_EXP: (* yyNew)->DUMMY_EXP = yyt->DUMMY_EXP;
  11288. return;
  11289. case kCONST_EXP: (* yyNew)->CONST_EXP = yyt->CONST_EXP;
  11290. yyt = yyt->CONST_EXP.C;
  11291. yyNew = & (* yyNew)->CONST_EXP.C; break;
  11292. case kOP_EXP: (* yyNew)->OP_EXP = yyt->OP_EXP;
  11293. copytTree ((* yyNew)->OP_EXP.EXP_OP, yyt->OP_EXP.EXP_OP)
  11294. copytTree ((* yyNew)->OP_EXP.OPND1, yyt->OP_EXP.OPND1)
  11295. yyt = yyt->OP_EXP.OPND2;
  11296. yyNew = & (* yyNew)->OP_EXP.OPND2; break;
  11297. case kOP1_EXP: (* yyNew)->OP1_EXP = yyt->OP1_EXP;
  11298. copytTree ((* yyNew)->OP1_EXP.EXP_OP1, yyt->OP1_EXP.EXP_OP1)
  11299. yyt = yyt->OP1_EXP.OPND;
  11300. yyNew = & (* yyNew)->OP1_EXP.OPND; break;
  11301. case kSLICE_EXP: (* yyNew)->SLICE_EXP = yyt->SLICE_EXP;
  11302. copytTree ((* yyNew)->SLICE_EXP.START, yyt->SLICE_EXP.START)
  11303. copytTree ((* yyNew)->SLICE_EXP.STOP, yyt->SLICE_EXP.STOP)
  11304. yyt = yyt->SLICE_EXP.INC;
  11305. yyNew = & (* yyNew)->SLICE_EXP.INC; break;
  11306. case kPOSTFIX_EXP: (* yyNew)->POSTFIX_EXP = yyt->POSTFIX_EXP;
  11307. copytTree ((* yyNew)->POSTFIX_EXP.POSTFIX_OP, yyt->POSTFIX_EXP.POSTFIX_OP)
  11308. yyt = yyt->POSTFIX_EXP.OPND;
  11309. yyNew = & (* yyNew)->POSTFIX_EXP.OPND; break;
  11310. case kCALL_EXP: (* yyNew)->CALL_EXP = yyt->CALL_EXP;
  11311. copytTree ((* yyNew)->CALL_EXP.FUNC_ID, yyt->CALL_EXP.FUNC_ID)
  11312. yyt = yyt->CALL_EXP.FUNC_PARAMS;
  11313. yyNew = & (* yyNew)->CALL_EXP.FUNC_PARAMS; break;
  11314. case kCAST_EXP: (* yyNew)->CAST_EXP = yyt->CAST_EXP;
  11315. copytTree ((* yyNew)->CAST_EXP.ID, yyt->CAST_EXP.ID)
  11316. yyt = yyt->CAST_EXP.CAST;
  11317. yyNew = & (* yyNew)->CAST_EXP.CAST; break;
  11318. case kINDEXED_EXP: (* yyNew)->INDEXED_EXP = yyt->INDEXED_EXP;
  11319. copytTree ((* yyNew)->INDEXED_EXP.IND_EXP, yyt->INDEXED_EXP.IND_EXP)
  11320. yyt = yyt->INDEXED_EXP.INDEX;
  11321. yyNew = & (* yyNew)->INDEXED_EXP.INDEX; break;
  11322. case kSELECTED_EXP: (* yyNew)->SELECTED_EXP = yyt->SELECTED_EXP;
  11323. copytTree ((* yyNew)->SELECTED_EXP.SELEC_EXP, yyt->SELECTED_EXP.SELEC_EXP)
  11324. yyt = yyt->SELECTED_EXP.SELECTOR;
  11325. yyNew = & (* yyNew)->SELECTED_EXP.SELECTOR; break;
  11326. case kASSIGN_EXP: (* yyNew)->ASSIGN_EXP = yyt->ASSIGN_EXP;
  11327. copytTree ((* yyNew)->ASSIGN_EXP.ASSIGN_OP, yyt->ASSIGN_EXP.ASSIGN_OP)
  11328. copytTree ((* yyNew)->ASSIGN_EXP.LHS, yyt->ASSIGN_EXP.LHS)
  11329. yyt = yyt->ASSIGN_EXP.RHS;
  11330. yyNew = & (* yyNew)->ASSIGN_EXP.RHS; break;
  11331. case kUSED_EXP: (* yyNew)->USED_EXP = yyt->USED_EXP;
  11332. yyt = yyt->USED_EXP.VARNAME;
  11333. yyNew = & (* yyNew)->USED_EXP.VARNAME; break;
  11334. case kCOND_EXP: (* yyNew)->COND_EXP = yyt->COND_EXP;
  11335. copytTree ((* yyNew)->COND_EXP.COND, yyt->COND_EXP.COND)
  11336. copytTree ((* yyNew)->COND_EXP.TRUE_EXP, yyt->COND_EXP.TRUE_EXP)
  11337. yyt = yyt->COND_EXP.FALSE_EXP;
  11338. yyNew = & (* yyNew)->COND_EXP.FALSE_EXP; break;
  11339. case kVAR_EXP: (* yyNew)->VAR_EXP = yyt->VAR_EXP;
  11340. yyt = yyt->VAR_EXP.V;
  11341. yyNew = & (* yyNew)->VAR_EXP.V; break;
  11342. case kFUNC_CALL_EXP: (* yyNew)->FUNC_CALL_EXP = yyt->FUNC_CALL_EXP;
  11343. copytTree ((* yyNew)->FUNC_CALL_EXP.FUNC_ID, yyt->FUNC_CALL_EXP.FUNC_ID)
  11344. yyt = yyt->FUNC_CALL_EXP.FUNC_PARAMS;
  11345. yyNew = & (* yyNew)->FUNC_CALL_EXP.FUNC_PARAMS; break;
  11346. case kNAMED_EXP: (* yyNew)->NAMED_EXP = yyt->NAMED_EXP;
  11347. copytIdent ((* yyNew)->NAMED_EXP.Name, yyt->NAMED_EXP.Name)
  11348. yyt = yyt->NAMED_EXP.VAL;
  11349. yyNew = & (* yyNew)->NAMED_EXP.VAL; break;
  11350. case kDO_EXP: (* yyNew)->DO_EXP = yyt->DO_EXP;
  11351. copytTree ((* yyNew)->DO_EXP.DO_ID, yyt->DO_EXP.DO_ID)
  11352. copytTree ((* yyNew)->DO_EXP.RANGE, yyt->DO_EXP.RANGE)
  11353. yyt = yyt->DO_EXP.BODY;
  11354. yyNew = & (* yyNew)->DO_EXP.BODY; break;
  11355. case kTYPE_EXP: (* yyNew)->TYPE_EXP = yyt->TYPE_EXP;
  11356. copytTree ((* yyNew)->TYPE_EXP.ID, yyt->TYPE_EXP.ID)
  11357. yyt = yyt->TYPE_EXP.ELEMENTS;
  11358. yyNew = & (* yyNew)->TYPE_EXP.ELEMENTS; break;
  11359. case kARRAY_EXP: (* yyNew)->ARRAY_EXP = yyt->ARRAY_EXP;
  11360. yyt = yyt->ARRAY_EXP.ELEMENTS;
  11361. yyNew = & (* yyNew)->ARRAY_EXP.ELEMENTS; break;
  11362. case kBT_EXP_LIST: (* yyNew)->BT_EXP_LIST = yyt->BT_EXP_LIST;
  11363. return;
  11364. case kBTE_EMPTY: (* yyNew)->BTE_EMPTY = yyt->BTE_EMPTY;
  11365. return;
  11366. case kBTE_LIST: (* yyNew)->BTE_LIST = yyt->BTE_LIST;
  11367. copytTree ((* yyNew)->BTE_LIST.Elem, yyt->BTE_LIST.Elem)
  11368. yyt = yyt->BTE_LIST.Next;
  11369. yyNew = & (* yyNew)->BTE_LIST.Next; break;
  11370. case kBT_VAR: (* yyNew)->BT_VAR = yyt->BT_VAR;
  11371. return;
  11372. case kDUMMY_VAR: (* yyNew)->DUMMY_VAR = yyt->DUMMY_VAR;
  11373. return;
  11374. case kUSED_VAR: (* yyNew)->USED_VAR = yyt->USED_VAR;
  11375. yyt = yyt->USED_VAR.VARNAME;
  11376. yyNew = & (* yyNew)->USED_VAR.VARNAME; break;
  11377. case kINDEXED_VAR: (* yyNew)->INDEXED_VAR = yyt->INDEXED_VAR;
  11378. copytTree ((* yyNew)->INDEXED_VAR.IND_VAR, yyt->INDEXED_VAR.IND_VAR)
  11379. yyt = yyt->INDEXED_VAR.IND_EXPS;
  11380. yyNew = & (* yyNew)->INDEXED_VAR.IND_EXPS; break;
  11381. case kSUBSTRING_VAR: (* yyNew)->SUBSTRING_VAR = yyt->SUBSTRING_VAR;
  11382. copytTree ((* yyNew)->SUBSTRING_VAR.IND_VAR, yyt->SUBSTRING_VAR.IND_VAR)
  11383. yyt = yyt->SUBSTRING_VAR.IND_EXP;
  11384. yyNew = & (* yyNew)->SUBSTRING_VAR.IND_EXP; break;
  11385. case kSELECTED_VAR: (* yyNew)->SELECTED_VAR = yyt->SELECTED_VAR;
  11386. copytTree ((* yyNew)->SELECTED_VAR.SELEC_VAR, yyt->SELECTED_VAR.SELEC_VAR)
  11387. yyt = yyt->SELECTED_VAR.SELECTOR;
  11388. yyNew = & (* yyNew)->SELECTED_VAR.SELECTOR; break;
  11389. case kLOOP_VAR: (* yyNew)->LOOP_VAR = yyt->LOOP_VAR;
  11390. yyt = yyt->LOOP_VAR.LOOP_VARNAME;
  11391. yyNew = & (* yyNew)->LOOP_VAR.LOOP_VARNAME; break;
  11392. case kADDR: (* yyNew)->ADDR = yyt->ADDR;
  11393. yyt = yyt->ADDR.E;
  11394. yyNew = & (* yyNew)->ADDR.E; break;
  11395. case kDO_VAR: (* yyNew)->DO_VAR = yyt->DO_VAR;
  11396. copytTree ((* yyNew)->DO_VAR.DO_ID, yyt->DO_VAR.DO_ID)
  11397. copytTree ((* yyNew)->DO_VAR.RANGE, yyt->DO_VAR.RANGE)
  11398. yyt = yyt->DO_VAR.BODY;
  11399. yyNew = & (* yyNew)->DO_VAR.BODY; break;
  11400. case kBT_VAR_LIST: (* yyNew)->BT_VAR_LIST = yyt->BT_VAR_LIST;
  11401. return;
  11402. case kBTV_EMPTY: (* yyNew)->BTV_EMPTY = yyt->BTV_EMPTY;
  11403. return;
  11404. case kBTV_LIST: (* yyNew)->BTV_LIST = yyt->BTV_LIST;
  11405. copytTree ((* yyNew)->BTV_LIST.Elem, yyt->BTV_LIST.Elem)
  11406. yyt = yyt->BTV_LIST.Next;
  11407. yyNew = & (* yyNew)->BTV_LIST.Next; break;
  11408. case kBT_PARAM: (* yyNew)->BT_PARAM = yyt->BT_PARAM;
  11409. return;
  11410. case kVAR_PARAM: (* yyNew)->VAR_PARAM = yyt->VAR_PARAM;
  11411. yyt = yyt->VAR_PARAM.V;
  11412. yyNew = & (* yyNew)->VAR_PARAM.V; break;
  11413. case kVALUE_PARAM: (* yyNew)->VALUE_PARAM = yyt->VALUE_PARAM;
  11414. yyt = yyt->VALUE_PARAM.E;
  11415. yyNew = & (* yyNew)->VALUE_PARAM.E; break;
  11416. case kNAMED_PARAM: (* yyNew)->NAMED_PARAM = yyt->NAMED_PARAM;
  11417. copytIdent ((* yyNew)->NAMED_PARAM.Name, yyt->NAMED_PARAM.Name)
  11418. yyt = yyt->NAMED_PARAM.VAL;
  11419. yyNew = & (* yyNew)->NAMED_PARAM.VAL; break;
  11420. case kPROC_PARAM: (* yyNew)->PROC_PARAM = yyt->PROC_PARAM;
  11421. yyt = yyt->PROC_PARAM.P;
  11422. yyNew = & (* yyNew)->PROC_PARAM.P; break;
  11423. case kFUNC_PARAM: (* yyNew)->FUNC_PARAM = yyt->FUNC_PARAM;
  11424. yyt = yyt->FUNC_PARAM.F;
  11425. yyNew = & (* yyNew)->FUNC_PARAM.F; break;
  11426. case kFORMAT_PARAM: (* yyNew)->FORMAT_PARAM = yyt->FORMAT_PARAM;
  11427. copytStringRef ((* yyNew)->FORMAT_PARAM.S, yyt->FORMAT_PARAM.S)
  11428. return;
  11429. case kRETURN_PARAM: (* yyNew)->RETURN_PARAM = yyt->RETURN_PARAM;
  11430. copyint ((* yyNew)->RETURN_PARAM.label, yyt->RETURN_PARAM.label)
  11431. return;
  11432. case kNO_PARAM: (* yyNew)->NO_PARAM = yyt->NO_PARAM;
  11433. return;
  11434. case kBT_PARAM_LIST: (* yyNew)->BT_PARAM_LIST = yyt->BT_PARAM_LIST;
  11435. return;
  11436. case kBTP_EMPTY: (* yyNew)->BTP_EMPTY = yyt->BTP_EMPTY;
  11437. return;
  11438. case kBTP_LIST: (* yyNew)->BTP_LIST = yyt->BTP_LIST;
  11439. copytTree ((* yyNew)->BTP_LIST.Elem, yyt->BTP_LIST.Elem)
  11440. yyt = yyt->BTP_LIST.Next;
  11441. yyNew = & (* yyNew)->BTP_LIST.Next; break;
  11442. case kCONSTANT: (* yyNew)->CONSTANT = yyt->CONSTANT;
  11443. return;
  11444. case kBOOL_CONSTANT: (* yyNew)->BOOL_CONSTANT = yyt->BOOL_CONSTANT;
  11445. copyint ((* yyNew)->BOOL_CONSTANT.value, yyt->BOOL_CONSTANT.value)
  11446. return;
  11447. case kINT_CONSTANT: (* yyNew)->INT_CONSTANT = yyt->INT_CONSTANT;
  11448. copyint ((* yyNew)->INT_CONSTANT.value, yyt->INT_CONSTANT.value)
  11449. return;
  11450. case kREAL_CONSTANT: (* yyNew)->REAL_CONSTANT = yyt->REAL_CONSTANT;
  11451. copytStringRef ((* yyNew)->REAL_CONSTANT.value, yyt->REAL_CONSTANT.value)
  11452. return;
  11453. case kDREAL_CONSTANT: (* yyNew)->DREAL_CONSTANT = yyt->DREAL_CONSTANT;
  11454. copytStringRef ((* yyNew)->DREAL_CONSTANT.value, yyt->DREAL_CONSTANT.value)
  11455. return;
  11456. case kCHAR_CONSTANT: (* yyNew)->CHAR_CONSTANT = yyt->CHAR_CONSTANT;
  11457. copychar ((* yyNew)->CHAR_CONSTANT.value, yyt->CHAR_CONSTANT.value)
  11458. return;
  11459. case kSTRING_CONSTANT: (* yyNew)->STRING_CONSTANT = yyt->STRING_CONSTANT;
  11460. copytStringRef ((* yyNew)->STRING_CONSTANT.value, yyt->STRING_CONSTANT.value)
  11461. return;
  11462. case kCOMPLEX_CONSTANT: (* yyNew)->COMPLEX_CONSTANT = yyt->COMPLEX_CONSTANT;
  11463. copytStringRef ((* yyNew)->COMPLEX_CONSTANT.rvalue, yyt->COMPLEX_CONSTANT.rvalue)
  11464. copytStringRef ((* yyNew)->COMPLEX_CONSTANT.ivalue, yyt->COMPLEX_CONSTANT.ivalue)
  11465. return;
  11466. case kPROC_OBJ: (* yyNew)->PROC_OBJ = yyt->PROC_OBJ;
  11467. copytIdent ((* yyNew)->PROC_OBJ.Ident, yyt->PROC_OBJ.Ident)
  11468. copytDefinitions ((* yyNew)->PROC_OBJ.Object, yyt->PROC_OBJ.Object)
  11469. return;
  11470. case kVAR_OBJ: (* yyNew)->VAR_OBJ = yyt->VAR_OBJ;
  11471. copyint ((* yyNew)->VAR_OBJ.Pos, yyt->VAR_OBJ.Pos)
  11472. copytIdent ((* yyNew)->VAR_OBJ.Ident, yyt->VAR_OBJ.Ident)
  11473. copytDefinitions ((* yyNew)->VAR_OBJ.Object, yyt->VAR_OBJ.Object)
  11474. return;
  11475. case kTYPE_OBJ: (* yyNew)->TYPE_OBJ = yyt->TYPE_OBJ;
  11476. copytIdent ((* yyNew)->TYPE_OBJ.Ident, yyt->TYPE_OBJ.Ident)
  11477. copytDefinitions ((* yyNew)->TYPE_OBJ.Object, yyt->TYPE_OBJ.Object)
  11478. return;
  11479. case kREC_COMP: (* yyNew)->REC_COMP = yyt->REC_COMP;
  11480. copytIdent ((* yyNew)->REC_COMP.Ident, yyt->REC_COMP.Ident)
  11481. copytDefinitions ((* yyNew)->REC_COMP.Object, yyt->REC_COMP.Object)
  11482. return;
  11483.   default: ;
  11484.   }
  11485.  }
  11486. }
  11487.  
  11488. tTree CopyTree
  11489. # if defined __STDC__ | defined __cplusplus
  11490.  (tTree yyt)
  11491. # else
  11492.  (yyt) tTree yyt;
  11493. # endif
  11494. {
  11495.  tTree yyNew;
  11496.  yyMark (yyt);
  11497.  yyOldToNewCount = 0;
  11498.  yyCopyTree (yyt, & yyNew);
  11499.  return yyNew;
  11500. }
  11501.  
  11502. static bool yyCheckTree ARGS((tTree yyt));
  11503.  
  11504. bool CheckTree
  11505. # if defined __STDC__ | defined __cplusplus
  11506.  (tTree yyt)
  11507. # else
  11508.  (yyt) tTree yyt;
  11509. # endif
  11510. {
  11511.  yyMark (yyt);
  11512.  return yyCheckTree (yyt);
  11513. }
  11514.  
  11515. static bool yyCheckChild
  11516. # if defined __STDC__ | defined __cplusplus
  11517.  (tTree yyParent, tTree yyyChild, Tree_tKind yyType, char * yySelector)
  11518. # else
  11519.  (yyParent, yyyChild, yyType, yySelector)
  11520.  tTree yyParent, yyyChild;
  11521.  Tree_tKind yyType;
  11522.  char * yySelector;
  11523. # endif
  11524. {
  11525.  bool yySuccess = Tree_IsType (yyyChild, yyType);
  11526.  if (! yySuccess) {
  11527.   (void) fputs ("CheckTree: parent = ", stderr);
  11528.   WriteTreeNode (stderr, yyParent);
  11529.   (void) fprintf (stderr, "\nselector: %s child = ", yySelector);
  11530.   WriteTreeNode (stderr, yyyChild);
  11531.   (void) fputc ('\n', stderr);
  11532.  }
  11533.  return yyCheckTree (yyyChild) && yySuccess;
  11534. }
  11535.  
  11536. static bool yyCheckTree
  11537. # if defined __STDC__ | defined __cplusplus
  11538.  (tTree yyt)
  11539. # else
  11540.  (yyt) tTree yyt;
  11541. # endif
  11542. {
  11543.  bool yyResult;
  11544.  if (yyt == NoTree) return false;
  11545.  else if (yyt->yyHead.yyMark == 0) return true;
  11546.  yyt->yyHead.yyMark = 0;
  11547.  
  11548.  yyResult = true;
  11549.  switch (yyt->Kind) {
  11550. case kCOMP_UNIT:
  11551. yyResult = yyCheckChild (yyt, yyt->COMP_UNIT.COMP_ELEMENTS, kDECL_NODE_LIST, "COMP_ELEMENTS") && yyResult;
  11552. break;
  11553. case kBODY_NODE:
  11554. yyResult = yyCheckChild (yyt, yyt->BODY_NODE.DECLS, kDECL_NODE_LIST, "DECLS") && yyResult;
  11555. yyResult = yyCheckChild (yyt, yyt->BODY_NODE.STATS, kACF_NODE_LIST, "STATS") && yyResult;
  11556. yyResult = yyCheckChild (yyt, yyt->BODY_NODE.INTERNALS, kDECL_NODE_LIST, "INTERNALS") && yyResult;
  11557. break;
  11558. case kSTRING_TYPE:
  11559. yyResult = yyCheckChild (yyt, yyt->STRING_TYPE.LENGTH, kBT_EXP, "LENGTH") && yyResult;
  11560. break;
  11561. case kINDEX_TYPE:
  11562. yyResult = yyCheckChild (yyt, yyt->INDEX_TYPE.LOWER, kBT_EXP, "LOWER") && yyResult;
  11563. yyResult = yyCheckChild (yyt, yyt->INDEX_TYPE.UPPER, kBT_EXP, "UPPER") && yyResult;
  11564. break;
  11565. case kTYPE_ID:
  11566. yyResult = yyCheckChild (yyt, yyt->TYPE_ID.ID, kTYPE_OBJ, "ID") && yyResult;
  11567. break;
  11568. case kARRAY_TYPE:
  11569. yyResult = yyCheckChild (yyt, yyt->ARRAY_TYPE.ARRAY_INDEX_TYPES, kTYPE_NODE_LIST, "ARRAY_INDEX_TYPES") && yyResult;
  11570. yyResult = yyCheckChild (yyt, yyt->ARRAY_TYPE.ARRAY_COMP_TYPE, kTYPE_NODE, "ARRAY_COMP_TYPE") && yyResult;
  11571. break;
  11572. case kRECORD_TYPE:
  11573. yyResult = yyCheckChild (yyt, yyt->RECORD_TYPE.COMPONENTS, kDECL_NODE_LIST, "COMPONENTS") && yyResult;
  11574. break;
  11575. case kUNION_TYPE:
  11576. yyResult = yyCheckChild (yyt, yyt->UNION_TYPE.COMPONENTS, kDECL_NODE_LIST, "COMPONENTS") && yyResult;
  11577. break;
  11578. case kENUM_TYPE:
  11579. yyResult = yyCheckChild (yyt, yyt->ENUM_TYPE.COMPONENTS, kDECL_NODE_LIST, "COMPONENTS") && yyResult;
  11580. break;
  11581. case kPOINTER_TYPE:
  11582. yyResult = yyCheckChild (yyt, yyt->POINTER_TYPE.PTR_COMP, kTYPE_NODE, "PTR_COMP") && yyResult;
  11583. break;
  11584. case kARRAY1_TYPE:
  11585. yyResult = yyCheckChild (yyt, yyt->ARRAY1_TYPE.SIZE, kBT_EXP, "SIZE") && yyResult;
  11586. yyResult = yyCheckChild (yyt, yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE, kTYPE_NODE, "ARRAY1_COMP_TYPE") && yyResult;
  11587. break;
  11588. case kFUNCTION_TYPE:
  11589. yyResult = yyCheckChild (yyt, yyt->FUNCTION_TYPE.FORMALS, kDECL_NODE_LIST, "FORMALS") && yyResult;
  11590. yyResult = yyCheckChild (yyt, yyt->FUNCTION_TYPE.RESULT_TYPE, kTYPE_NODE, "RESULT_TYPE") && yyResult;
  11591. break;
  11592. case kTYPE_LIST:
  11593. yyResult = yyCheckChild (yyt, yyt->TYPE_LIST.Elem, kTYPE_NODE, "Elem") && yyResult;
  11594. yyResult = yyCheckChild (yyt, yyt->TYPE_LIST.Next, kTYPE_NODE_LIST, "Next") && yyResult;
  11595. break;
  11596. case kMODULE_DECL:
  11597. yyResult = yyCheckChild (yyt, yyt->MODULE_DECL.MODULE_BODY, kBODY_NODE, "MODULE_BODY") && yyResult;
  11598. break;
  11599. case kPROGRAM_DECL:
  11600. yyResult = yyCheckChild (yyt, yyt->PROGRAM_DECL.FORMALS, kDECL_NODE_LIST, "FORMALS") && yyResult;
  11601. yyResult = yyCheckChild (yyt, yyt->PROGRAM_DECL.PROGRAM_BODY, kBODY_NODE, "PROGRAM_BODY") && yyResult;
  11602. break;
  11603. case kPROC_DECL:
  11604. yyResult = yyCheckChild (yyt, yyt->PROC_DECL.FORMALS, kDECL_NODE_LIST, "FORMALS") && yyResult;
  11605. yyResult = yyCheckChild (yyt, yyt->PROC_DECL.PROC_BODY, kBODY_NODE, "PROC_BODY") && yyResult;
  11606. break;
  11607. case kFUNC_DECL:
  11608. yyResult = yyCheckChild (yyt, yyt->FUNC_DECL.FORMALS, kDECL_NODE_LIST, "FORMALS") && yyResult;
  11609. yyResult = yyCheckChild (yyt, yyt->FUNC_DECL.FUNC_BODY, kBODY_NODE, "FUNC_BODY") && yyResult;
  11610. yyResult = yyCheckChild (yyt, yyt->FUNC_DECL.RESULT_TYPE, kTYPE_NODE, "RESULT_TYPE") && yyResult;
  11611. break;
  11612. case kBLOCK_DATA_DECL:
  11613. yyResult = yyCheckChild (yyt, yyt->BLOCK_DATA_DECL.DATA_BODY, kBODY_NODE, "DATA_BODY") && yyResult;
  11614. break;
  11615. case kTYPE_DECL:
  11616. yyResult = yyCheckChild (yyt, yyt->TYPE_DECL.VAL, kTYPE_NODE, "VAL") && yyResult;
  11617. break;
  11618. case kENTITY_DECL:
  11619. yyResult = yyCheckChild (yyt, yyt->ENTITY_DECL.ATTRIBUTES, kDECL_LIST, "ATTRIBUTES") && yyResult;
  11620. break;
  11621. case kVAR_DECL:
  11622. yyResult = yyCheckChild (yyt, yyt->VAR_DECL.VAL, kTYPE_NODE, "VAL") && yyResult;
  11623. break;
  11624. case kCOMMON_DECL:
  11625. yyResult = yyCheckChild (yyt, yyt->COMMON_DECL.IDS, kDECL_NODE_LIST, "IDS") && yyResult;
  11626. break;
  11627. case kNAMELIST_DECL:
  11628. yyResult = yyCheckChild (yyt, yyt->NAMELIST_DECL.IDS, kDECL_NODE_LIST, "IDS") && yyResult;
  11629. break;
  11630. case kTEMPLATE_DECL:
  11631. yyResult = yyCheckChild (yyt, yyt->TEMPLATE_DECL.DIMENSIONS, kTYPE_NODE_LIST, "DIMENSIONS") && yyResult;
  11632. break;
  11633. case kPROCESSORS_DECL:
  11634. yyResult = yyCheckChild (yyt, yyt->PROCESSORS_DECL.DIMENSIONS, kTYPE_NODE_LIST, "DIMENSIONS") && yyResult;
  11635. break;
  11636. case kSTMT_FUNC_DECL:
  11637. yyResult = yyCheckChild (yyt, yyt->STMT_FUNC_DECL.FORMALS, kDECL_NODE_LIST, "FORMALS") && yyResult;
  11638. yyResult = yyCheckChild (yyt, yyt->STMT_FUNC_DECL.RESULT_TYPE, kTYPE_NODE, "RESULT_TYPE") && yyResult;
  11639. yyResult = yyCheckChild (yyt, yyt->STMT_FUNC_DECL.FFUNC_BODY, kBT_EXP, "FFUNC_BODY") && yyResult;
  11640. break;
  11641. case kINTERFACE_DECL:
  11642. yyResult = yyCheckChild (yyt, yyt->INTERFACE_DECL.SPEC, kGENERIC_SPEC, "SPEC") && yyResult;
  11643. yyResult = yyCheckChild (yyt, yyt->INTERFACE_DECL.ITEMS, kDECL_NODE_LIST, "ITEMS") && yyResult;
  11644. break;
  11645. case kEXT_PROC_DECL:
  11646. yyResult = yyCheckChild (yyt, yyt->EXT_PROC_DECL.FORMALS, kDECL_NODE_LIST, "FORMALS") && yyResult;
  11647. break;
  11648. case kEXT_FUNC_DECL:
  11649. yyResult = yyCheckChild (yyt, yyt->EXT_FUNC_DECL.FORMALS, kDECL_NODE_LIST, "FORMALS") && yyResult;
  11650. yyResult = yyCheckChild (yyt, yyt->EXT_FUNC_DECL.RESULT_TYPE, kTYPE_NODE, "RESULT_TYPE") && yyResult;
  11651. break;
  11652. case kVAL_PARAM_DECL:
  11653. yyResult = yyCheckChild (yyt, yyt->VAL_PARAM_DECL.VAL, kTYPE_NODE, "VAL") && yyResult;
  11654. break;
  11655. case kVAR_PARAM_DECL:
  11656. yyResult = yyCheckChild (yyt, yyt->VAR_PARAM_DECL.VAL, kTYPE_NODE, "VAL") && yyResult;
  11657. break;
  11658. case kPROC_PARAM_DECL:
  11659. yyResult = yyCheckChild (yyt, yyt->PROC_PARAM_DECL.FORMAL, kDECL_NODE_LIST, "FORMAL") && yyResult;
  11660. break;
  11661. case kFUNC_PARAM_DECL:
  11662. yyResult = yyCheckChild (yyt, yyt->FUNC_PARAM_DECL.FORMAL, kDECL_NODE_LIST, "FORMAL") && yyResult;
  11663. yyResult = yyCheckChild (yyt, yyt->FUNC_PARAM_DECL.RESULT_TYPE, kTYPE_NODE, "RESULT_TYPE") && yyResult;
  11664. break;
  11665. case kIMPLICIT_DECL:
  11666. yyResult = yyCheckChild (yyt, yyt->IMPLICIT_DECL.VAL, kTYPE_NODE, "VAL") && yyResult;
  11667. break;
  11668. case kUSE_DECL:
  11669. yyResult = yyCheckChild (yyt, yyt->USE_DECL.RENAMINGS, kDECL_NODE_LIST, "RENAMINGS") && yyResult;
  11670. break;
  11671. case kONLY_USE_DECL:
  11672. yyResult = yyCheckChild (yyt, yyt->ONLY_USE_DECL.NAMES, kDECL_NODE_LIST, "NAMES") && yyResult;
  11673. break;
  11674. case kEQV_DECL:
  11675. yyResult = yyCheckChild (yyt, yyt->EQV_DECL.VARS, kBT_VAR_LIST, "VARS") && yyResult;
  11676. break;
  11677. case kDATA_DECL:
  11678. yyResult = yyCheckChild (yyt, yyt->DATA_DECL.VARS, kBT_VAR_LIST, "VARS") && yyResult;
  11679. yyResult = yyCheckChild (yyt, yyt->DATA_DECL.VALS, kBT_EXP_LIST, "VALS") && yyResult;
  11680. break;
  11681. case kDIMENSION_DECL:
  11682. yyResult = yyCheckChild (yyt, yyt->DIMENSION_DECL.INDEXES, kTYPE_NODE_LIST, "INDEXES") && yyResult;
  11683. break;
  11684. case kINIT_DATA_DECL:
  11685. yyResult = yyCheckChild (yyt, yyt->INIT_DATA_DECL.VAL, kBT_EXP, "VAL") && yyResult;
  11686. break;
  11687. case kTYPESPEC_DECL:
  11688. yyResult = yyCheckChild (yyt, yyt->TYPESPEC_DECL.VAL, kTYPE_NODE, "VAL") && yyResult;
  11689. break;
  11690. case kPARAMETER_DECL:
  11691. yyResult = yyCheckChild (yyt, yyt->PARAMETER_DECL.VAL, kBT_EXP, "VAL") && yyResult;
  11692. break;
  11693. case kDISTRIBUTE_DECL:
  11694. yyResult = yyCheckChild (yyt, yyt->DISTRIBUTE_DECL.DISTRIBUTION, kDISTRIBUTION_SPEC, "DISTRIBUTION") && yyResult;
  11695. break;
  11696. case kALIGN_DECL:
  11697. yyResult = yyCheckChild (yyt, yyt->ALIGN_DECL.ALIGN_SOURCE, kBT_EXP_LIST, "ALIGN_SOURCE") && yyResult;
  11698. yyResult = yyCheckChild (yyt, yyt->ALIGN_DECL.ALIGN_SPEC, kBT_VAR, "ALIGN_SPEC") && yyResult;
  11699. break;
  11700. case kDECL_LIST:
  11701. yyResult = yyCheckChild (yyt, yyt->DECL_LIST.Elem, kDECL_NODE, "Elem") && yyResult;
  11702. yyResult = yyCheckChild (yyt, yyt->DECL_LIST.Next, kDECL_NODE_LIST, "Next") && yyResult;
  11703. break;
  11704. case kNODE_DISTRIBUTION:
  11705. yyResult = yyCheckChild (yyt, yyt->NODE_DISTRIBUTION.MAPPING, kDIST_FORMAT_LIST, "MAPPING") && yyResult;
  11706. break;
  11707. case kBLOCK_DISTRIBUTION:
  11708. yyResult = yyCheckChild (yyt, yyt->BLOCK_DISTRIBUTION.SIZE, kBT_EXP, "SIZE") && yyResult;
  11709. break;
  11710. case kCYCLIC_DISTRIBUTION:
  11711. yyResult = yyCheckChild (yyt, yyt->CYCLIC_DISTRIBUTION.SIZE, kBT_EXP, "SIZE") && yyResult;
  11712. break;
  11713. case kDIST_LIST:
  11714. yyResult = yyCheckChild (yyt, yyt->DIST_LIST.Elem, kDISTRIBUTION_FORMAT, "Elem") && yyResult;
  11715. yyResult = yyCheckChild (yyt, yyt->DIST_LIST.Next, kDIST_FORMAT_LIST, "Next") && yyResult;
  11716. break;
  11717. case kOP_GENERIC_SPEC:
  11718. yyResult = yyCheckChild (yyt, yyt->OP_GENERIC_SPEC.OPERATOR, kOP, "OPERATOR") && yyResult;
  11719. break;
  11720. case kACF_LIST:
  11721. yyResult = yyCheckChild (yyt, yyt->ACF_LIST.Elem, kACF_NODE, "Elem") && yyResult;
  11722. yyResult = yyCheckChild (yyt, yyt->ACF_LIST.Next, kACF_NODE_LIST, "Next") && yyResult;
  11723. break;
  11724. case kACF_BASIC:
  11725. yyResult = yyCheckChild (yyt, yyt->ACF_BASIC.BASIC_STMT, kBT_STMT, "BASIC_STMT") && yyResult;
  11726. break;
  11727. case kACF_IF:
  11728. yyResult = yyCheckChild (yyt, yyt->ACF_IF.IF_EXP, kBT_EXP, "IF_EXP") && yyResult;
  11729. yyResult = yyCheckChild (yyt, yyt->ACF_IF.THEN_PART, kACF_NODE_LIST, "THEN_PART") && yyResult;
  11730. yyResult = yyCheckChild (yyt, yyt->ACF_IF.ELSE_PART, kACF_NODE_LIST, "ELSE_PART") && yyResult;
  11731. break;
  11732. case kACF_WHERE:
  11733. yyResult = yyCheckChild (yyt, yyt->ACF_WHERE.WHERE_EXP, kBT_EXP, "WHERE_EXP") && yyResult;
  11734. yyResult = yyCheckChild (yyt, yyt->ACF_WHERE.TRUE_PART, kACF_NODE_LIST, "TRUE_PART") && yyResult;
  11735. yyResult = yyCheckChild (yyt, yyt->ACF_WHERE.FALSE_PART, kACF_NODE_LIST, "FALSE_PART") && yyResult;
  11736. break;
  11737. case kACF_SWITCH:
  11738. yyResult = yyCheckChild (yyt, yyt->ACF_SWITCH.SWITCH_EXP, kBT_EXP, "SWITCH_EXP") && yyResult;
  11739. yyResult = yyCheckChild (yyt, yyt->ACF_SWITCH.SWITCH_STMT, kACF_NODE, "SWITCH_STMT") && yyResult;
  11740. break;
  11741. case kACF_ALTER:
  11742. yyResult = yyCheckChild (yyt, yyt->ACF_ALTER.ALTER_EXP, kBT_EXP, "ALTER_EXP") && yyResult;
  11743. yyResult = yyCheckChild (yyt, yyt->ACF_ALTER.ALTER_STMT, kACF_NODE, "ALTER_STMT") && yyResult;
  11744. break;
  11745. case kACF_CASE:
  11746. yyResult = yyCheckChild (yyt, yyt->ACF_CASE.CASE_EXP, kBT_EXP, "CASE_EXP") && yyResult;
  11747. yyResult = yyCheckChild (yyt, yyt->ACF_CASE.CASE_ALTS, kSELECTED_ACF_NODE_LIST, "CASE_ALTS") && yyResult;
  11748. yyResult = yyCheckChild (yyt, yyt->ACF_CASE.CASE_OTHERWISE, kACF_NODE_LIST, "CASE_OTHERWISE") && yyResult;
  11749. break;
  11750. case kACF_WHILE:
  11751. yyResult = yyCheckChild (yyt, yyt->ACF_WHILE.WHILE_EXP, kBT_EXP, "WHILE_EXP") && yyResult;
  11752. yyResult = yyCheckChild (yyt, yyt->ACF_WHILE.WHILE_BODY, kACF_NODE_LIST, "WHILE_BODY") && yyResult;
  11753. break;
  11754. case kACF_REPEAT:
  11755. yyResult = yyCheckChild (yyt, yyt->ACF_REPEAT.REPEAT_BODY, kACF_NODE_LIST, "REPEAT_BODY") && yyResult;
  11756. yyResult = yyCheckChild (yyt, yyt->ACF_REPEAT.REPEAT_EXP, kBT_EXP, "REPEAT_EXP") && yyResult;
  11757. break;
  11758. case kACF_WITH:
  11759. yyResult = yyCheckChild (yyt, yyt->ACF_WITH.WITH_VARS, kBT_VAR_LIST, "WITH_VARS") && yyResult;
  11760. yyResult = yyCheckChild (yyt, yyt->ACF_WITH.WITH_BODY, kACF_NODE_LIST, "WITH_BODY") && yyResult;
  11761. break;
  11762. case kACF_LOOP:
  11763. yyResult = yyCheckChild (yyt, yyt->ACF_LOOP.LOOP_BODY, kACF_NODE_LIST, "LOOP_BODY") && yyResult;
  11764. break;
  11765. case kACF_DO:
  11766. yyResult = yyCheckChild (yyt, yyt->ACF_DO.DO_ID, kBT_VAR, "DO_ID") && yyResult;
  11767. yyResult = yyCheckChild (yyt, yyt->ACF_DO.DO_RANGE, kSLICE_EXP, "DO_RANGE") && yyResult;
  11768. yyResult = yyCheckChild (yyt, yyt->ACF_DO.DO_BODY, kACF_NODE_LIST, "DO_BODY") && yyResult;
  11769. break;
  11770. case kACF_DOLOCAL:
  11771. yyResult = yyCheckChild (yyt, yyt->ACF_DOLOCAL.DOLOCAL_ID, kBT_VAR, "DOLOCAL_ID") && yyResult;
  11772. yyResult = yyCheckChild (yyt, yyt->ACF_DOLOCAL.DOLOCAL_RANGE, kSLICE_EXP, "DOLOCAL_RANGE") && yyResult;
  11773. yyResult = yyCheckChild (yyt, yyt->ACF_DOLOCAL.DOLOCAL_BODY, kACF_NODE_LIST, "DOLOCAL_BODY") && yyResult;
  11774. break;
  11775. case kACF_DOVEC:
  11776. yyResult = yyCheckChild (yyt, yyt->ACF_DOVEC.DOVEC_ID, kBT_VAR, "DOVEC_ID") && yyResult;
  11777. yyResult = yyCheckChild (yyt, yyt->ACF_DOVEC.DOVEC_RANGE, kSLICE_EXP, "DOVEC_RANGE") && yyResult;
  11778. yyResult = yyCheckChild (yyt, yyt->ACF_DOVEC.DOVEC_BODY, kACF_NODE_LIST, "DOVEC_BODY") && yyResult;
  11779. break;
  11780. case kACF_DOALL:
  11781. yyResult = yyCheckChild (yyt, yyt->ACF_DOALL.DOALL_NEW, kBT_VAR_LIST, "DOALL_NEW") && yyResult;
  11782. yyResult = yyCheckChild (yyt, yyt->ACF_DOALL.DOALL_ID, kBT_VAR, "DOALL_ID") && yyResult;
  11783. yyResult = yyCheckChild (yyt, yyt->ACF_DOALL.DOALL_RANGE, kSLICE_EXP, "DOALL_RANGE") && yyResult;
  11784. yyResult = yyCheckChild (yyt, yyt->ACF_DOALL.DOALL_BODY, kACF_NODE_LIST, "DOALL_BODY") && yyResult;
  11785. break;
  11786. case kACF_FORALL:
  11787. yyResult = yyCheckChild (yyt, yyt->ACF_FORALL.FORALL_ID, kBT_VAR, "FORALL_ID") && yyResult;
  11788. yyResult = yyCheckChild (yyt, yyt->ACF_FORALL.FORALL_RANGE, kSLICE_EXP, "FORALL_RANGE") && yyResult;
  11789. yyResult = yyCheckChild (yyt, yyt->ACF_FORALL.FORALL_BODY, kACF_NODE_LIST, "FORALL_BODY") && yyResult;
  11790. break;
  11791. case kACF_ON:
  11792. yyResult = yyCheckChild (yyt, yyt->ACF_ON.ON_VAR, kBT_VAR, "ON_VAR") && yyResult;
  11793. yyResult = yyCheckChild (yyt, yyt->ACF_ON.ON_STMT, kACF_NODE, "ON_STMT") && yyResult;
  11794. break;
  11795. case kACF_BODY:
  11796. yyResult = yyCheckChild (yyt, yyt->ACF_BODY.NEW_BODY, kBODY_NODE, "NEW_BODY") && yyResult;
  11797. break;
  11798. case kACF_FLOW_GRAPH:
  11799. yyResult = yyCheckChild (yyt, yyt->ACF_FLOW_GRAPH.FLOW_NODES, kACF_NODE_LIST, "FLOW_NODES") && yyResult;
  11800. break;
  11801. case kACF_ENTRY:
  11802. yyResult = yyCheckChild (yyt, yyt->ACF_ENTRY.ENTRY_DECL, kDECL_NODE, "ENTRY_DECL") && yyResult;
  11803. break;
  11804. case kSELECTED_ACF_LIST:
  11805. yyResult = yyCheckChild (yyt, yyt->SELECTED_ACF_LIST.Elem, kSELECTED_ACF_NODE, "Elem") && yyResult;
  11806. yyResult = yyCheckChild (yyt, yyt->SELECTED_ACF_LIST.Next, kSELECTED_ACF_NODE_LIST, "Next") && yyResult;
  11807. break;
  11808. case kSELECTED_ACF_NODE:
  11809. yyResult = yyCheckChild (yyt, yyt->SELECTED_ACF_NODE.SELECT_LIST, kBT_EXP_LIST, "SELECT_LIST") && yyResult;
  11810. yyResult = yyCheckChild (yyt, yyt->SELECTED_ACF_NODE.SELECT_ACFS, kACF_NODE_LIST, "SELECT_ACFS") && yyResult;
  11811. break;
  11812. case kEXP_STMT:
  11813. yyResult = yyCheckChild (yyt, yyt->EXP_STMT.STMT_EXP, kBT_EXP, "STMT_EXP") && yyResult;
  11814. break;
  11815. case kASSIGN_STMT:
  11816. yyResult = yyCheckChild (yyt, yyt->ASSIGN_STMT.ASSIGN_VAR, kBT_VAR, "ASSIGN_VAR") && yyResult;
  11817. yyResult = yyCheckChild (yyt, yyt->ASSIGN_STMT.ASSIGN_EXP, kBT_EXP, "ASSIGN_EXP") && yyResult;
  11818. break;
  11819. case kPTR_ASSIGN_STMT:
  11820. yyResult = yyCheckChild (yyt, yyt->PTR_ASSIGN_STMT.ASSIGN_VAR, kBT_VAR, "ASSIGN_VAR") && yyResult;
  11821. yyResult = yyCheckChild (yyt, yyt->PTR_ASSIGN_STMT.ASSIGN_EXP, kBT_EXP, "ASSIGN_EXP") && yyResult;
  11822. break;
  11823. case kLABEL_ASSIGN_STMT:
  11824. yyResult = yyCheckChild (yyt, yyt->LABEL_ASSIGN_STMT.LABEL_VAR, kBT_VAR, "LABEL_VAR") && yyResult;
  11825. break;
  11826. case kCALL_STMT:
  11827. yyResult = yyCheckChild (yyt, yyt->CALL_STMT.CALL_ID, kPROC_OBJ, "CALL_ID") && yyResult;
  11828. yyResult = yyCheckChild (yyt, yyt->CALL_STMT.CALL_PARAMS, kBT_PARAM_LIST, "CALL_PARAMS") && yyResult;
  11829. break;
  11830. case kIO_STMT:
  11831. yyResult = yyCheckChild (yyt, yyt->IO_STMT.ID, kPROC_OBJ, "ID") && yyResult;
  11832. yyResult = yyCheckChild (yyt, yyt->IO_STMT.IO_SPECS, kBT_PARAM_LIST, "IO_SPECS") && yyResult;
  11833. yyResult = yyCheckChild (yyt, yyt->IO_STMT.IO_ITEMS, kBT_PARAM_LIST, "IO_ITEMS") && yyResult;
  11834. break;
  11835. case kASS_GOTO_STMT:
  11836. yyResult = yyCheckChild (yyt, yyt->ASS_GOTO_STMT.GOTO_VAR, kBT_VAR, "GOTO_VAR") && yyResult;
  11837. yyResult = yyCheckChild (yyt, yyt->ASS_GOTO_STMT.LABELS, kLABEL_USE_LIST, "LABELS") && yyResult;
  11838. break;
  11839. case kCOMP_GOTO_STMT:
  11840. yyResult = yyCheckChild (yyt, yyt->COMP_GOTO_STMT.GOTO_LABELS, kLABEL_USE_LIST, "GOTO_LABELS") && yyResult;
  11841. yyResult = yyCheckChild (yyt, yyt->COMP_GOTO_STMT.GOTO_EXP, kBT_EXP, "GOTO_EXP") && yyResult;
  11842. break;
  11843. case kCOMP_IF_STMT:
  11844. yyResult = yyCheckChild (yyt, yyt->COMP_IF_STMT.IF_EXP, kBT_EXP, "IF_EXP") && yyResult;
  11845. break;
  11846. case kRETURN_STMT:
  11847. yyResult = yyCheckChild (yyt, yyt->RETURN_STMT.RETURN_EXP, kBT_EXP, "RETURN_EXP") && yyResult;
  11848. break;
  11849. case kPAUSE_STMT:
  11850. yyResult = yyCheckChild (yyt, yyt->PAUSE_STMT.PAUSE_CONST, kCONSTANT, "PAUSE_CONST") && yyResult;
  11851. break;
  11852. case kSTOP_STMT:
  11853. yyResult = yyCheckChild (yyt, yyt->STOP_STMT.STOP_CONST, kBT_EXP, "STOP_CONST") && yyResult;
  11854. break;
  11855. case kFORMAT_STMT:
  11856. yyResult = yyCheckChild (yyt, yyt->FORMAT_STMT.FORMAT_PARAMS, kBT_PARAM_LIST, "FORMAT_PARAMS") && yyResult;
  11857. break;
  11858. case kALLOCATE_STMT:
  11859. yyResult = yyCheckChild (yyt, yyt->ALLOCATE_STMT.PARAMS, kBT_PARAM_LIST, "PARAMS") && yyResult;
  11860. yyResult = yyCheckChild (yyt, yyt->ALLOCATE_STMT.STAT, kBT_VAR, "STAT") && yyResult;
  11861. break;
  11862. case kDEALLOCATE_STMT:
  11863. yyResult = yyCheckChild (yyt, yyt->DEALLOCATE_STMT.PARAMS, kBT_PARAM_LIST, "PARAMS") && yyResult;
  11864. yyResult = yyCheckChild (yyt, yyt->DEALLOCATE_STMT.STAT, kBT_VAR, "STAT") && yyResult;
  11865. break;
  11866. case kNULLIFY_STMT:
  11867. yyResult = yyCheckChild (yyt, yyt->NULLIFY_STMT.PARAMS, kBT_PARAM_LIST, "PARAMS") && yyResult;
  11868. break;
  11869. case kREDUCE_STMT:
  11870. yyResult = yyCheckChild (yyt, yyt->REDUCE_STMT.RED_FUNC, kPROC_OBJ, "RED_FUNC") && yyResult;
  11871. yyResult = yyCheckChild (yyt, yyt->REDUCE_STMT.RED_PARAMS, kBT_PARAM_LIST, "RED_PARAMS") && yyResult;
  11872. break;
  11873. case kGLOBAL_STMT:
  11874. yyResult = yyCheckChild (yyt, yyt->GLOBAL_STMT.ARRAY, kBT_PARAM, "ARRAY") && yyResult;
  11875. yyResult = yyCheckChild (yyt, yyt->GLOBAL_STMT.INDEXED_ARRAY, kBT_PARAM, "INDEXED_ARRAY") && yyResult;
  11876. yyResult = yyCheckChild (yyt, yyt->GLOBAL_STMT.INDEXES, kBT_PARAM_LIST, "INDEXES") && yyResult;
  11877. yyResult = yyCheckChild (yyt, yyt->GLOBAL_STMT.MASK, kBT_PARAM, "MASK") && yyResult;
  11878. break;
  11879. case kALIGN_STMT:
  11880. yyResult = yyCheckChild (yyt, yyt->ALIGN_STMT.ALIGNEE, kBT_VAR, "ALIGNEE") && yyResult;
  11881. yyResult = yyCheckChild (yyt, yyt->ALIGN_STMT.ALIGN_SPEC, kBT_VAR, "ALIGN_SPEC") && yyResult;
  11882. break;
  11883. case kDISTRIBUTE_STMT:
  11884. yyResult = yyCheckChild (yyt, yyt->DISTRIBUTE_STMT.DISTRIBUTEE, kBT_VAR, "DISTRIBUTEE") && yyResult;
  11885. yyResult = yyCheckChild (yyt, yyt->DISTRIBUTE_STMT.DISTRIBUTION, kDISTRIBUTION_SPEC, "DISTRIBUTION") && yyResult;
  11886. break;
  11887. case kLABEL_LIST:
  11888. yyResult = yyCheckChild (yyt, yyt->LABEL_LIST.Next, kLABEL_USE_LIST, "Next") && yyResult;
  11889. break;
  11890. case kCONST_EXP:
  11891. yyResult = yyCheckChild (yyt, yyt->CONST_EXP.C, kCONSTANT, "C") && yyResult;
  11892. break;
  11893. case kOP_EXP:
  11894. yyResult = yyCheckChild (yyt, yyt->OP_EXP.EXP_OP, kOP, "EXP_OP") && yyResult;
  11895. yyResult = yyCheckChild (yyt, yyt->OP_EXP.OPND1, kBT_EXP, "OPND1") && yyResult;
  11896. yyResult = yyCheckChild (yyt, yyt->OP_EXP.OPND2, kBT_EXP, "OPND2") && yyResult;
  11897. break;
  11898. case kOP1_EXP:
  11899. yyResult = yyCheckChild (yyt, yyt->OP1_EXP.EXP_OP1, kOP, "EXP_OP1") && yyResult;
  11900. yyResult = yyCheckChild (yyt, yyt->OP1_EXP.OPND, kBT_EXP, "OPND") && yyResult;
  11901. break;
  11902. case kSLICE_EXP:
  11903. yyResult = yyCheckChild (yyt, yyt->SLICE_EXP.START, kBT_EXP, "START") && yyResult;
  11904. yyResult = yyCheckChild (yyt, yyt->SLICE_EXP.STOP, kBT_EXP, "STOP") && yyResult;
  11905. yyResult = yyCheckChild (yyt, yyt->SLICE_EXP.INC, kBT_EXP, "INC") && yyResult;
  11906. break;
  11907. case kPOSTFIX_EXP:
  11908. yyResult = yyCheckChild (yyt, yyt->POSTFIX_EXP.POSTFIX_OP, kOP, "POSTFIX_OP") && yyResult;
  11909. yyResult = yyCheckChild (yyt, yyt->POSTFIX_EXP.OPND, kBT_EXP, "OPND") && yyResult;
  11910. break;
  11911. case kCALL_EXP:
  11912. yyResult = yyCheckChild (yyt, yyt->CALL_EXP.FUNC_ID, kBT_EXP, "FUNC_ID") && yyResult;
  11913. yyResult = yyCheckChild (yyt, yyt->CALL_EXP.FUNC_PARAMS, kBT_PARAM_LIST, "FUNC_PARAMS") && yyResult;
  11914. break;
  11915. case kCAST_EXP:
  11916. yyResult = yyCheckChild (yyt, yyt->CAST_EXP.ID, kTYPE_NODE, "ID") && yyResult;
  11917. yyResult = yyCheckChild (yyt, yyt->CAST_EXP.CAST, kBT_EXP, "CAST") && yyResult;
  11918. break;
  11919. case kINDEXED_EXP:
  11920. yyResult = yyCheckChild (yyt, yyt->INDEXED_EXP.IND_EXP, kBT_EXP, "IND_EXP") && yyResult;
  11921. yyResult = yyCheckChild (yyt, yyt->INDEXED_EXP.INDEX, kBT_EXP, "INDEX") && yyResult;
  11922. break;
  11923. case kSELECTED_EXP:
  11924. yyResult = yyCheckChild (yyt, yyt->SELECTED_EXP.SELEC_EXP, kBT_EXP, "SELEC_EXP") && yyResult;
  11925. yyResult = yyCheckChild (yyt, yyt->SELECTED_EXP.SELECTOR, kREC_COMP, "SELECTOR") && yyResult;
  11926. break;
  11927. case kASSIGN_EXP:
  11928. yyResult = yyCheckChild (yyt, yyt->ASSIGN_EXP.ASSIGN_OP, kOP, "ASSIGN_OP") && yyResult;
  11929. yyResult = yyCheckChild (yyt, yyt->ASSIGN_EXP.LHS, kBT_EXP, "LHS") && yyResult;
  11930. yyResult = yyCheckChild (yyt, yyt->ASSIGN_EXP.RHS, kBT_EXP, "RHS") && yyResult;
  11931. break;
  11932. case kUSED_EXP:
  11933. yyResult = yyCheckChild (yyt, yyt->USED_EXP.VARNAME, kVAR_OBJ, "VARNAME") && yyResult;
  11934. break;
  11935. case kCOND_EXP:
  11936. yyResult = yyCheckChild (yyt, yyt->COND_EXP.COND, kBT_EXP, "COND") && yyResult;
  11937. yyResult = yyCheckChild (yyt, yyt->COND_EXP.TRUE_EXP, kBT_EXP, "TRUE_EXP") && yyResult;
  11938. yyResult = yyCheckChild (yyt, yyt->COND_EXP.FALSE_EXP, kBT_EXP, "FALSE_EXP") && yyResult;
  11939. break;
  11940. case kVAR_EXP:
  11941. yyResult = yyCheckChild (yyt, yyt->VAR_EXP.V, kBT_VAR, "V") && yyResult;
  11942. break;
  11943. case kFUNC_CALL_EXP:
  11944. yyResult = yyCheckChild (yyt, yyt->FUNC_CALL_EXP.FUNC_ID, kPROC_OBJ, "FUNC_ID") && yyResult;
  11945. yyResult = yyCheckChild (yyt, yyt->FUNC_CALL_EXP.FUNC_PARAMS, kBT_PARAM_LIST, "FUNC_PARAMS") && yyResult;
  11946. break;
  11947. case kNAMED_EXP:
  11948. yyResult = yyCheckChild (yyt, yyt->NAMED_EXP.VAL, kBT_EXP, "VAL") && yyResult;
  11949. break;
  11950. case kDO_EXP:
  11951. yyResult = yyCheckChild (yyt, yyt->DO_EXP.DO_ID, kBT_VAR, "DO_ID") && yyResult;
  11952. yyResult = yyCheckChild (yyt, yyt->DO_EXP.RANGE, kSLICE_EXP, "RANGE") && yyResult;
  11953. yyResult = yyCheckChild (yyt, yyt->DO_EXP.BODY, kBT_EXP_LIST, "BODY") && yyResult;
  11954. break;
  11955. case kTYPE_EXP:
  11956. yyResult = yyCheckChild (yyt, yyt->TYPE_EXP.ID, kTYPE_OBJ, "ID") && yyResult;
  11957. yyResult = yyCheckChild (yyt, yyt->TYPE_EXP.ELEMENTS, kBT_EXP_LIST, "ELEMENTS") && yyResult;
  11958. break;
  11959. case kARRAY_EXP:
  11960. yyResult = yyCheckChild (yyt, yyt->ARRAY_EXP.ELEMENTS, kBT_EXP_LIST, "ELEMENTS") && yyResult;
  11961. break;
  11962. case kBTE_LIST:
  11963. yyResult = yyCheckChild (yyt, yyt->BTE_LIST.Elem, kBT_EXP, "Elem") && yyResult;
  11964. yyResult = yyCheckChild (yyt, yyt->BTE_LIST.Next, kBT_EXP_LIST, "Next") && yyResult;
  11965. break;
  11966. case kUSED_VAR:
  11967. yyResult = yyCheckChild (yyt, yyt->USED_VAR.VARNAME, kVAR_OBJ, "VARNAME") && yyResult;
  11968. break;
  11969. case kINDEXED_VAR:
  11970. yyResult = yyCheckChild (yyt, yyt->INDEXED_VAR.IND_VAR, kBT_VAR, "IND_VAR") && yyResult;
  11971. yyResult = yyCheckChild (yyt, yyt->INDEXED_VAR.IND_EXPS, kBT_EXP_LIST, "IND_EXPS") && yyResult;
  11972. break;
  11973. case kSUBSTRING_VAR:
  11974. yyResult = yyCheckChild (yyt, yyt->SUBSTRING_VAR.IND_VAR, kBT_VAR, "IND_VAR") && yyResult;
  11975. yyResult = yyCheckChild (yyt, yyt->SUBSTRING_VAR.IND_EXP, kBT_EXP, "IND_EXP") && yyResult;
  11976. break;
  11977. case kSELECTED_VAR:
  11978. yyResult = yyCheckChild (yyt, yyt->SELECTED_VAR.SELEC_VAR, kBT_VAR, "SELEC_VAR") && yyResult;
  11979. yyResult = yyCheckChild (yyt, yyt->SELECTED_VAR.SELECTOR, kREC_COMP, "SELECTOR") && yyResult;
  11980. break;
  11981. case kLOOP_VAR:
  11982. yyResult = yyCheckChild (yyt, yyt->LOOP_VAR.LOOP_VARNAME, kVAR_OBJ, "LOOP_VARNAME") && yyResult;
  11983. break;
  11984. case kADDR:
  11985. yyResult = yyCheckChild (yyt, yyt->ADDR.E, kBT_EXP, "E") && yyResult;
  11986. break;
  11987. case kDO_VAR:
  11988. yyResult = yyCheckChild (yyt, yyt->DO_VAR.DO_ID, kBT_VAR, "DO_ID") && yyResult;
  11989. yyResult = yyCheckChild (yyt, yyt->DO_VAR.RANGE, kSLICE_EXP, "RANGE") && yyResult;
  11990. yyResult = yyCheckChild (yyt, yyt->DO_VAR.BODY, kBT_VAR_LIST, "BODY") && yyResult;
  11991. break;
  11992. case kBTV_LIST:
  11993. yyResult = yyCheckChild (yyt, yyt->BTV_LIST.Elem, kBT_VAR, "Elem") && yyResult;
  11994. yyResult = yyCheckChild (yyt, yyt->BTV_LIST.Next, kBT_VAR_LIST, "Next") && yyResult;
  11995. break;
  11996. case kVAR_PARAM:
  11997. yyResult = yyCheckChild (yyt, yyt->VAR_PARAM.V, kBT_VAR, "V") && yyResult;
  11998. break;
  11999. case kVALUE_PARAM:
  12000. yyResult = yyCheckChild (yyt, yyt->VALUE_PARAM.E, kBT_EXP, "E") && yyResult;
  12001. break;
  12002. case kNAMED_PARAM:
  12003. yyResult = yyCheckChild (yyt, yyt->NAMED_PARAM.VAL, kBT_PARAM, "VAL") && yyResult;
  12004. break;
  12005. case kPROC_PARAM:
  12006. yyResult = yyCheckChild (yyt, yyt->PROC_PARAM.P, kPROC_OBJ, "P") && yyResult;
  12007. break;
  12008. case kFUNC_PARAM:
  12009. yyResult = yyCheckChild (yyt, yyt->FUNC_PARAM.F, kPROC_OBJ, "F") && yyResult;
  12010. break;
  12011. case kBTP_LIST:
  12012. yyResult = yyCheckChild (yyt, yyt->BTP_LIST.Elem, kBT_PARAM, "Elem") && yyResult;
  12013. yyResult = yyCheckChild (yyt, yyt->BTP_LIST.Next, kBT_PARAM_LIST, "Next") && yyResult;
  12014. break;
  12015.  default: ;
  12016.  }
  12017.  return yyResult;
  12018. }
  12019.  
  12020. void InitTree
  12021. # if defined __STDC__ | defined __cplusplus
  12022.  (register tTree yyt)
  12023. # else
  12024.  (yyt) register tTree yyt;
  12025. # endif
  12026. {
  12027.  register tTree yyr;
  12028.  for (;;) {
  12029.   yyt->yyHead.yyIsComp0 = 0;
  12030.   yyt->yyHead.yyIsDone0 = 0;
  12031.   switch (yyt->Kind) {
  12032. case kCOMP_UNIT:
  12033. yyr = yyt->COMP_UNIT.COMP_ELEMENTS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12034. yyt = yyt->COMP_UNIT.COMP_ELEMENTS; break;
  12035. case kBODY_NODE:
  12036. yyr = yyt->BODY_NODE.DECLS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12037. InitTree (yyr);
  12038. yyr = yyt->BODY_NODE.STATS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12039. InitTree (yyr);
  12040. yyr = yyt->BODY_NODE.INTERNALS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12041. yyt = yyt->BODY_NODE.INTERNALS; break;
  12042. case kSTRING_TYPE:
  12043. yyr = yyt->STRING_TYPE.LENGTH; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12044. yyt = yyt->STRING_TYPE.LENGTH; break;
  12045. case kINDEX_TYPE:
  12046. yyr = yyt->INDEX_TYPE.LOWER; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12047. InitTree (yyr);
  12048. yyr = yyt->INDEX_TYPE.UPPER; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12049. yyt = yyt->INDEX_TYPE.UPPER; break;
  12050. case kTYPE_ID:
  12051. yyr = yyt->TYPE_ID.ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12052. yyt = yyt->TYPE_ID.ID; break;
  12053. case kARRAY_TYPE:
  12054. yyr = yyt->ARRAY_TYPE.ARRAY_INDEX_TYPES; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12055. InitTree (yyr);
  12056. yyr = yyt->ARRAY_TYPE.ARRAY_COMP_TYPE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12057. yyt = yyt->ARRAY_TYPE.ARRAY_COMP_TYPE; break;
  12058. case kRECORD_TYPE:
  12059. yyr = yyt->RECORD_TYPE.COMPONENTS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12060. yyt = yyt->RECORD_TYPE.COMPONENTS; break;
  12061. case kUNION_TYPE:
  12062. yyr = yyt->UNION_TYPE.COMPONENTS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12063. yyt = yyt->UNION_TYPE.COMPONENTS; break;
  12064. case kENUM_TYPE:
  12065. yyr = yyt->ENUM_TYPE.COMPONENTS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12066. yyt = yyt->ENUM_TYPE.COMPONENTS; break;
  12067. case kPOINTER_TYPE:
  12068. yyr = yyt->POINTER_TYPE.PTR_COMP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12069. yyt = yyt->POINTER_TYPE.PTR_COMP; break;
  12070. case kARRAY1_TYPE:
  12071. yyr = yyt->ARRAY1_TYPE.SIZE; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12072. InitTree (yyr);
  12073. yyr = yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12074. yyt = yyt->ARRAY1_TYPE.ARRAY1_COMP_TYPE; break;
  12075. case kFUNCTION_TYPE:
  12076. yyr = yyt->FUNCTION_TYPE.FORMALS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12077. InitTree (yyr);
  12078. yyr = yyt->FUNCTION_TYPE.RESULT_TYPE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12079. yyt = yyt->FUNCTION_TYPE.RESULT_TYPE; break;
  12080. case kTYPE_LIST:
  12081. yyr = yyt->TYPE_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12082. InitTree (yyr);
  12083. yyr = yyt->TYPE_LIST.Next; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12084. yyt = yyt->TYPE_LIST.Next; break;
  12085. case kMODULE_DECL:
  12086. yyr = yyt->MODULE_DECL.MODULE_BODY; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12087. yyt = yyt->MODULE_DECL.MODULE_BODY; break;
  12088. case kPROGRAM_DECL:
  12089. yyr = yyt->PROGRAM_DECL.FORMALS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12090. InitTree (yyr);
  12091. yyr = yyt->PROGRAM_DECL.PROGRAM_BODY; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12092. yyt = yyt->PROGRAM_DECL.PROGRAM_BODY; break;
  12093. case kPROC_DECL:
  12094. yyr = yyt->PROC_DECL.FORMALS; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12095. InitTree (yyr);
  12096. yyr = yyt->PROC_DECL.PROC_BODY; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12097. yyt = yyt->PROC_DECL.PROC_BODY; break;
  12098. case kFUNC_DECL:
  12099. yyr = yyt->FUNC_DECL.FORMALS; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12100. InitTree (yyr);
  12101. yyr = yyt->FUNC_DECL.FUNC_BODY; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12102. InitTree (yyr);
  12103. yyr = yyt->FUNC_DECL.RESULT_TYPE; yyr->yyHead.yyOffset = 6; yyr->yyHead.yyParent = yyt;
  12104. yyt = yyt->FUNC_DECL.RESULT_TYPE; break;
  12105. case kBLOCK_DATA_DECL:
  12106. yyr = yyt->BLOCK_DATA_DECL.DATA_BODY; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12107. yyt = yyt->BLOCK_DATA_DECL.DATA_BODY; break;
  12108. case kTYPE_DECL:
  12109. yyr = yyt->TYPE_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12110. yyt = yyt->TYPE_DECL.VAL; break;
  12111. case kENTITY_DECL:
  12112. yyr = yyt->ENTITY_DECL.ATTRIBUTES; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12113. yyt = yyt->ENTITY_DECL.ATTRIBUTES; break;
  12114. case kVAR_DECL:
  12115. yyr = yyt->VAR_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12116. yyt = yyt->VAR_DECL.VAL; break;
  12117. case kCOMMON_DECL:
  12118. yyr = yyt->COMMON_DECL.IDS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12119. yyt = yyt->COMMON_DECL.IDS; break;
  12120. case kNAMELIST_DECL:
  12121. yyr = yyt->NAMELIST_DECL.IDS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12122. yyt = yyt->NAMELIST_DECL.IDS; break;
  12123. case kTEMPLATE_DECL:
  12124. yyr = yyt->TEMPLATE_DECL.DIMENSIONS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12125. yyt = yyt->TEMPLATE_DECL.DIMENSIONS; break;
  12126. case kPROCESSORS_DECL:
  12127. yyr = yyt->PROCESSORS_DECL.DIMENSIONS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12128. yyt = yyt->PROCESSORS_DECL.DIMENSIONS; break;
  12129. case kSTMT_FUNC_DECL:
  12130. yyr = yyt->STMT_FUNC_DECL.FORMALS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12131. InitTree (yyr);
  12132. yyr = yyt->STMT_FUNC_DECL.RESULT_TYPE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12133. InitTree (yyr);
  12134. yyr = yyt->STMT_FUNC_DECL.FFUNC_BODY; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12135. yyt = yyt->STMT_FUNC_DECL.FFUNC_BODY; break;
  12136. case kINTERFACE_DECL:
  12137. yyr = yyt->INTERFACE_DECL.SPEC; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12138. InitTree (yyr);
  12139. yyr = yyt->INTERFACE_DECL.ITEMS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12140. yyt = yyt->INTERFACE_DECL.ITEMS; break;
  12141. case kEXT_PROC_DECL:
  12142. yyr = yyt->EXT_PROC_DECL.FORMALS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12143. yyt = yyt->EXT_PROC_DECL.FORMALS; break;
  12144. case kEXT_FUNC_DECL:
  12145. yyr = yyt->EXT_FUNC_DECL.FORMALS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12146. InitTree (yyr);
  12147. yyr = yyt->EXT_FUNC_DECL.RESULT_TYPE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12148. yyt = yyt->EXT_FUNC_DECL.RESULT_TYPE; break;
  12149. case kVAL_PARAM_DECL:
  12150. yyr = yyt->VAL_PARAM_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12151. yyt = yyt->VAL_PARAM_DECL.VAL; break;
  12152. case kVAR_PARAM_DECL:
  12153. yyr = yyt->VAR_PARAM_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12154. yyt = yyt->VAR_PARAM_DECL.VAL; break;
  12155. case kPROC_PARAM_DECL:
  12156. yyr = yyt->PROC_PARAM_DECL.FORMAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12157. yyt = yyt->PROC_PARAM_DECL.FORMAL; break;
  12158. case kFUNC_PARAM_DECL:
  12159. yyr = yyt->FUNC_PARAM_DECL.FORMAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12160. InitTree (yyr);
  12161. yyr = yyt->FUNC_PARAM_DECL.RESULT_TYPE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12162. yyt = yyt->FUNC_PARAM_DECL.RESULT_TYPE; break;
  12163. case kIMPLICIT_DECL:
  12164. yyr = yyt->IMPLICIT_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12165. yyt = yyt->IMPLICIT_DECL.VAL; break;
  12166. case kUSE_DECL:
  12167. yyr = yyt->USE_DECL.RENAMINGS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12168. yyt = yyt->USE_DECL.RENAMINGS; break;
  12169. case kONLY_USE_DECL:
  12170. yyr = yyt->ONLY_USE_DECL.NAMES; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12171. yyt = yyt->ONLY_USE_DECL.NAMES; break;
  12172. case kEQV_DECL:
  12173. yyr = yyt->EQV_DECL.VARS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12174. yyt = yyt->EQV_DECL.VARS; break;
  12175. case kDATA_DECL:
  12176. yyr = yyt->DATA_DECL.VARS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12177. InitTree (yyr);
  12178. yyr = yyt->DATA_DECL.VALS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12179. yyt = yyt->DATA_DECL.VALS; break;
  12180. case kDIMENSION_DECL:
  12181. yyr = yyt->DIMENSION_DECL.INDEXES; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12182. yyt = yyt->DIMENSION_DECL.INDEXES; break;
  12183. case kINIT_DATA_DECL:
  12184. yyr = yyt->INIT_DATA_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12185. yyt = yyt->INIT_DATA_DECL.VAL; break;
  12186. case kTYPESPEC_DECL:
  12187. yyr = yyt->TYPESPEC_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12188. yyt = yyt->TYPESPEC_DECL.VAL; break;
  12189. case kPARAMETER_DECL:
  12190. yyr = yyt->PARAMETER_DECL.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12191. yyt = yyt->PARAMETER_DECL.VAL; break;
  12192. case kDISTRIBUTE_DECL:
  12193. yyr = yyt->DISTRIBUTE_DECL.DISTRIBUTION; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12194. yyt = yyt->DISTRIBUTE_DECL.DISTRIBUTION; break;
  12195. case kALIGN_DECL:
  12196. yyr = yyt->ALIGN_DECL.ALIGN_SOURCE; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12197. InitTree (yyr);
  12198. yyr = yyt->ALIGN_DECL.ALIGN_SPEC; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12199. yyt = yyt->ALIGN_DECL.ALIGN_SPEC; break;
  12200. case kDECL_LIST:
  12201. yyr = yyt->DECL_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12202. InitTree (yyr);
  12203. yyr = yyt->DECL_LIST.Next; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12204. yyt = yyt->DECL_LIST.Next; break;
  12205. case kNODE_DISTRIBUTION:
  12206. yyr = yyt->NODE_DISTRIBUTION.MAPPING; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12207. yyt = yyt->NODE_DISTRIBUTION.MAPPING; break;
  12208. case kBLOCK_DISTRIBUTION:
  12209. yyr = yyt->BLOCK_DISTRIBUTION.SIZE; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12210. yyt = yyt->BLOCK_DISTRIBUTION.SIZE; break;
  12211. case kCYCLIC_DISTRIBUTION:
  12212. yyr = yyt->CYCLIC_DISTRIBUTION.SIZE; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12213. yyt = yyt->CYCLIC_DISTRIBUTION.SIZE; break;
  12214. case kDIST_LIST:
  12215. yyr = yyt->DIST_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12216. InitTree (yyr);
  12217. yyr = yyt->DIST_LIST.Next; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12218. yyt = yyt->DIST_LIST.Next; break;
  12219. case kOP_GENERIC_SPEC:
  12220. yyr = yyt->OP_GENERIC_SPEC.OPERATOR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12221. yyt = yyt->OP_GENERIC_SPEC.OPERATOR; break;
  12222. case kACF_LIST:
  12223. yyr = yyt->ACF_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12224. InitTree (yyr);
  12225. yyr = yyt->ACF_LIST.Next; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12226. yyt = yyt->ACF_LIST.Next; break;
  12227. case kACF_BASIC:
  12228. yyr = yyt->ACF_BASIC.BASIC_STMT; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12229. yyt = yyt->ACF_BASIC.BASIC_STMT; break;
  12230. case kACF_IF:
  12231. yyr = yyt->ACF_IF.IF_EXP; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12232. InitTree (yyr);
  12233. yyr = yyt->ACF_IF.THEN_PART; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12234. InitTree (yyr);
  12235. yyr = yyt->ACF_IF.ELSE_PART; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12236. yyt = yyt->ACF_IF.ELSE_PART; break;
  12237. case kACF_WHERE:
  12238. yyr = yyt->ACF_WHERE.WHERE_EXP; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12239. InitTree (yyr);
  12240. yyr = yyt->ACF_WHERE.TRUE_PART; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12241. InitTree (yyr);
  12242. yyr = yyt->ACF_WHERE.FALSE_PART; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12243. yyt = yyt->ACF_WHERE.FALSE_PART; break;
  12244. case kACF_SWITCH:
  12245. yyr = yyt->ACF_SWITCH.SWITCH_EXP; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12246. InitTree (yyr);
  12247. yyr = yyt->ACF_SWITCH.SWITCH_STMT; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12248. yyt = yyt->ACF_SWITCH.SWITCH_STMT; break;
  12249. case kACF_ALTER:
  12250. yyr = yyt->ACF_ALTER.ALTER_EXP; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12251. InitTree (yyr);
  12252. yyr = yyt->ACF_ALTER.ALTER_STMT; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12253. yyt = yyt->ACF_ALTER.ALTER_STMT; break;
  12254. case kACF_CASE:
  12255. yyr = yyt->ACF_CASE.CASE_EXP; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12256. InitTree (yyr);
  12257. yyr = yyt->ACF_CASE.CASE_ALTS; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12258. InitTree (yyr);
  12259. yyr = yyt->ACF_CASE.CASE_OTHERWISE; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12260. yyt = yyt->ACF_CASE.CASE_OTHERWISE; break;
  12261. case kACF_WHILE:
  12262. yyr = yyt->ACF_WHILE.WHILE_EXP; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12263. InitTree (yyr);
  12264. yyr = yyt->ACF_WHILE.WHILE_BODY; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12265. yyt = yyt->ACF_WHILE.WHILE_BODY; break;
  12266. case kACF_REPEAT:
  12267. yyr = yyt->ACF_REPEAT.REPEAT_BODY; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12268. InitTree (yyr);
  12269. yyr = yyt->ACF_REPEAT.REPEAT_EXP; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12270. yyt = yyt->ACF_REPEAT.REPEAT_EXP; break;
  12271. case kACF_WITH:
  12272. yyr = yyt->ACF_WITH.WITH_VARS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12273. InitTree (yyr);
  12274. yyr = yyt->ACF_WITH.WITH_BODY; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12275. yyt = yyt->ACF_WITH.WITH_BODY; break;
  12276. case kACF_LOOP:
  12277. yyr = yyt->ACF_LOOP.LOOP_BODY; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12278. yyt = yyt->ACF_LOOP.LOOP_BODY; break;
  12279. case kACF_DO:
  12280. yyr = yyt->ACF_DO.DO_ID; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12281. InitTree (yyr);
  12282. yyr = yyt->ACF_DO.DO_RANGE; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12283. InitTree (yyr);
  12284. yyr = yyt->ACF_DO.DO_BODY; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12285. yyt = yyt->ACF_DO.DO_BODY; break;
  12286. case kACF_DOLOCAL:
  12287. yyr = yyt->ACF_DOLOCAL.DOLOCAL_ID; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12288. InitTree (yyr);
  12289. yyr = yyt->ACF_DOLOCAL.DOLOCAL_RANGE; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12290. InitTree (yyr);
  12291. yyr = yyt->ACF_DOLOCAL.DOLOCAL_BODY; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12292. yyt = yyt->ACF_DOLOCAL.DOLOCAL_BODY; break;
  12293. case kACF_DOVEC:
  12294. yyr = yyt->ACF_DOVEC.DOVEC_ID; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12295. InitTree (yyr);
  12296. yyr = yyt->ACF_DOVEC.DOVEC_RANGE; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12297. InitTree (yyr);
  12298. yyr = yyt->ACF_DOVEC.DOVEC_BODY; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12299. yyt = yyt->ACF_DOVEC.DOVEC_BODY; break;
  12300. case kACF_DOALL:
  12301. yyr = yyt->ACF_DOALL.DOALL_NEW; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12302. InitTree (yyr);
  12303. yyr = yyt->ACF_DOALL.DOALL_ID; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12304. InitTree (yyr);
  12305. yyr = yyt->ACF_DOALL.DOALL_RANGE; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12306. InitTree (yyr);
  12307. yyr = yyt->ACF_DOALL.DOALL_BODY; yyr->yyHead.yyOffset = 6; yyr->yyHead.yyParent = yyt;
  12308. yyt = yyt->ACF_DOALL.DOALL_BODY; break;
  12309. case kACF_FORALL:
  12310. yyr = yyt->ACF_FORALL.FORALL_ID; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12311. InitTree (yyr);
  12312. yyr = yyt->ACF_FORALL.FORALL_RANGE; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12313. InitTree (yyr);
  12314. yyr = yyt->ACF_FORALL.FORALL_BODY; yyr->yyHead.yyOffset = 5; yyr->yyHead.yyParent = yyt;
  12315. yyt = yyt->ACF_FORALL.FORALL_BODY; break;
  12316. case kACF_ON:
  12317. yyr = yyt->ACF_ON.ON_VAR; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12318. InitTree (yyr);
  12319. yyr = yyt->ACF_ON.ON_STMT; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12320. yyt = yyt->ACF_ON.ON_STMT; break;
  12321. case kACF_BODY:
  12322. yyr = yyt->ACF_BODY.NEW_BODY; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12323. yyt = yyt->ACF_BODY.NEW_BODY; break;
  12324. case kACF_FLOW_GRAPH:
  12325. yyr = yyt->ACF_FLOW_GRAPH.FLOW_NODES; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12326. yyt = yyt->ACF_FLOW_GRAPH.FLOW_NODES; break;
  12327. case kACF_ENTRY:
  12328. yyr = yyt->ACF_ENTRY.ENTRY_DECL; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12329. yyt = yyt->ACF_ENTRY.ENTRY_DECL; break;
  12330. case kSELECTED_ACF_LIST:
  12331. yyr = yyt->SELECTED_ACF_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12332. InitTree (yyr);
  12333. yyr = yyt->SELECTED_ACF_LIST.Next; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12334. yyt = yyt->SELECTED_ACF_LIST.Next; break;
  12335. case kSELECTED_ACF_NODE:
  12336. yyr = yyt->SELECTED_ACF_NODE.SELECT_LIST; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12337. InitTree (yyr);
  12338. yyr = yyt->SELECTED_ACF_NODE.SELECT_ACFS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12339. yyt = yyt->SELECTED_ACF_NODE.SELECT_ACFS; break;
  12340. case kEXP_STMT:
  12341. yyr = yyt->EXP_STMT.STMT_EXP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12342. yyt = yyt->EXP_STMT.STMT_EXP; break;
  12343. case kASSIGN_STMT:
  12344. yyr = yyt->ASSIGN_STMT.ASSIGN_VAR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12345. InitTree (yyr);
  12346. yyr = yyt->ASSIGN_STMT.ASSIGN_EXP; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12347. yyt = yyt->ASSIGN_STMT.ASSIGN_EXP; break;
  12348. case kPTR_ASSIGN_STMT:
  12349. yyr = yyt->PTR_ASSIGN_STMT.ASSIGN_VAR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12350. InitTree (yyr);
  12351. yyr = yyt->PTR_ASSIGN_STMT.ASSIGN_EXP; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12352. yyt = yyt->PTR_ASSIGN_STMT.ASSIGN_EXP; break;
  12353. case kLABEL_ASSIGN_STMT:
  12354. yyr = yyt->LABEL_ASSIGN_STMT.LABEL_VAR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12355. yyt = yyt->LABEL_ASSIGN_STMT.LABEL_VAR; break;
  12356. case kCALL_STMT:
  12357. yyr = yyt->CALL_STMT.CALL_ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12358. InitTree (yyr);
  12359. yyr = yyt->CALL_STMT.CALL_PARAMS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12360. yyt = yyt->CALL_STMT.CALL_PARAMS; break;
  12361. case kIO_STMT:
  12362. yyr = yyt->IO_STMT.ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12363. InitTree (yyr);
  12364. yyr = yyt->IO_STMT.IO_SPECS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12365. InitTree (yyr);
  12366. yyr = yyt->IO_STMT.IO_ITEMS; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12367. yyt = yyt->IO_STMT.IO_ITEMS; break;
  12368. case kASS_GOTO_STMT:
  12369. yyr = yyt->ASS_GOTO_STMT.GOTO_VAR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12370. InitTree (yyr);
  12371. yyr = yyt->ASS_GOTO_STMT.LABELS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12372. yyt = yyt->ASS_GOTO_STMT.LABELS; break;
  12373. case kCOMP_GOTO_STMT:
  12374. yyr = yyt->COMP_GOTO_STMT.GOTO_LABELS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12375. InitTree (yyr);
  12376. yyr = yyt->COMP_GOTO_STMT.GOTO_EXP; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12377. yyt = yyt->COMP_GOTO_STMT.GOTO_EXP; break;
  12378. case kCOMP_IF_STMT:
  12379. yyr = yyt->COMP_IF_STMT.IF_EXP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12380. yyt = yyt->COMP_IF_STMT.IF_EXP; break;
  12381. case kRETURN_STMT:
  12382. yyr = yyt->RETURN_STMT.RETURN_EXP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12383. yyt = yyt->RETURN_STMT.RETURN_EXP; break;
  12384. case kPAUSE_STMT:
  12385. yyr = yyt->PAUSE_STMT.PAUSE_CONST; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12386. yyt = yyt->PAUSE_STMT.PAUSE_CONST; break;
  12387. case kSTOP_STMT:
  12388. yyr = yyt->STOP_STMT.STOP_CONST; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12389. yyt = yyt->STOP_STMT.STOP_CONST; break;
  12390. case kFORMAT_STMT:
  12391. yyr = yyt->FORMAT_STMT.FORMAT_PARAMS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12392. yyt = yyt->FORMAT_STMT.FORMAT_PARAMS; break;
  12393. case kALLOCATE_STMT:
  12394. yyr = yyt->ALLOCATE_STMT.PARAMS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12395. InitTree (yyr);
  12396. yyr = yyt->ALLOCATE_STMT.STAT; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12397. yyt = yyt->ALLOCATE_STMT.STAT; break;
  12398. case kDEALLOCATE_STMT:
  12399. yyr = yyt->DEALLOCATE_STMT.PARAMS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12400. InitTree (yyr);
  12401. yyr = yyt->DEALLOCATE_STMT.STAT; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12402. yyt = yyt->DEALLOCATE_STMT.STAT; break;
  12403. case kNULLIFY_STMT:
  12404. yyr = yyt->NULLIFY_STMT.PARAMS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12405. yyt = yyt->NULLIFY_STMT.PARAMS; break;
  12406. case kREDUCE_STMT:
  12407. yyr = yyt->REDUCE_STMT.RED_FUNC; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12408. InitTree (yyr);
  12409. yyr = yyt->REDUCE_STMT.RED_PARAMS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12410. yyt = yyt->REDUCE_STMT.RED_PARAMS; break;
  12411. case kGLOBAL_STMT:
  12412. yyr = yyt->GLOBAL_STMT.ARRAY; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12413. InitTree (yyr);
  12414. yyr = yyt->GLOBAL_STMT.INDEXED_ARRAY; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12415. InitTree (yyr);
  12416. yyr = yyt->GLOBAL_STMT.INDEXES; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12417. InitTree (yyr);
  12418. yyr = yyt->GLOBAL_STMT.MASK; yyr->yyHead.yyOffset = 4; yyr->yyHead.yyParent = yyt;
  12419. yyt = yyt->GLOBAL_STMT.MASK; break;
  12420. case kALIGN_STMT:
  12421. yyr = yyt->ALIGN_STMT.ALIGNEE; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12422. InitTree (yyr);
  12423. yyr = yyt->ALIGN_STMT.ALIGN_SPEC; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12424. yyt = yyt->ALIGN_STMT.ALIGN_SPEC; break;
  12425. case kDISTRIBUTE_STMT:
  12426. yyr = yyt->DISTRIBUTE_STMT.DISTRIBUTEE; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12427. InitTree (yyr);
  12428. yyr = yyt->DISTRIBUTE_STMT.DISTRIBUTION; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12429. yyt = yyt->DISTRIBUTE_STMT.DISTRIBUTION; break;
  12430. case kLABEL_LIST:
  12431. yyr = yyt->LABEL_LIST.Next; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12432. yyt = yyt->LABEL_LIST.Next; break;
  12433. case kCONST_EXP:
  12434. yyr = yyt->CONST_EXP.C; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12435. yyt = yyt->CONST_EXP.C; break;
  12436. case kOP_EXP:
  12437. yyr = yyt->OP_EXP.EXP_OP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12438. InitTree (yyr);
  12439. yyr = yyt->OP_EXP.OPND1; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12440. InitTree (yyr);
  12441. yyr = yyt->OP_EXP.OPND2; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12442. yyt = yyt->OP_EXP.OPND2; break;
  12443. case kOP1_EXP:
  12444. yyr = yyt->OP1_EXP.EXP_OP1; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12445. InitTree (yyr);
  12446. yyr = yyt->OP1_EXP.OPND; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12447. yyt = yyt->OP1_EXP.OPND; break;
  12448. case kSLICE_EXP:
  12449. yyr = yyt->SLICE_EXP.START; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12450. InitTree (yyr);
  12451. yyr = yyt->SLICE_EXP.STOP; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12452. InitTree (yyr);
  12453. yyr = yyt->SLICE_EXP.INC; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12454. yyt = yyt->SLICE_EXP.INC; break;
  12455. case kPOSTFIX_EXP:
  12456. yyr = yyt->POSTFIX_EXP.POSTFIX_OP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12457. InitTree (yyr);
  12458. yyr = yyt->POSTFIX_EXP.OPND; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12459. yyt = yyt->POSTFIX_EXP.OPND; break;
  12460. case kCALL_EXP:
  12461. yyr = yyt->CALL_EXP.FUNC_ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12462. InitTree (yyr);
  12463. yyr = yyt->CALL_EXP.FUNC_PARAMS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12464. yyt = yyt->CALL_EXP.FUNC_PARAMS; break;
  12465. case kCAST_EXP:
  12466. yyr = yyt->CAST_EXP.ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12467. InitTree (yyr);
  12468. yyr = yyt->CAST_EXP.CAST; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12469. yyt = yyt->CAST_EXP.CAST; break;
  12470. case kINDEXED_EXP:
  12471. yyr = yyt->INDEXED_EXP.IND_EXP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12472. InitTree (yyr);
  12473. yyr = yyt->INDEXED_EXP.INDEX; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12474. yyt = yyt->INDEXED_EXP.INDEX; break;
  12475. case kSELECTED_EXP:
  12476. yyr = yyt->SELECTED_EXP.SELEC_EXP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12477. InitTree (yyr);
  12478. yyr = yyt->SELECTED_EXP.SELECTOR; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12479. yyt = yyt->SELECTED_EXP.SELECTOR; break;
  12480. case kASSIGN_EXP:
  12481. yyr = yyt->ASSIGN_EXP.ASSIGN_OP; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12482. InitTree (yyr);
  12483. yyr = yyt->ASSIGN_EXP.LHS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12484. InitTree (yyr);
  12485. yyr = yyt->ASSIGN_EXP.RHS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12486. yyt = yyt->ASSIGN_EXP.RHS; break;
  12487. case kUSED_EXP:
  12488. yyr = yyt->USED_EXP.VARNAME; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12489. yyt = yyt->USED_EXP.VARNAME; break;
  12490. case kCOND_EXP:
  12491. yyr = yyt->COND_EXP.COND; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12492. InitTree (yyr);
  12493. yyr = yyt->COND_EXP.TRUE_EXP; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12494. InitTree (yyr);
  12495. yyr = yyt->COND_EXP.FALSE_EXP; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12496. yyt = yyt->COND_EXP.FALSE_EXP; break;
  12497. case kVAR_EXP:
  12498. yyr = yyt->VAR_EXP.V; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12499. yyt = yyt->VAR_EXP.V; break;
  12500. case kFUNC_CALL_EXP:
  12501. yyr = yyt->FUNC_CALL_EXP.FUNC_ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12502. InitTree (yyr);
  12503. yyr = yyt->FUNC_CALL_EXP.FUNC_PARAMS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12504. yyt = yyt->FUNC_CALL_EXP.FUNC_PARAMS; break;
  12505. case kNAMED_EXP:
  12506. yyr = yyt->NAMED_EXP.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12507. yyt = yyt->NAMED_EXP.VAL; break;
  12508. case kDO_EXP:
  12509. yyr = yyt->DO_EXP.DO_ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12510. InitTree (yyr);
  12511. yyr = yyt->DO_EXP.RANGE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12512. InitTree (yyr);
  12513. yyr = yyt->DO_EXP.BODY; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12514. yyt = yyt->DO_EXP.BODY; break;
  12515. case kTYPE_EXP:
  12516. yyr = yyt->TYPE_EXP.ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12517. InitTree (yyr);
  12518. yyr = yyt->TYPE_EXP.ELEMENTS; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12519. yyt = yyt->TYPE_EXP.ELEMENTS; break;
  12520. case kARRAY_EXP:
  12521. yyr = yyt->ARRAY_EXP.ELEMENTS; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12522. yyt = yyt->ARRAY_EXP.ELEMENTS; break;
  12523. case kBTE_LIST:
  12524. yyr = yyt->BTE_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12525. InitTree (yyr);
  12526. yyr = yyt->BTE_LIST.Next; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12527. yyt = yyt->BTE_LIST.Next; break;
  12528. case kUSED_VAR:
  12529. yyr = yyt->USED_VAR.VARNAME; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12530. yyt = yyt->USED_VAR.VARNAME; break;
  12531. case kINDEXED_VAR:
  12532. yyr = yyt->INDEXED_VAR.IND_VAR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12533. InitTree (yyr);
  12534. yyr = yyt->INDEXED_VAR.IND_EXPS; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12535. yyt = yyt->INDEXED_VAR.IND_EXPS; break;
  12536. case kSUBSTRING_VAR:
  12537. yyr = yyt->SUBSTRING_VAR.IND_VAR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12538. InitTree (yyr);
  12539. yyr = yyt->SUBSTRING_VAR.IND_EXP; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12540. yyt = yyt->SUBSTRING_VAR.IND_EXP; break;
  12541. case kSELECTED_VAR:
  12542. yyr = yyt->SELECTED_VAR.SELEC_VAR; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12543. InitTree (yyr);
  12544. yyr = yyt->SELECTED_VAR.SELECTOR; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12545. yyt = yyt->SELECTED_VAR.SELECTOR; break;
  12546. case kLOOP_VAR:
  12547. yyr = yyt->LOOP_VAR.LOOP_VARNAME; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12548. yyt = yyt->LOOP_VAR.LOOP_VARNAME; break;
  12549. case kADDR:
  12550. yyr = yyt->ADDR.E; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12551. yyt = yyt->ADDR.E; break;
  12552. case kDO_VAR:
  12553. yyr = yyt->DO_VAR.DO_ID; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12554. InitTree (yyr);
  12555. yyr = yyt->DO_VAR.RANGE; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12556. InitTree (yyr);
  12557. yyr = yyt->DO_VAR.BODY; yyr->yyHead.yyOffset = 3; yyr->yyHead.yyParent = yyt;
  12558. yyt = yyt->DO_VAR.BODY; break;
  12559. case kBTV_LIST:
  12560. yyr = yyt->BTV_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12561. InitTree (yyr);
  12562. yyr = yyt->BTV_LIST.Next; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12563. yyt = yyt->BTV_LIST.Next; break;
  12564. case kVAR_PARAM:
  12565. yyr = yyt->VAR_PARAM.V; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12566. yyt = yyt->VAR_PARAM.V; break;
  12567. case kVALUE_PARAM:
  12568. yyr = yyt->VALUE_PARAM.E; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12569. yyt = yyt->VALUE_PARAM.E; break;
  12570. case kNAMED_PARAM:
  12571. yyr = yyt->NAMED_PARAM.VAL; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12572. yyt = yyt->NAMED_PARAM.VAL; break;
  12573. case kPROC_PARAM:
  12574. yyr = yyt->PROC_PARAM.P; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12575. yyt = yyt->PROC_PARAM.P; break;
  12576. case kFUNC_PARAM:
  12577. yyr = yyt->FUNC_PARAM.F; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12578. yyt = yyt->FUNC_PARAM.F; break;
  12579. case kBTP_LIST:
  12580. yyr = yyt->BTP_LIST.Elem; yyr->yyHead.yyOffset = 1; yyr->yyHead.yyParent = yyt;
  12581. InitTree (yyr);
  12582. yyr = yyt->BTP_LIST.Next; yyr->yyHead.yyOffset = 2; yyr->yyHead.yyParent = yyt;
  12583. yyt = yyt->BTP_LIST.Next; break;
  12584.   default: return;
  12585.   }
  12586.  }
  12587. }
  12588.  
  12589. void BeginTree ()
  12590. {
  12591. }
  12592.  
  12593. void CloseTree ()
  12594. {
  12595. }
  12596.