[deliverable/binutils-gdb.git] / binutils / sysinfo.y

/* Copyright (C) 2001-2019 Free Software Foundation, Inc.
   Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).

   This file is part of GNU binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char writecode;
static char *it;
static int code;
static char * repeat;
static char *oldrepeat;
static char *name;
static int rdepth;
static char *names[] = {" ","[n]","[n][m]"};
static char *pnames[]= {"","*","**"};

static int yyerror (char *s);
extern int yylex (void);
%}


%union {
 int i;
 char *s;
}
%token COND
%token REPEAT
%token '(' ')'
%token <s> TYPE
%token <s> NAME
%token <i> NUMBER UNIT
%type <i> attr_size
%type <s> attr_desc attr_id attr_type
%%

top:  {
  switch (writecode)
    {
    case 'i':
      printf("#ifdef SYSROFF_SWAP_IN\n");
      break;
    case 'p':
      printf("#ifdef SYSROFF_p\n");
      break;
    case 'd':
      break;
    case 'g':
      printf("#ifdef SYSROFF_SWAP_OUT\n");
      break;
    case 'c':
      printf("#ifdef SYSROFF_PRINT\n");
      printf("#include <stdio.h>\n");
      printf("#include <stdlib.h>\n");
      printf("#include <ansidecl.h>\n");
      break;
    }
 }
it_list {
  switch (writecode) {
  case 'i':
  case 'p':
  case 'g':
  case 'c':
    printf("#endif\n");
    break;
  case 'd':
    break;
  }
}

  ;


it_list: it it_list
  |
  ;

it:
	'(' NAME NUMBER
      {
	it = $2; code = $3;
	switch (writecode)
	  {
	  case 'd':
	    printf("\n\n\n#define IT_%s_CODE 0x%x\n", it,code);
	    printf("struct IT_%s;\n", it);
	    printf("extern void sysroff_swap_%s_in (struct IT_%s *);\n",
		   $2, it);
	    printf("extern void sysroff_swap_%s_out (FILE *, struct IT_%s *);\n",
		   $2, it);
	    printf("extern void sysroff_print_%s_out (struct IT_%s *);\n",
		   $2, it);
	    printf("struct IT_%s { \n", it);
	    break;
	  case 'i':
	    printf("void sysroff_swap_%s_in (struct IT_%s * ptr)\n",$2,it);
	    printf("{\n");
	    printf("\tunsigned char raw[255];\n");
	    printf("\tint idx = 0;\n");
	    printf("\tint size;\n");
	    printf("\tmemset(raw,0,255);\n");
	    printf("\tmemset(ptr,0,sizeof(*ptr));\n");
	    printf("\tsize = fillup(raw);\n");
	    break;
	  case 'g':
	    printf("void sysroff_swap_%s_out (FILE * ffile, struct IT_%s * ptr)\n",$2,it);
	    printf("{\n");
	    printf("\tunsigned char raw[255];\n");
	    printf("\tint idx = 16;\n");
	    printf("\tmemset (raw, 0, 255);\n");
	    printf("\tcode = IT_%s_CODE;\n", it);
	    break;
	  case 'o':
	    printf("void sysroff_swap_%s_out (bfd * abfd, struct IT_%s * ptr)\n",$2, it);
	    printf("{\n");
	    printf("\tint idx = 0;\n");
	    break;
	  case 'c':
	    printf("void sysroff_print_%s_out (struct IT_%s *ptr)\n",$2,it);
	    printf("{\n");
	    printf("itheader(\"%s\", IT_%s_CODE);\n",$2,$2);
	    break;

	  case 't':
	    break;
	  }

      }
	it_field_list
')'
{
  switch (writecode) {
  case 'd':
    printf("};\n");
    break;
  case 'g':
    printf("\tchecksum(ffile,raw, idx, IT_%s_CODE);\n", it);
    /* Fall through.  */
  case 'i':
  case 'o':
  case 'c':
    printf("}\n");
  }

  free (it);
}
;


it_field_list:
		it_field it_field_list
	|	cond_it_field it_field_list
	|	repeat_it_field it_field_list
	|
	;

repeat_it_field: '(' REPEAT NAME
	{
	  rdepth++;
	  switch (writecode)
	    {
	    case 'c':
	      if (rdepth==1)
	      printf("\tprintf(\"repeat %%d\\n\", %s);\n",$3);
	      if (rdepth==2)
	      printf("\tprintf(\"repeat %%d\\n\", %s[n]);\n",$3);
	      /* Fall through.  */
	    case 'i':
	    case 'g':
	    case 'o':

	      if (rdepth==1)
		{
	      printf("\t{ int n; for (n = 0; n < %s; n++) {\n",    $3);
	    }
	      if (rdepth == 2) {
	      printf("\t{ int m; for (m = 0; m < %s[n]; m++) {\n",    $3);
	    }

	      break;
	    }

	  oldrepeat = repeat;
         repeat = $3;
	}

	 it_field_list ')'

	{
	  free (repeat);

	  repeat = oldrepeat;
	  oldrepeat =0;
	  rdepth--;
	  switch (writecode)
	    {
	    case 'i':
	    case 'g':
	    case 'o':
	    case 'c':
	  printf("\t}}\n");
	}
	}
       ;


cond_it_field: '(' COND NAME
	{
	  switch (writecode)
	    {
	    case 'i':
	    case 'g':
	    case 'o':
	    case 'c':
	      printf("\tif (%s) {\n", $3);
	      break;
	    }

	  free ($3);
	}

	 it_field_list ')'
	{
	  switch (writecode)
	    {
	    case 'i':
	    case 'g':
	    case 'o':
	    case 'c':
	  printf("\t}\n");
	}
	}
       ;

it_field:
	'(' attr_desc '(' attr_type attr_size ')' attr_id
	{name = $7; }
	enums ')'
	{
	  char *desc = $2;
	  char *type = $4;
	  int size = $5;
	  char *id = $7;
char *p = names[rdepth];
char *ptr = pnames[rdepth];
	  switch (writecode)
	    {
	    case 'g':
	      if (size % 8)
		{

		  printf("\twriteBITS(ptr->%s%s,raw,&idx,%d);\n",
			 id,
			 names[rdepth], size);

		}
	      else {
		printf("\twrite%s(ptr->%s%s,raw,&idx,%d,ffile);\n",
		       type,
		       id,
		       names[rdepth],size/8);
		}
	      break;
	    case 'i':
	      {

		if (rdepth >= 1)

		  {
		    printf("if (!ptr->%s) ptr->%s = (%s*)xcalloc(%s, sizeof(ptr->%s[0]));\n",
			   id,
			   id,
			   type,
			   repeat,
			   id);
		  }

		if (rdepth == 2)
		  {
		    printf("if (!ptr->%s[n]) ptr->%s[n] = (%s**)xcalloc(%s[n], sizeof(ptr->%s[n][0]));\n",
			   id,
			   id,
			   type,
			   repeat,
			   id);
		  }

	      }

	      if (size % 8)
		{
		  printf("\tptr->%s%s = getBITS(raw,&idx, %d,size);\n",
			 id,
			 names[rdepth],
			 size);
		}
	      else {
		printf("\tptr->%s%s = get%s(raw,&idx, %d,size);\n",
		       id,
		       names[rdepth],
		       type,
		       size/8);
		}
	      break;
	    case 'o':
	      printf("\tput%s(raw,%d,%d,&idx,ptr->%s%s);\n", type,size/8,size%8,id,names[rdepth]);
	      break;
	    case 'd':
	      if (repeat)
		printf("\t/* repeat %s */\n", repeat);

		  if (type[0] == 'I') {
		  printf("\tint %s%s; \t/* %s */\n",ptr,id, desc);
		}
		  else if (type[0] =='C') {
		  printf("\tchar %s*%s;\t /* %s */\n",ptr,id, desc);
		}
	      else {
		printf("\tbarray %s%s;\t /* %s */\n",ptr,id, desc);
	      }
		  break;
		case 'c':
	      printf("tabout();\n");
		  printf("\tprintf(\"/*%-30s*/ ptr->%s = \");\n", desc, id);

		  if (type[0] == 'I')
		  printf("\tprintf(\"%%d\\n\",ptr->%s%s);\n", id,p);
		  else   if (type[0] == 'C')
		  printf("\tprintf(\"%%s\\n\",ptr->%s%s);\n", id,p);

		  else   if (type[0] == 'B')
		    {
		  printf("\tpbarray(&ptr->%s%s);\n", id,p);
		}
	      else abort();
		  break;
		}

	  free (desc);
	  free (id);
	}

	;


attr_type:
	 TYPE { $$ = $1; }
 	|  { $$ = "INT";}
	;

attr_desc:
	'(' NAME ')'
	{ $$ = $2; }
	;

attr_size:
	 NUMBER UNIT
	{ $$ = $1 * $2; }
	;


attr_id:
		'(' NAME ')'	{ $$ = $2; }
	|	{ $$ = strdup ("dummy");}
	;

enums:
	| '(' enum_list ')' ;

enum_list:
	|
	enum_list '(' NAME NAME ')' {
	  switch (writecode)
	    {
	    case 'd':
	      printf("#define %s %s\n", $3,$4);
	      break;
	    case 'c':
		printf("if (ptr->%s%s == %s) { tabout(); printf(\"%s\\n\");}\n", name, names[rdepth],$4,$3);
	    }

	  free ($3);
	  free ($4);
	}

	;


%%
/* four modes

   -d write structure definitions for sysroff in host format
   -i write functions to swap into sysroff format in
   -o write functions to swap into sysroff format out
   -c write code to print info in human form */

int yydebug;

int
main (int ac, char **av)
{
  yydebug=0;
  if (ac > 1)
    writecode = av[1][1];
if (writecode == 'd')
  {
    printf("typedef struct { unsigned char *data; int len; } barray; \n");
    printf("typedef  int INT;\n");
    printf("typedef  char * CHARS;\n");

  }
  yyparse();
return 0;
}

static int
yyerror (char *s)
{
  fprintf(stderr, "%s\n" , s);
  return 0;
}
Commit	Line	Data
82704155	1	/* Copyright (C) 2001-2019 Free Software Foundation, Inc.
8c2bc687 NC	2	Written by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
8c2bc687 NC	3
32866df7	4	This file is part of GNU binutils.
8c2bc687	5
32866df7 NC	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3 of the License, or
	9	(at your option) any later version.
8c2bc687	10
32866df7 NC	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
8c2bc687	15
32866df7 NC	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	19	MA 02110-1301, USA. */
8c2bc687	20
252b5132 RH	21	%{
	22	#include <stdio.h>
	23	#include <stdlib.h>
d24b7561	24	#include <string.h>
252b5132	25
89b78896 BE	26	static char writecode;
	27	static char *it;
	28	static int code;
	29	static char * repeat;
	30	static char *oldrepeat;
	31	static char *name;
	32	static int rdepth;
	33	static char *names[] = {" ","[n]","[n][m]"};
	34	static char pnames[]= {"","","**"};
dc3c06c2 AM	35
	36	static int yyerror (char *s);
	37	extern int yylex (void);
252b5132 RH	38	%}
	39
	40
	41	%union {
	42	int i;
	43	char *s;
3aade688	44	}
252b5132 RH	45	%token COND
	46	%token REPEAT
	47	%token '(' ')'
	48	%token <s> TYPE
	49	%token <s> NAME
	50	%token <i> NUMBER UNIT
3aade688	51	%type <i> attr_size
252b5132 RH	52	%type <s> attr_desc attr_id attr_type
	53	%%
	54
	55	top: {
	56	switch (writecode)
	57	{
	58	case 'i':
	59	printf("#ifdef SYSROFF_SWAP_IN\n");
3aade688	60	break;
252b5132 RH	61	case 'p':
252b5132 RH	62	printf("#ifdef SYSROFF_p\n");
3aade688	63	break;
252b5132 RH	64	case 'd':
	65	break;
	66	case 'g':
	67	printf("#ifdef SYSROFF_SWAP_OUT\n");
	68	break;
	69	case 'c':
	70	printf("#ifdef SYSROFF_PRINT\n");
	71	printf("#include <stdio.h>\n");
	72	printf("#include <stdlib.h>\n");
c32144ff	73	printf("#include <ansidecl.h>\n");
252b5132 RH	74	break;
252b5132 RH	75	}
3aade688	76	}
252b5132 RH	77	it_list {
	78	switch (writecode) {
	79	case 'i':
	80	case 'p':
	81	case 'g':
	82	case 'c':
	83	printf("#endif\n");
3aade688	84	break;
252b5132 RH	85	case 'd':
	86	break;
	87	}
	88	}
	89
	90	;
	91
	92
	93	it_list: it it_list
	94	\|
	95	;
	96
	97	it:
3aade688	98	'(' NAME NUMBER
252b5132 RH	99	{
252b5132 RH	100	it = $2; code = $3;
3aade688	101	switch (writecode)
252b5132 RH	102	{
	103	case 'd':
	104	printf("\n\n\n#define IT_%s_CODE 0x%x\n", it,code);
c32144ff	105	printf("struct IT_%s;\n", it);
91d6fa6a	106	printf("extern void sysroff_swap_%s_in (struct IT_%s *);\n",
c32144ff	107	$2, it);
91d6fa6a	108	printf("extern void sysroff_swap_%s_out (FILE , struct IT_%s );\n",
c32144ff	109	$2, it);
91d6fa6a	110	printf("extern void sysroff_print_%s_out (struct IT_%s *);\n",
c32144ff	111	$2, it);
252b5132 RH	112	printf("struct IT_%s { \n", it);
	113	break;
	114	case 'i':
91d6fa6a	115	printf("void sysroff_swap_%s_in (struct IT_%s * ptr)\n",$2,it);
252b5132	116	printf("{\n");
91d6fa6a NC	117	printf("\tunsigned char raw[255];\n");
91d6fa6a NC	118	printf("\tint idx = 0;\n");
252b5132	119	printf("\tint size;\n");
3aade688	120	printf("\tmemset(raw,0,255);\n");
91d6fa6a NC	121	printf("\tmemset(ptr,0,sizeof(*ptr));\n");
91d6fa6a NC	122	printf("\tsize = fillup(raw);\n");
252b5132 RH	123	break;
252b5132 RH	124	case 'g':
91d6fa6a	125	printf("void sysroff_swap_%s_out (FILE * ffile, struct IT_%s * ptr)\n",$2,it);
252b5132	126	printf("{\n");
dc3c06c2	127	printf("\tunsigned char raw[255];\n");
91d6fa6a	128	printf("\tint idx = 16;\n");
252b5132 RH	129	printf("\tmemset (raw, 0, 255);\n");
	130	printf("\tcode = IT_%s_CODE;\n", it);
	131	break;
	132	case 'o':
91d6fa6a	133	printf("void sysroff_swap_%s_out (bfd * abfd, struct IT_%s * ptr)\n",$2, it);
252b5132	134	printf("{\n");
91d6fa6a	135	printf("\tint idx = 0;\n");
252b5132 RH	136	break;
252b5132 RH	137	case 'c':
91d6fa6a	138	printf("void sysroff_print_%s_out (struct IT_%s *ptr)\n",$2,it);
252b5132 RH	139	printf("{\n");
	140	printf("itheader(\"%s\", IT_%s_CODE);\n",$2,$2);
	141	break;
	142
	143	case 't':
	144	break;
	145	}
	146
3aade688 L	147	}
3aade688 L	148	it_field_list
252b5132 RH	149	')'
	150	{
	151	switch (writecode) {
3aade688	152	case 'd':
252b5132 RH	153	printf("};\n");
	154	break;
	155	case 'g':
91d6fa6a	156	printf("\tchecksum(ffile,raw, idx, IT_%s_CODE);\n", it);
1a0670f3	157	/* Fall through. */
252b5132	158	case 'i':
252b5132 RH	159	case 'o':
	160	case 'c':
	161	printf("}\n");
	162	}
d24b7561 SM	163
d24b7561 SM	164	free (it);
252b5132 RH	165	}
	166	;
	167
	168
	169
	170	it_field_list:
	171	it_field it_field_list
3aade688	172	\| cond_it_field it_field_list
252b5132 RH	173	\| repeat_it_field it_field_list
	174	\|
	175	;
	176
	177	repeat_it_field: '(' REPEAT NAME
	178	{
	179	rdepth++;
3aade688	180	switch (writecode)
252b5132 RH	181	{
	182	case 'c':
	183	if (rdepth==1)
	184	printf("\tprintf(\"repeat %%d\\n\", %s);\n",$3);
	185	if (rdepth==2)
	186	printf("\tprintf(\"repeat %%d\\n\", %s[n]);\n",$3);
1a0670f3	187	/* Fall through. */
252b5132 RH	188	case 'i':
	189	case 'g':
	190	case 'o':
	191
3aade688	192	if (rdepth==1)
252b5132 RH	193	{
	194	printf("\t{ int n; for (n = 0; n < %s; n++) {\n", $3);
	195	}
	196	if (rdepth == 2) {
	197	printf("\t{ int m; for (m = 0; m < %s[n]; m++) {\n", $3);
3aade688	198	}
252b5132 RH	199
	200	break;
	201	}
	202
	203	oldrepeat = repeat;
	204	repeat = $3;
	205	}
	206
3aade688	207	it_field_list ')'
252b5132 RH	208
252b5132 RH	209	{
d24b7561 SM	210	free (repeat);
d24b7561 SM	211
252b5132 RH	212	repeat = oldrepeat;
	213	oldrepeat =0;
	214	rdepth--;
	215	switch (writecode)
	216	{
	217	case 'i':
	218	case 'g':
	219	case 'o':
	220	case 'c':
	221	printf("\t}}\n");
	222	}
	223	}
	224	;
	225
	226
	227	cond_it_field: '(' COND NAME
	228	{
3aade688	229	switch (writecode)
252b5132 RH	230	{
	231	case 'i':
	232	case 'g':
	233	case 'o':
	234	case 'c':
	235	printf("\tif (%s) {\n", $3);
	236	break;
	237	}
d24b7561 SM	238
d24b7561 SM	239	free ($3);
252b5132 RH	240	}
252b5132 RH	241
3aade688	242	it_field_list ')'
252b5132 RH	243	{
	244	switch (writecode)
	245	{
	246	case 'i':
	247	case 'g':
	248	case 'o':
	249	case 'c':
	250	printf("\t}\n");
	251	}
	252	}
	253	;
	254
	255	it_field:
3aade688 L	256	'(' attr_desc '(' attr_type attr_size ')' attr_id
3aade688 L	257	{name = $7; }
252b5132 RH	258	enums ')'
	259	{
	260	char *desc = $2;
	261	char *type = $4;
	262	int size = $5;
	263	char *id = $7;
	264	char *p = names[rdepth];
	265	char *ptr = pnames[rdepth];
3aade688	266	switch (writecode)
252b5132 RH	267	{
252b5132 RH	268	case 'g':
3aade688	269	if (size % 8)
252b5132	270	{
3aade688	271
252b5132 RH	272	printf("\twriteBITS(ptr->%s%s,raw,&idx,%d);\n",
	273	id,
	274	names[rdepth], size);
	275
	276	}
	277	else {
91d6fa6a	278	printf("\twrite%s(ptr->%s%s,raw,&idx,%d,ffile);\n",
252b5132 RH	279	type,
	280	id,
	281	names[rdepth],size/8);
	282	}
3aade688	283	break;
252b5132 RH	284	case 'i':
	285	{
	286
	287	if (rdepth >= 1)
	288
	289	{
3aade688 L	290	printf("if (!ptr->%s) ptr->%s = (%s*)xcalloc(%s, sizeof(ptr->%s[0]));\n",
3aade688 L	291	id,
252b5132 RH	292	id,
	293	type,
	294	repeat,
	295	id);
	296	}
	297
	298	if (rdepth == 2)
	299	{
3aade688 L	300	printf("if (!ptr->%s[n]) ptr->%s[n] = (%s**)xcalloc(%s[n], sizeof(ptr->%s[n][0]));\n",
3aade688 L	301	id,
252b5132 RH	302	id,
	303	type,
	304	repeat,
	305	id);
	306	}
	307
	308	}
	309
3aade688	310	if (size % 8)
252b5132 RH	311	{
	312	printf("\tptr->%s%s = getBITS(raw,&idx, %d,size);\n",
	313	id,
3aade688	314	names[rdepth],
252b5132 RH	315	size);
	316	}
	317	else {
	318	printf("\tptr->%s%s = get%s(raw,&idx, %d,size);\n",
	319	id,
	320	names[rdepth],
	321	type,
	322	size/8);
	323	}
	324	break;
	325	case 'o':
	326	printf("\tput%s(raw,%d,%d,&idx,ptr->%s%s);\n", type,size/8,size%8,id,names[rdepth]);
	327	break;
	328	case 'd':
3aade688	329	if (repeat)
252b5132 RH	330	printf("\t/* repeat %s */\n", repeat);
	331
	332	if (type[0] == 'I') {
	333	printf("\tint %s%s; \t/* %s */\n",ptr,id, desc);
	334	}
	335	else if (type[0] =='C') {
	336	printf("\tchar %s%s;\t / %s */\n",ptr,id, desc);
	337	}
	338	else {
	339	printf("\tbarray %s%s;\t /* %s */\n",ptr,id, desc);
	340	}
	341	break;
	342	case 'c':
	343	printf("tabout();\n");
	344	printf("\tprintf(\"/%-30s/ ptr->%s = \");\n", desc, id);
	345
	346	if (type[0] == 'I')
	347	printf("\tprintf(\"%%d\\n\",ptr->%s%s);\n", id,p);
	348	else if (type[0] == 'C')
	349	printf("\tprintf(\"%%s\\n\",ptr->%s%s);\n", id,p);
	350
3aade688	351	else if (type[0] == 'B')
252b5132 RH	352	{
	353	printf("\tpbarray(&ptr->%s%s);\n", id,p);
	354	}
	355	else abort();
	356	break;
	357	}
d24b7561 SM	358
	359	free (desc);
	360	free (id);
252b5132 RH	361	}
	362
	363	;
	364
	365
3aade688	366	attr_type:
252b5132 RH	367	TYPE { $$ = $1; }
	368	\| { $$ = "INT";}
	369	;
	370
3aade688 L	371	attr_desc:
3aade688 L	372	'(' NAME ')'
252b5132 RH	373	{ $$ = $2; }
	374	;
	375
	376	attr_size:
3aade688	377	NUMBER UNIT
252b5132 RH	378	{ $$ = $1 * $2; }
	379	;
	380
	381
	382	attr_id:
	383	'(' NAME ')' { $$ = $2; }
d24b7561	384	\| { $$ = strdup ("dummy");}
3aade688 L	385	;
	386
	387	enums:
252b5132 RH	388	\| '(' enum_list ')' ;
	389
	390	enum_list:
	391	\|
3aade688 L	392	enum_list '(' NAME NAME ')' {
3aade688 L	393	switch (writecode)
252b5132 RH	394	{
	395	case 'd':
	396	printf("#define %s %s\n", $3,$4);
	397	break;
	398	case 'c':
	399	printf("if (ptr->%s%s == %s) { tabout(); printf(\"%s\\n\");}\n", name, names[rdepth],$4,$3);
	400	}
d24b7561 SM	401
	402	free ($3);
	403	free ($4);
252b5132 RH	404	}
	405
	406	;
	407
	408
	409
	410	%%
	411	/* four modes
	412
50c2245b	413	-d write structure definitions for sysroff in host format
252b5132 RH	414	-i write functions to swap into sysroff format in
	415	-o write functions to swap into sysroff format out
	416	-c write code to print info in human form */
	417
	418	int yydebug;
252b5132	419
3aade688	420	int
2da42df6	421	main (int ac, char **av)
252b5132 RH	422	{
	423	yydebug=0;
	424	if (ac > 1)
	425	writecode = av[1][1];
	426	if (writecode == 'd')
	427	{
	428	printf("typedef struct { unsigned char *data; int len; } barray; \n");
	429	printf("typedef int INT;\n");
	430	printf("typedef char * CHARS;\n");
	431
	432	}
	433	yyparse();
	434	return 0;
	435	}
	436
dc3c06c2	437	static int
2da42df6	438	yyerror (char *s)
252b5132 RH	439	{
	440	fprintf(stderr, "%s\n" , s);
	441	return 0;
	442	}