URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [binutils/] [sysinfo.y] - Blame information for rev 818

Details | Compare with Previous | View Log


/* Copyright 2001, 2003, 2005, 2007 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 
#include 
 
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  TYPE
%token  NAME
%token  NUMBER UNIT
%type  attr_size
%type  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 \n");
      printf("#include \n");
      printf("#include \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 PARAMS ((struct IT_%s *));\n",
                   $2, it);
            printf("extern void sysroff_swap_%s_out PARAMS ((FILE *, struct IT_%s *));\n",
                   $2, it);
            printf("extern void sysroff_print_%s_out PARAMS ((struct IT_%s *));\n",
                   $2, it);
            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("unsigned 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("\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(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 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;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [binutils/] [sysinfo.y] - Blame information for rev 818

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