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

/* Copyright 2001 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

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

extern char *word;
extern char writecode;
extern int number;
extern int unit;
char nice_name[1000];
char *it;
int sofar;
int width;
int code;
char * repeat;
char *oldrepeat;
char *name;
int rdepth;
char *loop [] = {"","n","m","/*BAD*/"};
char *names[] = {" ","[n]","[n][m]"};
char *pnames[]= {"","*","**"};
%}


%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");
      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);
	    break;
	  case 'i':
	    printf("void sysroff_swap_%s_in(ptr)\n",$2);
	    printf("struct IT_%s *ptr;\n", it);
	    printf("{\n");
	    printf("char raw[255];\n");
	    printf("\tint idx = 0 ;\n");
	    printf("\tint size;\n");
	    printf("memset(raw,0,255);\n");	
	    printf("memset(ptr,0,sizeof(*ptr));\n");
	    printf("size = fillup(raw);\n");
	    break;
	  case 'g':
	    printf("void sysroff_swap_%s_out(file,ptr)\n",$2);
	    printf("FILE * file;\n");
	    printf("struct IT_%s *ptr;\n", it);
	    printf("{\n");
	    printf("\tchar 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(abfd,ptr)\n",$2);
	    printf("bfd * abfd;\n");
	    printf("struct IT_%s *ptr;\n",it);
	    printf("{\n");
	    printf("int idx = 0 ;\n");
	    break;
	  case 'c':
	    printf("void sysroff_print_%s_out(ptr)\n",$2);
	    printf("struct IT_%s *ptr;\n", 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(file,raw, idx, IT_%s_CODE);\n", it);
    
  case 'i':

  case 'o':
  case 'c':
    printf("}\n");
  }
}
;


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);
	    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 ')' 

	{
	  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;
	    }
	}

	 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,file);\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;
		}
	}

	;


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

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

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


attr_id:
		'(' NAME ')'	{ $$ = $2; }
	|	{ $$ = "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);
	    }
	}

	;


%%
/* four modes

   -d write structure defintions 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;
char writecode;

int 
main(ac,av)
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;
}

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