PageRenderTime 53ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 0ms

/other/netcdf_write_matrix/src/ncgen/ncgentab.c

http://github.com/jbeezley/wrf-fire
C | 1350 lines | 1294 code | 30 blank | 26 comment | 164 complexity | 6cb5f3734c155a2ccbd9e89bb46f195b MD5 | raw file
Possible License(s): AGPL-1.0 
    

  1. #ifndef lint
    2. 

  2. static char const 
    3. 

  3. yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $";
    4. 

  4. #endif
    5. 

  5. #include <stdlib.h>
    6. 

  6. #define YYBYACC 1
    7. 

  7. #define YYMAJOR 1
    8. 

  8. #define YYMINOR 9
    9. 

  9. #define YYLEX yylex()
    10. 

  10. #define YYEMPTY -1
    11. 

  11. #define yyclearin (yychar=(YYEMPTY))
    12. 

  12. #define yyerrok (yyerrflag=0)
    13. 

  13. #define YYRECOVERING() (yyerrflag!=0)
    14. 

  14. static int yygrowstack();
    15. 

  15. #define YYPREFIX "yy"
    16. 

  16. #line 10 "ncgen.y"
    17. 

  17. #ifndef lint
    18. 

  18. static char SccsId[] = "$Id: ncgentab.c,v 1.15 2005/02/17 23:24:25 ed Exp $";
    19. 

  19. #endif
    20. 

  20. #include        <string.h>
    21. 

  21. #include	<stdlib.h>
    22. 

  22. #include	<netcdf.h>
    23. 

  23. #include 	"generic.h"
    24. 

  24. #include        "ncgen.h"
    25. 

  25. #include	"genlib.h"	/* for grow_darray() et al */
    26. 

  26. 

  27. typedef struct Symbol {		/* symbol table entry */
    28. 

  28. 	char    	*name;
    29. 

  29. 	struct Symbol   *next;
    30. 

  30. 	unsigned	is_dim : 1;	/* appears as netCDF dimension */
    31. 

  31. 	unsigned	is_var : 1;	/* appears as netCDF variable */
    32. 

  32. 	unsigned	is_att : 1;	/* appears as netCDF attribute */
    33. 

  33. 	int             dnum;	        /* handle as a dimension */
    34. 

  34. 	int             vnum;	        /* handle as a variable */
    35. 

  35. 	} *YYSTYPE1;
    36. 

  36. 

  37. /* True if string a equals string b*/
    38. 

  38. #define	STREQ(a, b)	(*(a) == *(b) && strcmp((a), (b)) == 0)
    39. 

  39. #define NC_UNSPECIFIED ((nc_type)0)	/* unspecified (as yet) type */
    40. 

  40. 

  41. #define YYSTYPE YYSTYPE1
    42. 

  42. YYSTYPE symlist;		/* symbol table: linked list */
    43. 

  43. 

  44. extern int derror_count;	/* counts errors in netcdf definition */
    45. 

  45. extern int lineno;		/* line number for error messages */
    46. 

  46. 

  47. static int not_a_string;	/* whether last constant read was a string */
    48. 

  48. static char termstring[MAXTRST]; /* last terminal string read */
    49. 

  49. static double double_val;	/* last double value read */
    50. 

  50. static float float_val;		/* last float value read */
    51. 

  51. static int int_val;		/* last int value read */
    52. 

  52. static short short_val;		/* last short value read */
    53. 

  53. static char char_val;		/* last char value read */
    54. 

  54. static signed char byte_val;	/* last byte value read */
    55. 

  55. 

  56. static nc_type type_code;	/* holds declared type for variables */
    57. 

  57. static nc_type atype_code;	/* holds derived type for attributes */
    58. 

  58. static char *netcdfname;	/* to construct netcdf file name */
    59. 

  59. static void *att_space;		/* pointer to block for attribute values */
    60. 

  60. static nc_type valtype;		/* type code for list of attribute values  */
    61. 

  61. 

  62. static char *char_valp;		/* pointers used to accumulate data values */
    63. 

  63. static signed char *byte_valp;
    64. 

  64. static short *short_valp;
    65. 

  65. static int *int_valp;
    66. 

  66. static float *float_valp;
    67. 

  67. static double *double_valp;
    68. 

  68. static void *rec_cur;		/* pointer to where next data value goes */
    69. 

  69. static void *rec_start;		/* start of space for data */
    70. 

  70. #line 71 "y.tab.c"
    71. 

  71. #define YYERRCODE 256
    72. 

  72. #define NC_UNLIMITED_K 257
    73. 

  73. #define BYTE_K 258
    74. 

  74. #define CHAR_K 259
    75. 

  75. #define SHORT_K 260
    76. 

  76. #define INT_K 261
    77. 

  77. #define FLOAT_K 262
    78. 

  78. #define DOUBLE_K 263
    79. 

  79. #define IDENT 264
    80. 

  80. #define TERMSTRING 265
    81. 

  81. #define BYTE_CONST 266
    82. 

  82. #define CHAR_CONST 267
    83. 

  83. #define SHORT_CONST 268
    84. 

  84. #define INT_CONST 269
    85. 

  85. #define FLOAT_CONST 270
    86. 

  86. #define DOUBLE_CONST 271
    87. 

  87. #define DIMENSIONS 272
    88. 

  88. #define VARIABLES 273
    89. 

  89. #define NETCDF 274
    90. 

  90. #define DATA 275
    91. 

  91. #define FILLVALUE 276
    92. 

  92. const short yylhs[] = {                                        -1,
    93. 

  93.     2,    5,    0,    1,    1,    6,    6,    7,    7,    8,
    94. 

  94.     8,    8,    9,   10,    3,    3,    3,   11,   11,   13,
    95. 

  95.    13,   12,   12,   16,   14,   17,   17,   17,   17,   17,
    96. 

  96.    17,   18,   18,   22,   19,   20,   21,   21,   23,   23,
    97. 

  97.    24,   26,   15,   25,   25,   28,   29,   27,   27,   30,
    98. 

  98.    31,   31,   31,   31,   31,   31,   31,    4,    4,    4,
    99. 

  99.    32,   32,   34,   33,   35,   35,   38,   36,   37,   37,
    100. 

  100.    37,   37,   37,   37,   37,   37,
    101. 

  101. };
    102. 

  102. const short yylen[] = {                                         2,
    103. 

  103.     0,    0,    8,    0,    2,    2,    3,    1,    3,    3,
    104. 

  104.     3,    3,    1,    1,    0,    2,    1,    2,    3,    1,
    105. 

  105.     1,    2,    3,    1,    2,    1,    1,    1,    1,    1,
    106. 

  106.     1,    1,    3,    0,    3,    1,    0,    3,    1,    3,
    107. 

  107.     1,    0,    4,    3,    2,    1,    1,    1,    3,    1,
    108. 

  108.     1,    1,    1,    1,    1,    1,    1,    0,    2,    1,
    109. 

  109.     2,    3,    0,    4,    1,    3,    0,    2,    1,    1,
    110. 

  110.     1,    1,    1,    1,    1,    1,
    111. 

  111. };
    112. 

  112. const short yydefred[] = {                                      0,
    113. 

  113.     0,    0,    1,    0,    0,    0,   14,    0,    0,    8,
    114. 

  114.     0,   13,   36,    0,    0,    2,    0,   24,    0,   46,
    115. 

  115.    42,    0,    0,    6,    0,    0,   26,   27,   28,   29,
    116. 

  116.    30,   31,    0,    0,   20,   21,    0,   47,   45,    0,
    117. 

  117.     0,   22,    0,    0,    7,    9,   12,   10,   11,    0,
    118. 

  118.    18,    0,   32,   34,    0,    0,   23,    0,   44,   19,
    119. 

  119.     0,    0,   63,    0,    0,    3,   52,   53,   51,   54,
    120. 

  120.    55,   56,   57,    0,   48,   50,   33,    0,   35,    0,
    121. 

  121.     0,   61,    0,   41,    0,   39,   67,   62,   49,    0,
    122. 

  122.    38,    0,   65,    0,   40,   67,   70,   71,   69,   72,
    123. 

  123.    73,   74,   75,   76,   68,   66,
    124. 

  124. };
    125. 

  125. const short yydgoto[] = {                                       2,
    126. 

  126.     6,    4,   16,   56,   40,    8,    9,   10,   11,   12,
    127. 

  127.    33,   17,   34,   35,   18,   19,   37,   52,   53,   20,
    128. 

  128.    79,   62,   85,   86,   21,   43,   74,   22,   39,   75,
    129. 

  129.    76,   64,   65,   80,   92,   93,  105,   94,
    130. 

  130. };
    131. 

  131. const short yysindex[] = {                                   -261,
    132. 

  132.  -109,    0,    0, -253, -242,  -54,    0, -242,  -35,    0,
    133. 

  133.   -22,    0,    0,  -38, -224,    0,  -56,    0,  -36,    0,
    134. 

  134.     0,  -17,  -34,    0, -242, -241,    0,    0,    0,    0,
    135. 

  135.     0,    0,  -38,   -8,    0,    0, -222,    0,    0, -223,
    136. 

  136.    -5,    0,   -4, -224,    0,    0,    0,    0,    0,   -3,
    137. 

  137.     0,    9,    0,    0, -222,  -70,    0, -221,    0,    0,
    138. 

  138.  -222,   18,    0, -222,    1,    0,    0,    0,    0,    0,
    139. 

  139.     0,    0,    0,   15,    0,    0,    0, -242,    0,    2,
    140. 

  140.     3,    0, -221,    0,  -26,    0,    0,    0,    0, -242,
    141. 

  141.     0,   17,    0, -233,    0,    0,    0,    0,    0,    0,
    142. 

  142.     0,    0,    0,    0,    0,    0,
    143. 

  143. };
    144. 

  144. const short yyrindex[] = {                                      0,
    145. 

  145.     0,    0,    0,  -58,    0, -122,    0,  -57,    0,    0,
    146. 

  146.     0,    0,    0,    0,    0,    0, -120,    0,    0,    0,
    147. 

  147.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    148. 

  148.     0,    0, -119,    0,    0,    0,    0,    0,    0,  -60,
    149. 

  149.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    150. 

  150.     0,    5,    0,    0,  -59,    0,    0,    0,    0,    0,
    151. 

  151.     0,  -33,    0,  -55,    0,    0,    0,    0,    0,    0,
    152. 

  152.     0,    0,    0,   10,    0,    0,    0,    0,    0,    0,
    153. 

  153.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    154. 

  154.     0,   12,    0,    0,    0,    0,    0,    0,    0,    0,
    155. 

  155.     0,    0,    0,    0,    0,    0,
    156. 

  156. };
    157. 

  157. const short yygindex[] = {                                      0,
    158. 

  158.     0,    0,    0,    0,    0,    0,   64,   48,    0,  -61,
    159. 

  159.     0,    0,   41,    0,   -6,   58,    0,    0,   16,  -30,
    160. 

  160.     0,    0,    0,  -14,    0,    0,    0,  -43,   34,   -2,
    161. 

  161.     0,    0,   19,    0,    0,  -16,    0,    0,
    162. 

  162. };
    163. 

  163. #define YYTABLESIZE 226
    164. 

  164. const short yytable[] = {                                       4,
    165. 

  165.     5,   15,   15,   15,   17,   16,   54,   36,   25,   25,
    166. 

  166.    37,   63,    1,    3,   91,   47,   84,   90,    5,   15,
    167. 

  167.    63,    7,   42,   24,   45,   37,   36,   48,   84,   49,
    168. 

  168.    54,   97,   98,   99,  100,  101,  102,  103,   26,   38,
    169. 

  169.    44,   13,  104,   67,   68,   69,   70,   71,   72,   73,
    170. 

  170.    51,   55,   61,   57,   66,   60,   58,   78,   83,   82,
    171. 

  171.    96,   88,   87,   25,   58,   60,    4,    5,   43,   59,
    172. 

  172.    64,   23,   46,   50,   41,   95,   77,   59,    0,  106,
    173. 

  173.    89,    0,   81,    0,    0,    0,    0,    0,    0,    0,
    174. 

  174.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    175. 

  175.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    176. 

  176.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    177. 

  177.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    178. 

  178.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    179. 

  179.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    180. 

  180.     0,    0,   15,    0,   17,   16,    0,    0,    0,    0,
    181. 

  181.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    182. 

  182.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    183. 

  183.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    184. 

  184.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    185. 

  185.     0,    0,    0,    0,    0,    4,    0,   13,    0,   13,
    186. 

  186.     0,    0,    0,    0,    4,    5,    4,    5,   14,   27,
    187. 

  187.    28,   29,   30,   31,   32,   13,
    188. 

  188. };
    189. 

  189. const short yycheck[] = {                                      58,
    190. 

  190.    58,   58,  125,   58,  125,  125,   37,   14,   44,   44,
    191. 

  191.    44,   55,  274,  123,   41,  257,   78,   44,  272,   58,
    192. 

  192.    64,  264,   59,   59,   59,   59,   33,  269,   90,  271,
    193. 

  193.    61,  265,  266,  267,  268,  269,  270,  271,   61,  264,
    194. 

  194.    58,  264,  276,  265,  266,  267,  268,  269,  270,  271,
    195. 

  195.    59,  275,   44,   59,  125,   59,   61,   40,   44,   59,
    196. 

  196.    44,   59,   61,   59,  125,  125,  125,  125,   59,  125,
    197. 

  197.    59,    8,   25,   33,   17,   90,   61,   44,   -1,   96,
    198. 

  198.    83,   -1,   64,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    199. 

  199.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    200. 

  200.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    201. 

  201.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    202. 

  202.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    203. 

  203.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    204. 

  204.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    205. 

  205.    -1,   -1,  275,   -1,  275,  275,   -1,   -1,   -1,   -1,
    206. 

  206.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    207. 

  207.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    208. 

  208.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    209. 

  209.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    210. 

  210.    -1,   -1,   -1,   -1,   -1,  264,   -1,  264,   -1,  264,
    211. 

  211.    -1,   -1,   -1,   -1,  273,  273,  275,  275,  273,  258,
    212. 

  212.   259,  260,  261,  262,  263,  264,
    213. 

  213. };
    214. 

  214. #define YYFINAL 2
    215. 

  215. #ifndef YYDEBUG
    216. 

  216. #define YYDEBUG 0
    217. 

  217. #endif
    218. 

  218. #define YYMAXTOKEN 276
    219. 

  219. #if YYDEBUG
    220. 

  220. const char * const yyname[] = {
    221. 

  221. "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    222. 

  222. 0,0,0,0,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,"':'","';'",0,"'='",
    223. 

  223. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    224. 

  224. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,
    225. 

  225. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    226. 

  226. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    227. 

  227. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    228. 

  228. "NC_UNLIMITED_K","BYTE_K","CHAR_K","SHORT_K","INT_K","FLOAT_K","DOUBLE_K",
    229. 

  229. "IDENT","TERMSTRING","BYTE_CONST","CHAR_CONST","SHORT_CONST","INT_CONST",
    230. 

  230. "FLOAT_CONST","DOUBLE_CONST","DIMENSIONS","VARIABLES","NETCDF","DATA",
    231. 

  231. "FILLVALUE",
    232. 

  232. };
    233. 

  233. const char * const yyrule[] = {
    234. 

  234. "$accept : ncdesc",
    235. 

  235. "$$1 :",
    236. 

  236. "$$2 :",
    237. 

  237. "ncdesc : NETCDF '{' $$1 dimsection vasection $$2 datasection '}'",
    238. 

  238. "dimsection :",
    239. 

  239. "dimsection : DIMENSIONS dimdecls",
    240. 

  240. "dimdecls : dimdecline ';'",
    241. 

  241. "dimdecls : dimdecls dimdecline ';'",
    242. 

  242. "dimdecline : dimdecl",
    243. 

  243. "dimdecline : dimdecline ',' dimdecl",
    244. 

  244. "dimdecl : dimd '=' INT_CONST",
    245. 

  245. "dimdecl : dimd '=' DOUBLE_CONST",
    246. 

  246. "dimdecl : dimd '=' NC_UNLIMITED_K",
    247. 

  247. "dimd : dim",
    248. 

  248. "dim : IDENT",
    249. 

  249. "vasection :",
    250. 

  250. "vasection : VARIABLES vadecls",
    251. 

  251. "vasection : gattdecls",
    252. 

  252. "vadecls : vadecl ';'",
    253. 

  253. "vadecls : vadecls vadecl ';'",
    254. 

  254. "vadecl : vardecl",
    255. 

  255. "vadecl : attdecl",
    256. 

  256. "gattdecls : gattdecl ';'",
    257. 

  257. "gattdecls : gattdecls gattdecl ';'",
    258. 

  258. "gattdecl : attdecl",
    259. 

  259. "vardecl : type varlist",
    260. 

  260. "type : BYTE_K",
    261. 

  261. "type : CHAR_K",
    262. 

  262. "type : SHORT_K",
    263. 

  263. "type : INT_K",
    264. 

  264. "type : FLOAT_K",
    265. 

  265. "type : DOUBLE_K",
    266. 

  266. "varlist : varspec",
    267. 

  267. "varlist : varlist ',' varspec",
    268. 

  268. "$$3 :",
    269. 

  269. "varspec : var $$3 dimspec",
    270. 

  270. "var : IDENT",
    271. 

  271. "dimspec :",
    272. 

  272. "dimspec : '(' dimlist ')'",
    273. 

  273. "dimlist : vdim",
    274. 

  274. "dimlist : dimlist ',' vdim",
    275. 

  275. "vdim : dim",
    276. 

  276. "$$4 :",
    277. 

  277. "attdecl : att $$4 '=' attvallist",
    278. 

  278. "att : avar ':' attr",
    279. 

  279. "att : ':' attr",
    280. 

  280. "avar : var",
    281. 

  281. "attr : IDENT",
    282. 

  282. "attvallist : aconst",
    283. 

  283. "attvallist : attvallist ',' aconst",
    284. 

  284. "aconst : attconst",
    285. 

  285. "attconst : CHAR_CONST",
    286. 

  286. "attconst : TERMSTRING",
    287. 

  287. "attconst : BYTE_CONST",
    288. 

  288. "attconst : SHORT_CONST",
    289. 

  289. "attconst : INT_CONST",
    290. 

  290. "attconst : FLOAT_CONST",
    291. 

  291. "attconst : DOUBLE_CONST",
    292. 

  292. "datasection :",
    293. 

  293. "datasection : DATA datadecls",
    294. 

  294. "datasection : DATA",
    295. 

  295. "datadecls : datadecl ';'",
    296. 

  296. "datadecls : datadecls datadecl ';'",
    297. 

  297. "$$5 :",
    298. 

  298. "datadecl : avar $$5 '=' constlist",
    299. 

  299. "constlist : dconst",
    300. 

  300. "constlist : constlist ',' dconst",
    301. 

  301. "$$6 :",
    302. 

  302. "dconst : $$6 const",
    303. 

  303. "const : CHAR_CONST",
    304. 

  304. "const : TERMSTRING",
    305. 

  305. "const : BYTE_CONST",
    306. 

  306. "const : SHORT_CONST",
    307. 

  307. "const : INT_CONST",
    308. 

  308. "const : FLOAT_CONST",
    309. 

  309. "const : DOUBLE_CONST",
    310. 

  310. "const : FILLVALUE",
    311. 

  311. };
    312. 

  312. #endif
    313. 

  313. #ifndef YYSTYPE
    314. 

  314. typedef int YYSTYPE;
    315. 

  315. #endif
    316. 

  316. #if YYDEBUG
    317. 

  317. #include <stdio.h>
    318. 

  318. #endif
    319. 

  319. #ifdef YYSTACKSIZE
    320. 

  320. #undef YYMAXDEPTH
    321. 

  321. #define YYMAXDEPTH YYSTACKSIZE
    322. 

  322. #else
    323. 

  323. #ifdef YYMAXDEPTH
    324. 

  324. #define YYSTACKSIZE YYMAXDEPTH
    325. 

  325. #else
    326. 

  326. #define YYSTACKSIZE 10000
    327. 

  327. #define YYMAXDEPTH 10000
    328. 

  328. #endif
    329. 

  329. #endif
    330. 

  330. #define YYINITSTACKSIZE 200
    331. 

  331. int yydebug;
    332. 

  332. int yynerrs;
    333. 

  333. int yyerrflag;
    334. 

  334. int yychar;
    335. 

  335. short *yyssp;
    336. 

  336. YYSTYPE *yyvsp;
    337. 

  337. YYSTYPE yyval;
    338. 

  338. YYSTYPE yylval;
    339. 

  339. short *yyss;
    340. 

  340. short *yysslim;
    341. 

  341. YYSTYPE *yyvs;
    342. 

  342. int yystacksize;
    343. 

  343. #line 767 "ncgen.y"
    344. 

  344. 

  345. /* PROGRAMS */
    346. 

  346. 

  347. #ifdef vms
    348. 

  348. void
    349. 

  349. #else
    350. 

  350. int
    351. 

  351. #endif
    352. 

  352. yyerror(	/* called for yacc syntax error */
    353. 

  353.      char *s)
    354. 

  354. {
    355. 

  355. 	derror(s);
    356. 

  356. #ifndef vms
    357. 

  357. 	return -1;
    358. 

  358. #endif
    359. 

  359. }
    360. 

  360. 

  361. /* undefine yywrap macro, in case we are using bison instead of yacc */
    362. 

  362. #ifdef yywrap
    363. 

  363. #undef yywrap
    364. 

  364. #endif
    365. 

  365. 

  366. int
    367. 

  367. yywrap(void)			/* returns 1 on EOF if no more input */
    368. 

  368. {
    369. 

  369.     return  1;
    370. 

  370. }
    371. 

  371. 

  372. 

  373. /* Symbol table operations for ncgen tool */
    374. 

  374. 

  375. YYSTYPE lookup(       /* find sname in symbol table (linear search) */
    376. 

  376. 	const char *sname)
    377. 

  377. {
    378. 

  378.     YYSTYPE sp;
    379. 

  379.     for (sp = symlist; sp != (YYSTYPE) 0; sp = sp -> next)
    380. 

  380. 	if (STREQ(sp -> name, sname)) {
    381. 

  381. 	    return sp;
    382. 

  382. 	}
    383. 

  383.     return 0;			/* 0 ==> not found */
    384. 

  384. }
    385. 

  385. 

  386. YYSTYPE install(  /* install sname in symbol table */
    387. 

  387. 	const char *sname)
    388. 

  388. {
    389. 

  389.     YYSTYPE sp;
    390. 

  390. 

  391.     sp = (YYSTYPE) emalloc (sizeof (struct Symbol));
    392. 

  392.     sp -> name = (char *) emalloc (strlen (sname) + 1);/* +1 for '\0' */
    393. 

  393.     (void) strcpy (sp -> name, sname);
    394. 

  394.     sp -> next = symlist;	/* put at front of list */
    395. 

  395.     sp -> is_dim = 0;
    396. 

  396.     sp -> is_var = 0;
    397. 

  397.     sp -> is_att = 0;
    398. 

  398.     symlist = sp;
    399. 

  399.     return sp;
    400. 

  400. }
    401. 

  401. 

  402. void
    403. 

  403. clearout(void)	/* reset symbol table to empty */
    404. 

  404. {
    405. 

  405.     YYSTYPE sp, tp;
    406. 

  406.     for (sp = symlist; sp != (YYSTYPE) 0;) {
    407. 

  407. 	tp = sp -> next;
    408. 

  408. 	free (sp -> name);
    409. 

  409. 	free ((char *) sp);
    410. 

  410. 	sp = tp;
    411. 

  411.     }
    412. 

  412.     symlist = 0;
    413. 

  413. }
    414. 

  414. 

  415. /* get lexical input routine generated by lex  */
    416. 

  416. #include "ncgenyy.c"
    417. 

  417. #line 418 "y.tab.c"
    418. 

  418. /* allocate initial stack or double stack size, up to YYMAXDEPTH */
    419. 

  419. static int yygrowstack()
    420. 

  420. {
    421. 

  421.     int newsize, i;
    422. 

  422.     short *newss;
    423. 

  423.     YYSTYPE *newvs;
    424. 

  424. 

  425.     if ((newsize = yystacksize) == 0)
    426. 

  426.         newsize = YYINITSTACKSIZE;
    427. 

  427.     else if (newsize >= YYMAXDEPTH)
    428. 

  428.         return -1;
    429. 

  429.     else if ((newsize *= 2) > YYMAXDEPTH)
    430. 

  430.         newsize = YYMAXDEPTH;
    431. 

  431.     i = yyssp - yyss;
    432. 

  432.     newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
    433. 

  433.       (short *)malloc(newsize * sizeof *newss);
    434. 

  434.     if (newss == NULL)
    435. 

  435.         return -1;
    436. 

  436.     yyss = newss;
    437. 

  437.     yyssp = newss + i;
    438. 

  438.     newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
    439. 

  439.       (YYSTYPE *)malloc(newsize * sizeof *newvs);
    440. 

  440.     if (newvs == NULL)
    441. 

  441.         return -1;
    442. 

  442.     yyvs = newvs;
    443. 

  443.     yyvsp = newvs + i;
    444. 

  444.     yystacksize = newsize;
    445. 

  445.     yysslim = yyss + newsize - 1;
    446. 

  446.     return 0;
    447. 

  447. }
    448. 

  448. 

  449. #define YYABORT goto yyabort
    450. 

  450. #define YYREJECT goto yyabort
    451. 

  451. #define YYACCEPT goto yyaccept
    452. 

  452. #define YYERROR goto yyerrlab
    453. 

  453. 

  454. #ifndef YYPARSE_PARAM
    455. 

  455. #if defined(__cplusplus) || __STDC__
    456. 

  456. #define YYPARSE_PARAM_ARG void
    457. 

  457. #define YYPARSE_PARAM_DECL
    458. 

  458. #else	/* ! ANSI-C/C++ */
    459. 

  459. #define YYPARSE_PARAM_ARG
    460. 

  460. #define YYPARSE_PARAM_DECL
    461. 

  461. #endif	/* ANSI-C/C++ */
    462. 

  462. #else	/* YYPARSE_PARAM */
    463. 

  463. #ifndef YYPARSE_PARAM_TYPE
    464. 

  464. #define YYPARSE_PARAM_TYPE void *
    465. 

  465. #endif
    466. 

  466. #if defined(__cplusplus) || __STDC__
    467. 

  467. #define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
    468. 

  468. #define YYPARSE_PARAM_DECL
    469. 

  469. #else	/* ! ANSI-C/C++ */
    470. 

  470. #define YYPARSE_PARAM_ARG YYPARSE_PARAM
    471. 

  471. #define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
    472. 

  472. #endif	/* ANSI-C/C++ */
    473. 

  473. #endif	/* ! YYPARSE_PARAM */
    474. 

  474. 

  475. int
    476. 

  476. yyparse (YYPARSE_PARAM_ARG)
    477. 

  477.     YYPARSE_PARAM_DECL
    478. 

  478. {
    479. 

  479.     register int yym, yyn, yystate;
    480. 

  480. #if YYDEBUG
    481. 

  481.     register const char *yys;
    482. 

  482. 

  483.     if ((yys = getenv("YYDEBUG")))
    484. 

  484.     {
    485. 

  485.         yyn = *yys;
    486. 

  486.         if (yyn >= '0' && yyn <= '9')
    487. 

  487.             yydebug = yyn - '0';
    488. 

  488.     }
    489. 

  489. #endif
    490. 

  490. 

  491.     yynerrs = 0;
    492. 

  492.     yyerrflag = 0;
    493. 

  493.     yychar = (-1);
    494. 

  494. 

  495.     if (yyss == NULL && yygrowstack()) goto yyoverflow;
    496. 

  496.     yyssp = yyss;
    497. 

  497.     yyvsp = yyvs;
    498. 

  498.     *yyssp = yystate = 0;
    499. 

  499. 

  500. yyloop:
    501. 

  501.     if ((yyn = yydefred[yystate])) goto yyreduce;
    502. 

  502.     if (yychar < 0)
    503. 

  503.     {
    504. 

  504.         if ((yychar = yylex()) < 0) yychar = 0;
    505. 

  505. #if YYDEBUG
    506. 

  506.         if (yydebug)
    507. 

  507.         {
    508. 

  508.             yys = 0;
    509. 

  509.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
    510. 

  510.             if (!yys) yys = "illegal-symbol";
    511. 

  511.             printf("%sdebug: state %d, reading %d (%s)\n",
    512. 

  512.                     YYPREFIX, yystate, yychar, yys);
    513. 

  513.         }
    514. 

  514. #endif
    515. 

  515.     }
    516. 

  516.     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
    517. 

  517.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    518. 

  518.     {
    519. 

  519. #if YYDEBUG
    520. 

  520.         if (yydebug)
    521. 

  521.             printf("%sdebug: state %d, shifting to state %d\n",
    522. 

  522.                     YYPREFIX, yystate, yytable[yyn]);
    523. 

  523. #endif
    524. 

  524.         if (yyssp >= yysslim && yygrowstack())
    525. 

  525.         {
    526. 

  526.             goto yyoverflow;
    527. 

  527.         }
    528. 

  528.         *++yyssp = yystate = yytable[yyn];
    529. 

  529.         *++yyvsp = yylval;
    530. 

  530.         yychar = (-1);
    531. 

  531.         if (yyerrflag > 0)  --yyerrflag;
    532. 

  532.         goto yyloop;
    533. 

  533.     }
    534. 

  534.     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
    535. 

  535.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    536. 

  536.     {
    537. 

  537.         yyn = yytable[yyn];
    538. 

  538.         goto yyreduce;
    539. 

  539.     }
    540. 

  540.     if (yyerrflag) goto yyinrecovery;
    541. 

  541. #if defined(lint) || defined(__GNUC__)
    542. 

  542.     goto yynewerror;
    543. 

  543. #endif
    544. 

  544. yynewerror:
    545. 

  545.     yyerror("syntax error");
    546. 

  546. #if defined(lint) || defined(__GNUC__)
    547. 

  547.     goto yyerrlab;
    548. 

  548. #endif
    549. 

  549. yyerrlab:
    550. 

  550.     ++yynerrs;
    551. 

  551. yyinrecovery:
    552. 

  552.     if (yyerrflag < 3)
    553. 

  553.     {
    554. 

  554.         yyerrflag = 3;
    555. 

  555.         for (;;)
    556. 

  556.         {
    557. 

  557.             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
    558. 

  558.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
    559. 

  559.             {
    560. 

  560. #if YYDEBUG
    561. 

  561.                 if (yydebug)
    562. 

  562.                     printf("%sdebug: state %d, error recovery shifting\
    563. 

  563.  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
    564. 

  564. #endif
    565. 

  565.                 if (yyssp >= yysslim && yygrowstack())
    566. 

  566.                 {
    567. 

  567.                     goto yyoverflow;
    568. 

  568.                 }
    569. 

  569.                 *++yyssp = yystate = yytable[yyn];
    570. 

  570.                 *++yyvsp = yylval;
    571. 

  571.                 goto yyloop;
    572. 

  572.             }
    573. 

  573.             else
    574. 

  574.             {
    575. 

  575. #if YYDEBUG
    576. 

  576.                 if (yydebug)
    577. 

  577.                     printf("%sdebug: error recovery discarding state %d\n",
    578. 

  578.                             YYPREFIX, *yyssp);
    579. 

  579. #endif
    580. 

  580.                 if (yyssp <= yyss) goto yyabort;
    581. 

  581.                 --yyssp;
    582. 

  582.                 --yyvsp;
    583. 

  583.             }
    584. 

  584.         }
    585. 

  585.     }
    586. 

  586.     else
    587. 

  587.     {
    588. 

  588.         if (yychar == 0) goto yyabort;
    589. 

  589. #if YYDEBUG
    590. 

  590.         if (yydebug)
    591. 

  591.         {
    592. 

  592.             yys = 0;
    593. 

  593.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
    594. 

  594.             if (!yys) yys = "illegal-symbol";
    595. 

  595.             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
    596. 

  596.                     YYPREFIX, yystate, yychar, yys);
    597. 

  597.         }
    598. 

  598. #endif
    599. 

  599.         yychar = (-1);
    600. 

  600.         goto yyloop;
    601. 

  601.     }
    602. 

  602. yyreduce:
    603. 

  603. #if YYDEBUG
    604. 

  604.     if (yydebug)
    605. 

  605.         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
    606. 

  606.                 YYPREFIX, yystate, yyn, yyrule[yyn]);
    607. 

  607. #endif
    608. 

  608.     yym = yylen[yyn];
    609. 

  609.     yyval = yyvsp[1-yym];
    610. 

  610.     switch (yyn)
    611. 

  611.     {
    612. 

  612. case 1:
    613. 

  613. #line 97 "ncgen.y"
    614. 

  614. { init_netcdf(); }
    615. 

  615. break;
    616. 

  616. case 2:
    617. 

  617. #line 100 "ncgen.y"
    618. 

  618. {
    619. 

  619. 		       if (derror_count == 0)
    620. 

  620. 			 define_netcdf(netcdfname);
    621. 

  621. 		       if (derror_count > 0)
    622. 

  622. 			   exit(6);
    623. 

  623. 		   }
    624. 

  624. break;
    625. 

  625. case 3:
    626. 

  626. #line 108 "ncgen.y"
    627. 

  627. {
    628. 

  628. 		       if (derror_count == 0)
    629. 

  629. 			 close_netcdf();
    630. 

  630. 		   }
    631. 

  631. break;
    632. 

  632. case 10:
    633. 

  633. #line 123 "ncgen.y"
    634. 

  634. { if (int_val <= 0)
    635. 

  635. 			 derror("dimension length must be positive");
    636. 

  636. 		     dims[ndims].size = int_val;
    637. 

  637. 		     ndims++;
    638. 

  638. 		   }
    639. 

  639. break;
    640. 

  640. case 11:
    641. 

  641. #line 129 "ncgen.y"
    642. 

  642. { /* for rare case where 2^31 < dimsize < 2^32 */
    643. 

  643. 		       if (double_val <= 0)
    644. 

  644. 			 derror("dimension length must be positive");
    645. 

  645. 		       if (double_val > 4294967295.0)
    646. 

  646. 			 derror("dimension too large");
    647. 

  647. 		       if (double_val - (size_t) double_val > 0)
    648. 

  648. 			 derror("dimension length must be an integer");
    649. 

  649. 		       dims[ndims].size = (size_t) double_val;
    650. 

  650. 		       ndims++;
    651. 

  651.                    }
    652. 

  652. break;
    653. 

  653. case 12:
    654. 

  654. #line 140 "ncgen.y"
    655. 

  655. {  if (rec_dim != -1)
    656. 

  656. 			 derror("only one NC_UNLIMITED dimension allowed");
    657. 

  657. 		     rec_dim = ndims; /* the unlimited (record) dimension */
    658. 

  658. 		     dims[ndims].size = NC_UNLIMITED;
    659. 

  659. 		     ndims++;
    660. 

  660. 		   }
    661. 

  661. break;
    662. 

  662. case 13:
    663. 

  663. #line 148 "ncgen.y"
    664. 

  664. { if (yyvsp[0]->is_dim == 1) {
    665. 

  665. 		        derror( "duplicate dimension declaration for %s",
    666. 

  666. 		                yyvsp[0]->name);
    667. 

  667. 		     }
    668. 

  668. 	             yyvsp[0]->is_dim = 1;
    669. 

  669. 		     yyvsp[0]->dnum = ndims;
    670. 

  670. 		     /* make sure dims array will hold dimensions */
    671. 

  671. 		     grow_darray(ndims,  /* must hold ndims+1 dims */
    672. 

  672. 				 &dims); /* grow as needed */
    673. 

  673. 		     dims[ndims].name = (char *) emalloc(strlen(yyvsp[0]->name)+1);
    674. 

  674. 		     (void) strcpy(dims[ndims].name, yyvsp[0]->name);
    675. 

  675. 		     /* name for use in generated Fortran and C variables */
    676. 

  676. 		     dims[ndims].lname = decodify(yyvsp[0]->name);
    677. 

  677. 		   }
    678. 

  678. break;
    679. 

  679. case 26:
    680. 

  680. #line 181 "ncgen.y"
    681. 

  681. { type_code = NC_BYTE; }
    682. 

  682. break;
    683. 

  683. case 27:
    684. 

  684. #line 182 "ncgen.y"
    685. 

  685. { type_code = NC_CHAR; }
    686. 

  686. break;
    687. 

  687. case 28:
    688. 

  688. #line 183 "ncgen.y"
    689. 

  689. { type_code = NC_SHORT; }
    690. 

  690. break;
    691. 

  691. case 29:
    692. 

  692. #line 184 "ncgen.y"
    693. 

  693. { type_code = NC_INT; }
    694. 

  694. break;
    695. 

  695. case 30:
    696. 

  696. #line 185 "ncgen.y"
    697. 

  697. { type_code = NC_FLOAT; }
    698. 

  698. break;
    699. 

  699. case 31:
    700. 

  700. #line 186 "ncgen.y"
    701. 

  701. { type_code = NC_DOUBLE; }
    702. 

  702. break;
    703. 

  703. case 34:
    704. 

  704. #line 192 "ncgen.y"
    705. 

  705. {
    706. 

  706. 		    static struct vars dummyvar;
    707. 

  707. 

  708. 		    dummyvar.name = "dummy";
    709. 

  709. 		    dummyvar.type = NC_DOUBLE;
    710. 

  710. 		    dummyvar.ndims = 0;
    711. 

  711. 		    dummyvar.dims = 0;
    712. 

  712. 		    dummyvar.fill_value.doublev = NC_FILL_DOUBLE;
    713. 

  713. 		    dummyvar.has_data = 0;
    714. 

  714. 

  715. 		    nvdims = 0;
    716. 

  716. 		    /* make sure variable not re-declared */
    717. 

  717. 		    if (yyvsp[0]->is_var == 1) {
    718. 

  718. 		       derror( "duplicate variable declaration for %s",
    719. 

  719. 		               yyvsp[0]->name);
    720. 

  720. 		    }
    721. 

  721. 	            yyvsp[0]->is_var = 1;
    722. 

  722. 		    yyvsp[0]->vnum = nvars;
    723. 

  723. 		    /* make sure vars array will hold variables */
    724. 

  724. 		    grow_varray(nvars,  /* must hold nvars+1 vars */
    725. 

  725. 				&vars); /* grow as needed */
    726. 

  726. 		    vars[nvars] = dummyvar; /* to make Purify happy */
    727. 

  727. 		    vars[nvars].name = (char *) emalloc(strlen(yyvsp[0]->name)+1);
    728. 

  728. 		    (void) strcpy(vars[nvars].name, yyvsp[0]->name);
    729. 

  729. 		    /* name for use in generated Fortran and C variables */
    730. 

  730. 		    vars[nvars].lname = decodify(yyvsp[0]->name);
    731. 

  731. 		    vars[nvars].type = type_code;
    732. 

  732. 		    /* set default fill value.  You can override this with
    733. 

  733. 		     * the variable attribute "_FillValue". */
    734. 

  734. 		    nc_getfill(type_code, &vars[nvars].fill_value);
    735. 

  735. 		    vars[nvars].has_data = 0; /* has no data (yet) */
    736. 

  736. 		   }
    737. 

  737. break;
    738. 

  738. case 35:
    739. 

  739. #line 225 "ncgen.y"
    740. 

  740. {
    741. 

  741. 		    vars[nvars].ndims = nvdims;
    742. 

  742. 		    nvars++;
    743. 

  743. 		   }
    744. 

  744. break;
    745. 

  745. case 41:
    746. 

  746. #line 239 "ncgen.y"
    747. 

  747. {
    748. 

  748. 		    if (nvdims >= NC_MAX_VAR_DIMS) {
    749. 

  749. 		       derror("%s has too many dimensions",vars[nvars].name);
    750. 

  750. 		    }
    751. 

  751. 		    if (yyvsp[0]->is_dim == 1)
    752. 

  752. 		       dimnum = yyvsp[0]->dnum;
    753. 

  753. 		    else {
    754. 

  754. 		       derror( "%s is not declared as a dimension",
    755. 

  755. 			       yyvsp[0]->name);
    756. 

  756. 	               dimnum = ndims;
    757. 

  757. 		    }
    758. 

  758. 		    if (rec_dim != -1 && dimnum == rec_dim && nvdims != 0) {
    759. 

  759. 		       derror("unlimited dimension must be first");
    760. 

  760. 		    }
    761. 

  761. 		    grow_iarray(nvdims, /* must hold nvdims+1 ints */
    762. 

  762. 				&vars[nvars].dims); /* grow as needed */
    763. 

  763. 		    vars[nvars].dims[nvdims] = dimnum;
    764. 

  764.                     nvdims++;
    765. 

  765. 		   }
    766. 

  766. break;
    767. 

  767. case 42:
    768. 

  768. #line 260 "ncgen.y"
    769. 

  769. {
    770. 

  770. 		       valnum = 0;
    771. 

  771. 		       valtype = NC_UNSPECIFIED;
    772. 

  772. 		       /* get a large block for attributes, realloc later */
    773. 

  773. 		       att_space = emalloc(MAX_NC_ATTSIZE);
    774. 

  774. 		       /* make all kinds of pointers point to it */
    775. 

  775. 		       char_valp = (char *) att_space;
    776. 

  776. 		       byte_valp = (signed char *) att_space;
    777. 

  777. 		       short_valp = (short *) att_space;
    778. 

  778. 		       int_valp = (int *) att_space;
    779. 

  779. 		       float_valp = (float *) att_space;
    780. 

  780. 		       double_valp = (double *) att_space;
    781. 

  781. 		   }
    782. 

  782. break;
    783. 

  783. case 43:
    784. 

  784. #line 274 "ncgen.y"
    785. 

  785. {
    786. 

  786. 		       {	/* check if duplicate attribute for this var */
    787. 

  787. 			   int i;
    788. 

  788. 			   for(i=0; i<natts; i++) { /* expensive */
    789. 

  789. 			       if(atts[i].var == varnum &&
    790. 

  790. 				  STREQ(atts[i].name,atts[natts].name)) {
    791. 

  791. 				   derror("duplicate attribute %s:%s",
    792. 

  792. 					  vars[varnum].name,atts[natts].name);
    793. 

  793. 			       }
    794. 

  794. 			   }
    795. 

  795. 		       }
    796. 

  796. 		       atts[natts].var = varnum ;
    797. 

  797. 		       atts[natts].type = valtype;
    798. 

  798. 		       atts[natts].len = valnum;
    799. 

  799. 		       /* shrink space down to what was really needed */
    800. 

  800. 		       att_space = erealloc(att_space, valnum*nctypesize(valtype));
    801. 

  801. 		       atts[natts].val = att_space;
    802. 

  802. 		       if (STREQ(atts[natts].name, _FillValue) &&
    803. 

  803. 			   atts[natts].var != NC_GLOBAL) {
    804. 

  804. 			   nc_putfill(atts[natts].type,
    805. 

  805. 				       atts[natts].val,
    806. 

  806. 				       &vars[atts[natts].var].fill_value);
    807. 

  807. 			   if(atts[natts].type != vars[atts[natts].var].type) {
    808. 

  808. 			       derror("variable %s: %s type mismatch",
    809. 

  809. 				      vars[atts[natts].var].name, _FillValue);
    810. 

  810. 			   }
    811. 

  811. 		       }
    812. 

  812. 		       natts++;
    813. 

  813. 		   }
    814. 

  814. break;
    815. 

  815. case 45:
    816. 

  816. #line 306 "ncgen.y"
    817. 

  817. {
    818. 

  818. 		    varnum = NC_GLOBAL;  /* handle of "global" attribute */
    819. 

  819. 		   }
    820. 

  820. break;
    821. 

  821. case 46:
    822. 

  822. #line 312 "ncgen.y"
    823. 

  823. { if (yyvsp[0]->is_var == 1)
    824. 

  824. 		       varnum = yyvsp[0]->vnum;
    825. 

  825. 		    else {
    826. 

  826. 		      derror("%s not declared as a variable, fatal error",
    827. 

  827. 			     yyvsp[0]->name);
    828. 

  828. 		      YYABORT;
    829. 

  829. 		      }
    830. 

  830. 		   }
    831. 

  831. break;
    832. 

  832. case 47:
    833. 

  833. #line 322 "ncgen.y"
    834. 

  834. {
    835. 

  835. 		       /* make sure atts array will hold attributes */
    836. 

  836. 		       grow_aarray(natts,  /* must hold natts+1 atts */
    837. 

  837. 				   &atts); /* grow as needed */
    838. 

  838. 		       atts[natts].name = (char *) emalloc(strlen(yyvsp[0]->name)+1);
    839. 

  839. 		       (void) strcpy(atts[natts].name,yyvsp[0]->name);
    840. 

  840. 		       /* name for use in generated Fortran and C variables */
    841. 

  841. 		       atts[natts].lname = decodify(yyvsp[0]->name);
    842. 

  842. 		   }
    843. 

  843. break;
    844. 

  844. case 50:
    845. 

  845. #line 336 "ncgen.y"
    846. 

  846. {
    847. 

  847. 		    if (valtype == NC_UNSPECIFIED)
    848. 

  848. 		      valtype = atype_code;
    849. 

  849. 		    if (valtype != atype_code)
    850. 

  850. 		      derror("values for attribute must be all of same type");
    851. 

  851. 		   }
    852. 

  852. break;
    853. 

  853. case 51:
    854. 

  854. #line 345 "ncgen.y"
    855. 

  855. {
    856. 

  856. 		       atype_code = NC_CHAR;
    857. 

  857. 		       *char_valp++ = char_val;
    858. 

  858. 		       valnum++;
    859. 

  859. 		   }
    860. 

  860. break;
    861. 

  861. case 52:
    862. 

  862. #line 351 "ncgen.y"
    863. 

  863. {
    864. 

  864. 		       atype_code = NC_CHAR;
    865. 

  865. 		       {
    866. 

  866. 			   /* don't null-terminate attribute strings */
    867. 

  867. 			   size_t len = strlen(termstring);
    868. 

  868. 			   if (len == 0) /* need null if that's only value */
    869. 

  869. 			       len = 1;
    870. 

  870. 			   (void)strncpy(char_valp,termstring,len);
    871. 

  871. 			   valnum += len;
    872. 

  872. 			   char_valp += len;
    873. 

  873. 		       }
    874. 

  874. 		   }
    875. 

  875. break;
    876. 

  876. case 53:
    877. 

  877. #line 364 "ncgen.y"
    878. 

  878. {
    879. 

  879. 		       atype_code = NC_BYTE;
    880. 

  880. 		       *byte_valp++ = byte_val;
    881. 

  881. 		       valnum++;
    882. 

  882. 		   }
    883. 

  883. break;
    884. 

  884. case 54:
    885. 

  885. #line 370 "ncgen.y"
    886. 

  886. {
    887. 

  887. 		       atype_code = NC_SHORT;
    888. 

  888. 		       *short_valp++ = short_val;
    889. 

  889. 		       valnum++;
    890. 

  890. 		   }
    891. 

  891. break;
    892. 

  892. case 55:
    893. 

  893. #line 376 "ncgen.y"
    894. 

  894. {
    895. 

  895. 		       atype_code = NC_INT;
    896. 

  896. 		       *int_valp++ = int_val;
    897. 

  897. 		       valnum++;
    898. 

  898. 		   }
    899. 

  899. break;
    900. 

  900. case 56:
    901. 

  901. #line 382 "ncgen.y"
    902. 

  902. {
    903. 

  903. 		       atype_code = NC_FLOAT;
    904. 

  904. 		       *float_valp++ = float_val;
    905. 

  905. 		       valnum++;
    906. 

  906. 		   }
    907. 

  907. break;
    908. 

  908. case 57:
    909. 

  909. #line 388 "ncgen.y"
    910. 

  910. {
    911. 

  911. 		       atype_code = NC_DOUBLE;
    912. 

  912. 		       *double_valp++ = double_val;
    913. 

  913. 		       valnum++;
    914. 

  914. 		   }
    915. 

  915. break;
    916. 

  916. case 63:
    917. 

  917. #line 404 "ncgen.y"
    918. 

  918. {
    919. 

  919. 		       valtype = vars[varnum].type; /* variable type */
    920. 

  920. 		       valnum = 0;	/* values accumulated for variable */
    921. 

  921. 		       vars[varnum].has_data = 1;
    922. 

  922. 		       /* compute dimensions product */
    923. 

  923. 		       var_size = nctypesize(valtype);
    924. 

  924. 		       if (vars[varnum].ndims == 0) { /* scalar */
    925. 

  925. 			   var_len = 1;
    926. 

  926. 		       } else if (vars[varnum].dims[0] == rec_dim) {
    927. 

  927. 			   var_len = 1; /* one record for unlimited vars */
    928. 

  928. 		       } else {
    929. 

  929. 			   var_len = dims[vars[varnum].dims[0]].size;
    930. 

  930. 		       }
    931. 

  931. 		       for(dimnum = 1; dimnum < vars[varnum].ndims; dimnum++)
    932. 

  932. 			 var_len = var_len*dims[vars[varnum].dims[dimnum]].size;
    933. 

  933. 		       /* allocate memory for variable data */
    934. 

  934. 		       if (var_len*var_size != (size_t)(var_len*var_size)) {
    935. 

  935. 			   derror("variable %s too large for memory",
    936. 

  936. 				  vars[varnum].name);
    937. 

  937. 			   exit(9);
    938. 

  938. 		       }
    939. 

  939. 		       rec_len = var_len;
    940. 

  940. 		       rec_start = malloc ((size_t)(rec_len*var_size));
    941. 

  941. 		       if (rec_start == 0) {
    942. 

  942. 			   derror ("out of memory\n");
    943. 

  943. 			   exit(3);
    944. 

  944. 		       }
    945. 

  945. 		       rec_cur = rec_start;
    946. 

  946. 		       switch (valtype) {
    947. 

  947. 			 case NC_CHAR:
    948. 

  948. 			   char_valp = (char *) rec_start;
    949. 

  949. 			   break;
    950. 

  950. 			 case NC_BYTE:
    951. 

  951. 			   byte_valp = (signed char *) rec_start;
    952. 

  952. 			   break;
    953. 

  953. 			 case NC_SHORT:
    954. 

  954. 			   short_valp = (short *) rec_start;
    955. 

  955. 			   break;
    956. 

  956. 			 case NC_INT:
    957. 

  957. 			   int_valp = (int *) rec_start;
    958. 

  958. 			   break;
    959. 

  959. 			 case NC_FLOAT:
    960. 

  960. 			   float_valp = (float *) rec_start;
    961. 

  961. 			   break;
    962. 

  962. 			 case NC_DOUBLE:
    963. 

  963. 			   double_valp = (double *) rec_start;
    964. 

  964. 			   break;
    965. 

  965. 		       }
    966. 

  966. 		 }
    967. 

  967. break;
    968. 

  968. case 64:
    969. 

  969. #line 454 "ncgen.y"
    970. 

  970. {
    971. 

  971. 		       if (valnum < var_len) { /* leftovers */
    972. 

  972. 			   nc_fill(valtype,
    973. 

  973. 				    var_len - valnum,
    974. 

  974. 				    rec_cur,
    975. 

  975. 				    vars[varnum].fill_value);
    976. 

  976. 		       }
    977. 

  977. 		       /* put out var_len values */
    978. 

  978. 		       /* vars[varnum].nrecs = valnum / rec_len; */
    979. 

  979. 		       vars[varnum].nrecs = var_len / rec_len;
    980. 

  980. 		       if (derror_count == 0)
    981. 

  981. 			   put_variable(rec_start);
    982. 

  982. 		       free ((char *) rec_start);
    983. 

  983. 		 }
    984. 

  984. break;
    985. 

  985. case 67:
    986. 

  986. #line 473 "ncgen.y"
    987. 

  987. {
    988. 

  988. 		       if(valnum >= var_len) {
    989. 

  989. 			   if (vars[varnum].dims[0] != rec_dim) { /* not recvar */
    990. 

  990. 			       derror("too many values for this variable, %d >= %d",
    991. 

  991. 				      valnum, var_len);
    992. 

  992. 			       exit (4);
    993. 

  993. 			   } else { /* a record variable, so grow data
    994. 

  994. 				      container and increment var_len by
    995. 

  995. 				      multiple of record size */
    996. 

  996. 			       ptrdiff_t rec_inc = (char *)rec_cur
    997. 

  997. 				   - (char *)rec_start;
    998. 

  998. 			       var_len = rec_len * (1 + valnum / rec_len);
    999. 

  999. 			       rec_start = erealloc(rec_start, var_len*var_size);
    1000. 

  1000. 			       rec_cur = (char *)rec_start + rec_inc;
    1001. 

  1001. 			       char_valp = (char *) rec_cur;
    1002. 

  1002. 			       byte_valp = (signed char *) rec_cur;
    1003. 

  1003. 			       short_valp = (short *) rec_cur;
    1004. 

  1004. 			       int_valp = (int *) rec_cur;
    1005. 

  1005. 			       float_valp = (float *) rec_cur;
    1006. 

  1006. 			       double_valp = (double *) rec_cur;
    1007. 

  1007. 			   }
    1008. 

  1008. 		       }
    1009. 

  1009. 		       not_a_string = 1;
    1010. 

  1010.                    }
    1011. 

  1011. break;
    1012. 

  1012. case 68:
    1013. 

  1013. #line 498 "ncgen.y"
    1014. 

  1014. {
    1015. 

  1015. 		       if (not_a_string) {
    1016. 

  1016. 			   switch (valtype) {
    1017. 

  1017. 			     case NC_CHAR:
    1018. 

  1018. 			       rec_cur = (void *) char_valp;
    1019. 

  1019. 			       break;
    1020. 

  1020. 			     case NC_BYTE:
    1021. 

  1021. 			       rec_cur = (void *) byte_valp;
    1022. 

  1022. 			       break;
    1023. 

  1023. 			     case NC_SHORT:
    1024. 

  1024. 			       rec_cur = (void *) short_valp;
    1025. 

  1025. 			       break;
    1026. 

  1026. 			     case NC_INT:
    1027. 

  1027. 			       rec_cur = (void *) int_valp;
    1028. 

  1028. 			       break;
    1029. 

  1029. 			     case NC_FLOAT:
    1030. 

  1030. 			       rec_cur = (void *) float_valp;
    1031. 

  1031. 			       break;
    1032. 

  1032. 			     case NC_DOUBLE:
    1033. 

  1033. 			       rec_cur = (void *) double_valp;
    1034. 

  1034. 			       break;
    1035. 

  1035. 			   }
    1036. 

  1036. 		       }
    1037. 

  1037. 		   }
    1038. 

  1038. break;
    1039. 

  1039. case 69:
    1040. 

  1040. #line 525 "ncgen.y"
    1041. 

  1041. {
    1042. 

  1042. 		       atype_code = NC_CHAR;
    1043. 

  1043. 		       switch (valtype) {
    1044. 

  1044. 			 case NC_CHAR:
    1045. 

  1045. 			   *char_valp++ = char_val;
    1046. 

  1046. 			   break;
    1047. 

  1047. 			 case NC_BYTE:
    1048. 

  1048. 			   *byte_valp++ = char_val;
    1049. 

  1049. 			   break;
    1050. 

  1050. 			 case NC_SHORT:
    1051. 

  1051. 			   *short_valp++ = char_val;
    1052. 

  1052. 			   break;
    1053. 

  1053. 			 case NC_INT:
    1054. 

  1054. 			   *int_valp++ = char_val;
    1055. 

  1055. 			   break;
    1056. 

  1056. 			 case NC_FLOAT:
    1057. 

  1057. 			   *float_valp++ = char_val;
    1058. 

  1058. 			   break;
    1059. 

  1059. 			 case NC_DOUBLE:
    1060. 

  1060. 			   *double_valp++ = char_val;
    1061. 

  1061. 			   break;
    1062. 

  1062. 		       }
    1063. 

  1063. 		       valnum++;
    1064. 

  1064. 		   }
    1065. 

  1065. break;
    1066. 

  1066. case 70:
    1067. 

  1067. #line 550 "ncgen.y"
    1068. 

  1068. {
    1069. 

  1069. 		       not_a_string = 0;
    1070. 

  1070. 		       atype_code = NC_CHAR;
    1071. 

  1071. 		       {
    1072. 

  1072. 			   size_t len = strlen(termstring);
    1073. 

  1073. 

  1074. 			   if(valnum + len > var_len) {
    1075. 

  1075. 			       if (vars[varnum].dims[0] != rec_dim) {
    1076. 

  1076. 				   derror("too many values for this variable, %d>%d", 
    1077. 

  1077. 					  valnum+len, var_len);
    1078. 

  1078. 				   exit (5);
    1079. 

  1079. 			       } else {/* a record variable so grow it */
    1080. 

  1080. 				   ptrdiff_t rec_inc = (char *)rec_cur
    1081. 

  1081. 				       - (char *)rec_start;
    1082. 

  1082. 				   var_len += rec_len * (len + valnum - var_len)/rec_len;
    1083. 

  1083. 				   rec_start = erealloc(rec_start, var_len*var_size);
    1084. 

  1084. 				   rec_cur = (char *)rec_start + rec_inc;
    1085. 

  1085. 				   char_valp = (char *) rec_cur;
    1086. 

  1086. 			       }
    1087. 

  1087. 			   }
    1088. 

  1088. 			   switch (valtype) {
    1089. 

  1089. 			     case NC_CHAR:
    1090. 

  1090. 			       {
    1091. 

  1091. 				   int ld;
    1092. 

  1092. 				   size_t i, sl;
    1093. 

  1093. 				   (void)strncpy(char_valp,termstring,len);
    1094. 

  1094. 				   ld = vars[varnum].ndims-1;
    1095. 

  1095. 				   if (ld > 0) {/* null-fill to size of last dim */
    1096. 

  1096. 				       sl = dims[vars[varnum].dims[ld]].size;
    1097. 

  1097. 				       for (i =len;i<sl;i++)
    1098. 

  1098. 					   char_valp[i] = '\0';
    1099. 

  1099. 				       if (sl < len)
    1100. 

  1100. 					   sl = len;
    1101. 

  1101. 				       valnum += sl;
    1102. 

  1102. 				       char_valp += sl;
    1103. 

  1103. 				   } else { /* scalar or 1D strings */
    1104. 

  1104. 				       valnum += len;
    1105. 

  1105. 				       char_valp += len;
    1106. 

  1106. 				   }
    1107. 

  1107. 				   rec_cur = (void *) char_valp;
    1108. 

  1108. 			       }
    1109. 

  1109. 			       break;
    1110. 

  1110. 			     case NC_BYTE:
    1111. 

  1111. 			     case NC_SHORT:
    1112. 

  1112. 			     case NC_INT:
    1113. 

  1113. 			     case NC_FLOAT:
    1114. 

  1114. 			     case NC_DOUBLE:
    1115. 

  1115. 			       derror("string value invalid for %s variable",
    1116. 

  1116. 				      nctype(valtype));
    1117. 

  1117. 			       break;
    1118. 

  1118. 			   }
    1119. 

  1119. 		       }
    1120. 

  1120. 		   }
    1121. 

  1121. break;
    1122. 

  1122. case 71:
    1123. 

  1123. #line 604 "ncgen.y"
    1124. 

  1124. {
    1125. 

  1125. 		       atype_code = NC_BYTE;
    1126. 

  1126. 		       switch (valtype) {
    1127. 

  1127. 			 case NC_CHAR:
    1128. 

  1128. 			   *char_valp++ = byte_val;
    1129. 

  1129. 			   break;
    1130. 

  1130. 			 case NC_BYTE:
    1131. 

  1131. 			   *byte_valp++ = byte_val;
    1132. 

  1132. 			   break;
    1133. 

  1133. 			 case NC_SHORT:
    1134. 

  1134. 			   *short_valp++ = byte_val;
    1135. 

  1135. 			   break;
    1136. 

  1136. 			 case NC_INT:
    1137. 

  1137. 			   *int_valp++ = byte_val;
    1138. 

  1138. 			   break;
    1139. 

  1139. 			 case NC_FLOAT:
    1140. 

  1140. 			   *float_valp++ = byte_val;
    1141. 

  1141. 			   break;
    1142. 

  1142. 			 case NC_DOUBLE:
    1143. 

  1143. 			   *double_valp++ = byte_val;
    1144. 

  1144. 			   break;
    1145. 

  1145. 		       }
    1146. 

  1146. 		       valnum++;
    1147. 

  1147. 		   }
    1148. 

  1148. break;
    1149. 

  1149. case 72:
    1150. 

  1150. #line 629 "ncgen.y"
    1151. 

  1151. {
    1152. 

  1152. 		       atype_code = NC_SHORT;
    1153. 

  1153. 		       switch (valtype) {
    1154. 

  1154. 			 case NC_CHAR:
    1155. 

  1155. 			   *char_valp++ = short_val;
    1156. 

  1156. 			   break;
    1157. 

  1157. 			 case NC_BYTE:
    1158. 

  1158. 			   *byte_valp++ = short_val;
    1159. 

  1159. 			   break;
    1160. 

  1160. 			 case NC_SHORT:
    1161. 

  1161. 			   *short_valp++ = short_val;
    1162. 

  1162. 			   break;
    1163. 

  1163. 			 case NC_INT:
    1164. 

  1164. 			   *int_valp++ = short_val;
    1165. 

  1165. 			   break;
    1166. 

  1166. 			 case NC_FLOAT:
    1167. 

  1167. 			   *float_valp++ = short_val;
    1168. 

  1168. 			   break;
    1169. 

  1169. 			 case NC_DOUBLE:
    1170. 

  1170. 			   *double_valp++ = short_val;
    1171. 

  1171. 			   break;
    1172. 

  1172. 		       }
    1173. 

  1173. 		       valnum++;
    1174. 

  1174. 		   }
    1175. 

  1175. break;
    1176. 

  1176. case 73:
    1177. 

  1177. #line 654 "ncgen.y"
    1178. 

  1178. {
    1179. 

  1179. 		       atype_code = NC_INT;
    1180. 

  1180. 		       switch (valtype) {
    1181. 

  1181. 			 case NC_CHAR:
    1182. 

  1182. 			   *char_valp++ = int_val;
    1183. 

  1183. 			   break;
    1184. 

  1184. 			 case NC_BYTE:
    1185. 

  1185. 			   *byte_valp++ = int_val;
    1186. 

  1186. 			   break;
    1187. 

  1187. 			 case NC_SHORT:
    1188. 

  1188. 			   *short_valp++ = int_val;
    1189. 

  1189. 			   break;
    1190. 

  1190. 			 case NC_INT:
    1191. 

  1191. 			   *int_valp++ = int_val;
    1192. 

  1192. 			   break;
    1193. 

  1193. 			 case NC_FLOAT:
    1194. 

  1194. 			   *float_valp++ = int_val;
    1195. 

  1195. 			   break;
    1196. 

  1196. 			 case NC_DOUBLE:
    1197. 

  1197. 			   *double_valp++ = int_val;
    1198. 

  1198. 			   break;
    1199. 

  1199. 		       }
    1200. 

  1200. 		       valnum++;
    1201. 

  1201. 		   }
    1202. 

  1202. break;
    1203. 

  1203. case 74:
    1204. 

  1204. #line 679 "ncgen.y"
    1205. 

  1205. {
    1206. 

  1206. 		       atype_code = NC_FLOAT;
    1207. 

  1207. 		       switch (valtype) {
    1208. 

  1208. 			 case NC_CHAR:
    1209. 

  1209. 			   *char_valp++ = float_val;
    1210. 

  1210. 			   break;
    1211. 

  1211. 			 case NC_BYTE:
    1212. 

  1212. 			   *byte_valp++ = float_val;
    1213. 

  1213. 			   break;
    1214. 

  1214. 			 case NC_SHORT:
    1215. 

  1215. 			   *short_valp++ = float_val;
    1216. 

  1216. 			   break;
    1217. 

  1217. 			 case NC_INT:
    1218. 

  1218. 			   *int_valp++ = float_val;
    1219. 

  1219. 			   break;
    1220. 

  1220. 			 case NC_FLOAT:
    1221. 

  1221. 			   *float_valp++ = float_val;
    1222. 

  1222. 			   break;
    1223. 

  1223. 			 case NC_DOUBLE:
    1224. 

  1224. 			   *double_valp++ = float_val;
    1225. 

  1225. 			   break;
    1226. 

  1226. 		       }
    1227. 

  1227. 		       valnum++;
    1228. 

  1228. 		   }
    1229. 

  1229. break;
    1230. 

  1230. case 75:
    1231. 

  1231. #line 704 "ncgen.y"
    1232. 

  1232. {
    1233. 

  1233. 		       atype_code = NC_DOUBLE;
    1234. 

  1234. 		       switch (valtype) {
    1235. 

  1235. 			 case NC_CHAR:
    1236. 

  1236. 			   *char_valp++ = double_val;
    1237. 

  1237. 			   break;
    1238. 

  1238. 			 case NC_BYTE:
    1239. 

  1239. 			   *byte_valp++ = double_val;
    1240. 

  1240. 			   break;
    1241. 

  1241. 			 case NC_SHORT:
    1242. 

  1242. 			   *short_valp++ = double_val;
    1243. 

  1243. 			   break;
    1244. 

  1244. 			 case NC_INT:
    1245. 

  1245. 			   *int_valp++ = double_val;
    1246. 

  1246. 			   break;
    1247. 

  1247. 			 case NC_FLOAT:
    1248. 

  1248. 			   if (double_val == NC_FILL_DOUBLE)
    1249. 

  1249. 			     *float_valp++ = NC_FILL_FLOAT;
    1250. 

  1250. 			   else
    1251. 

  1251. 			     *float_valp++ = double_val;
    1252. 

  1252. 			   break;
    1253. 

  1253. 			 case NC_DOUBLE:
    1254. 

  1254. 			   *double_valp++ = double_val;
    1255. 

  1255. 			   break;
    1256. 

  1256. 		       }
    1257. 

  1257. 		       valnum++;
    1258. 

  1258. 		   }
    1259. 

  1259. break;
    1260. 

  1260. case 76:
    1261. 

  1261. #line 732 "ncgen.y"
    1262. 

  1262. {
    1263. 

  1263. 		       /* store fill_value */
    1264. 

  1264. 		       switch (valtype) {
    1265. 

  1265. 		       case NC_CHAR:
    1266. 

  1266. 			   nc_fill(valtype, 1, (void *)char_valp++,
    1267. 

  1267. 				   vars[varnum].fill_value);
    1268. 

  1268. 			   break;
    1269. 

  1269. 		       case NC_BYTE:
    1270. 

  1270. 			   nc_fill(valtype, 1, (void *)byte_valp++,
    1271. 

  1271. 				   vars[varnum].fill_value);
    1272. 

  1272. 			   break;
    1273. 

  1273. 		       case NC_SHORT:
    1274. 

  1274. 			   nc_fill(valtype, 1, (void *)short_valp++,
    1275. 

  1275. 				   vars[varnum].fill_value);
    1276. 

  1276. 			   break;
    1277. 

  1277. 		       case NC_INT:
    1278. 

  1278. 			   nc_fill(valtype, 1, (void *)int_valp++,
    1279. 

  1279. 				   vars[varnum].fill_value);
    1280. 

  1280. 			   break;
    1281. 

  1281. 		       case NC_FLOAT:
    1282. 

  1282. 			   nc_fill(valtype, 1, (void *)float_valp++,
    1283. 

  1283. 				   vars[varnum].fill_value);
    1284. 

  1284. 			   break;
    1285. 

  1285. 		       case NC_DOUBLE:
    1286. 

  1286. 			   nc_fill(valtype, 1, (void *)double_valp++,
    1287. 

  1287. 				   vars[varnum].fill_value);
    1288. 

  1288. 			   break;
    1289. 

  1289. 		       }
    1290. 

  1290. 		       valnum++;
    1291. 

  1291. 		   }
    1292. 

  1292. break;
    1293. 

  1293. #line 1294 "y.tab.c"
    1294. 

  1294.     }
    1295. 

  1295.     yyssp -= yym;
    1296. 

  1296.     yystate = *yyssp;
    1297. 

  1297.     yyvsp -= yym;
    1298. 

  1298.     yym = yylhs[yyn];
    1299. 

  1299.     if (yystate == 0 && yym == 0)
    1300. 

  1300.     {
    1301. 

  1301. #if YYDEBUG
    1302. 

  1302.         if (yydebug)
    1303. 

  1303.             printf("%sdebug: after reduction, shifting from state 0 to\
    1304. 

  1304.  state %d\n", YYPREFIX, YYFINAL);
    1305. 

  1305. #endif
    1306. 

  1306.         yystate = YYFINAL;
    1307. 

  1307.         *++yyssp = YYFINAL;
    1308. 

  1308.         *++yyvsp = yyval;
    1309. 

  1309.         if (yychar < 0)
    1310. 

  1310.         {
    1311. 

  1311.             if ((yychar = yylex()) < 0) yychar = 0;
    1312. 

  1312. #if YYDEBUG
    1313. 

  1313.             if (yydebug)
    1314. 

  1314.             {
    1315. 

  1315.                 yys = 0;
    1316. 

  1316.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
    1317. 

  1317.                 if (!yys) yys = "illegal-symbol";
    1318. 

  1318.                 printf("%sdebug: state %d, reading %d (%s)\n",
    1319. 

  1319.                         YYPREFIX, YYFINAL, yychar, yys);
    1320. 

  1320.             }
    1321. 

  1321. #endif
    1322. 

  1322.         }
    1323. 

  1323.         if (yychar == 0) goto yyaccept;
    1324. 

  1324.         goto yyloop;
    1325. 

  1325.     }
    1326. 

  1326.     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
    1327. 

  1327.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
    1328. 

  1328.         yystate = yytable[yyn];
    1329. 

  1329.     else
    1330. 

  1330.         yystate = yydgoto[yym];
    1331. 

  1331. #if YYDEBUG
    1332. 

  1332.     if (yydebug)
    1333. 

  1333.         printf("%sdebug: after reduction, shifting from state %d \
    1334. 

  1334. to state %d\n", YYPREFIX, *yyssp, yystate);
    1335. 

  1335. #endif
    1336. 

  1336.     if (yyssp >= yysslim && yygrowstack())
    1337. 

  1337.     {
    1338. 

  1338.         goto yyoverflow;
    1339. 

  1339.     }
    1340. 

  1340.     *++yyssp = yystate;
    1341. 

  1341.     *++yyvsp = yyval;
    1342. 

  1342.     goto yyloop;
    1343. 

  1343. yyoverflow:
    1344. 

  1344.     yyerror("yacc stack overflow");
    1345. 

  1345. yyabort:
    1346. 

  1346.     return (1);
    1347. 

  1347. yyaccept:
    1348. 

  1348.     return (0);
    1349. 

  1349. }
    1350. 

  1350. 

  1351.