OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [sysinfo.y] - Blame information for rev 18

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 15 khays 
/* Copyright 2001, 2003, 2005, 2007, 2009 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 (struct IT_%s *);\n",
106 
                   $2, it);
107 
            printf("extern void sysroff_swap_%s_out (FILE *, struct IT_%s *);\n",
108 
                   $2, it);
109 
            printf("extern void sysroff_print_%s_out (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 (struct IT_%s * ptr)\n",$2,it);
115 
            printf("{\n");
116 
            printf("\tunsigned char raw[255];\n");
117 
            printf("\tint idx = 0;\n");
118 
            printf("\tint size;\n");
119 
            printf("\tmemset(raw,0,255);\n");
120 
            printf("\tmemset(ptr,0,sizeof(*ptr));\n");
121 
            printf("\tsize = fillup(raw);\n");
122 
            break;
123 
          case 'g':
124 
            printf("void sysroff_swap_%s_out (FILE * ffile, struct IT_%s * ptr)\n",$2,it);
125 
            printf("{\n");
126 
            printf("\tunsigned char raw[255];\n");
127 
            printf("\tint idx = 16;\n");
128 
            printf("\tmemset (raw, 0, 255);\n");
129 
            printf("\tcode = IT_%s_CODE;\n", it);
130 
            break;
131 
          case 'o':
132 
            printf("void sysroff_swap_%s_out (bfd * abfd, struct IT_%s * ptr)\n",$2, it);
133 
            printf("{\n");
134 
            printf("\tint idx = 0;\n");
135 
            break;
136 
          case 'c':
137 
            printf("void sysroff_print_%s_out (struct IT_%s *ptr)\n",$2,it);
138 
            printf("{\n");
139 
            printf("itheader(\"%s\", IT_%s_CODE);\n",$2,$2);
140 
            break;
141 
 
142 
          case 't':
143 
            break;
144 
          }
145 
 
146 
      }
147 
        it_field_list
148 
')'
149 
{
150 
  switch (writecode) {
151 
  case 'd':
152 
    printf("};\n");
153 
    break;
154 
  case 'g':
155 
    printf("\tchecksum(ffile,raw, idx, IT_%s_CODE);\n", it);
156 
 
157 
  case 'i':
158 
 
159 
  case 'o':
160 
  case 'c':
161 
    printf("}\n");
162 
  }
163 
}
164 
;
165 
 
166 
 
167 
 
168 
it_field_list:
169 
                it_field it_field_list
170 
        |       cond_it_field it_field_list
171 
        |       repeat_it_field it_field_list
172 
        |
173 
        ;
174 
 
175 
repeat_it_field: '(' REPEAT NAME
176 
        {
177 
          rdepth++;
178 
          switch (writecode)
179 
            {
180 
            case 'c':
181 
              if (rdepth==1)
182 
              printf("\tprintf(\"repeat %%d\\n\", %s);\n",$3);
183 
              if (rdepth==2)
184 
              printf("\tprintf(\"repeat %%d\\n\", %s[n]);\n",$3);
185 
            case 'i':
186 
            case 'g':
187 
            case 'o':
188 
 
189 
              if (rdepth==1)
190 
                {
191 
              printf("\t{ int n; for (n = 0; n < %s; n++) {\n",    $3);
192 
            }
193 
              if (rdepth == 2) {
194 
              printf("\t{ int m; for (m = 0; m < %s[n]; m++) {\n",    $3);
195 
            }
196 
 
197 
              break;
198 
            }
199 
 
200 
          oldrepeat = repeat;
201 
         repeat = $3;
202 
        }
203 
 
204 
         it_field_list ')'
205 
 
206 
        {
207 
          repeat = oldrepeat;
208 
          oldrepeat =0;
209 
          rdepth--;
210 
          switch (writecode)
211 
            {
212 
            case 'i':
213 
            case 'g':
214 
            case 'o':
215 
            case 'c':
216 
          printf("\t}}\n");
217 
        }
218 
        }
219 
       ;
220 
 
221 
 
222 
cond_it_field: '(' COND NAME
223 
        {
224 
          switch (writecode)
225 
            {
226 
            case 'i':
227 
            case 'g':
228 
            case 'o':
229 
            case 'c':
230 
              printf("\tif (%s) {\n", $3);
231 
              break;
232 
            }
233 
        }
234 
 
235 
         it_field_list ')'
236 
        {
237 
          switch (writecode)
238 
            {
239 
            case 'i':
240 
            case 'g':
241 
            case 'o':
242 
            case 'c':
243 
          printf("\t}\n");
244 
        }
245 
        }
246 
       ;
247 
 
248 
it_field:
249 
        '(' attr_desc '(' attr_type attr_size ')' attr_id
250 
        {name = $7; }
251 
        enums ')'
252 
        {
253 
          char *desc = $2;
254 
          char *type = $4;
255 
          int size = $5;
256 
          char *id = $7;
257 
char *p = names[rdepth];
258 
char *ptr = pnames[rdepth];
259 
          switch (writecode)
260 
            {
261 
            case 'g':
262 
              if (size % 8)
263 
                {
264 
 
265 
                  printf("\twriteBITS(ptr->%s%s,raw,&idx,%d);\n",
266 
                         id,
267 
                         names[rdepth], size);
268 
 
269 
                }
270 
              else {
271 
                printf("\twrite%s(ptr->%s%s,raw,&idx,%d,ffile);\n",
272 
                       type,
273 
                       id,
274 
                       names[rdepth],size/8);
275 
                }
276 
              break;
277 
            case 'i':
278 
              {
279 
 
280 
                if (rdepth >= 1)
281 
 
282 
                  {
283 
                    printf("if (!ptr->%s) ptr->%s = (%s*)xcalloc(%s, sizeof(ptr->%s[0]));\n",
284 
                           id,
285 
                           id,
286 
                           type,
287 
                           repeat,
288 
                           id);
289 
                  }
290 
 
291 
                if (rdepth == 2)
292 
                  {
293 
                    printf("if (!ptr->%s[n]) ptr->%s[n] = (%s**)xcalloc(%s[n], sizeof(ptr->%s[n][0]));\n",
294 
                           id,
295 
                           id,
296 
                           type,
297 
                           repeat,
298 
                           id);
299 
                  }
300 
 
301 
              }
302 
 
303 
              if (size % 8)
304 
                {
305 
                  printf("\tptr->%s%s = getBITS(raw,&idx, %d,size);\n",
306 
                         id,
307 
                         names[rdepth],
308 
                         size);
309 
                }
310 
              else {
311 
                printf("\tptr->%s%s = get%s(raw,&idx, %d,size);\n",
312 
                       id,
313 
                       names[rdepth],
314 
                       type,
315 
                       size/8);
316 
                }
317 
              break;
318 
            case 'o':
319 
              printf("\tput%s(raw,%d,%d,&idx,ptr->%s%s);\n", type,size/8,size%8,id,names[rdepth]);
320 
              break;
321 
            case 'd':
322 
              if (repeat)
323 
                printf("\t/* repeat %s */\n", repeat);
324 
 
325 
                  if (type[0] == 'I') {
326 
                  printf("\tint %s%s; \t/* %s */\n",ptr,id, desc);
327 
                }
328 
                  else if (type[0] =='C') {
329 
                  printf("\tchar %s*%s;\t /* %s */\n",ptr,id, desc);
330 
                }
331 
              else {
332 
                printf("\tbarray %s%s;\t /* %s */\n",ptr,id, desc);
333 
              }
334 
                  break;
335 
                case 'c':
336 
              printf("tabout();\n");
337 
                  printf("\tprintf(\"/*%-30s*/ ptr->%s = \");\n", desc, id);
338 
 
339 
                  if (type[0] == 'I')
340 
                  printf("\tprintf(\"%%d\\n\",ptr->%s%s);\n", id,p);
341 
                  else   if (type[0] == 'C')
342 
                  printf("\tprintf(\"%%s\\n\",ptr->%s%s);\n", id,p);
343 
 
344 
                  else   if (type[0] == 'B')
345 
                    {
346 
                  printf("\tpbarray(&ptr->%s%s);\n", id,p);
347 
                }
348 
              else abort();
349 
                  break;
350 
                }
351 
        }
352 
 
353 
        ;
354 
 
355 
 
356 
attr_type:
357 
         TYPE { $$ = $1; }
358 
        |  { $$ = "INT";}
359 
        ;
360 
 
361 
attr_desc:
362 
        '(' NAME ')'
363 
        { $$ = $2; }
364 
        ;
365 
 
366 
attr_size:
367 
         NUMBER UNIT
368 
        { $$ = $1 * $2; }
369 
        ;
370 
 
371 
 
372 
attr_id:
373 
                '(' NAME ')'    { $$ = $2; }
374 
        |       { $$ = "dummy";}
375 
        ;
376 
 
377 
enums:
378 
        | '(' enum_list ')' ;
379 
 
380 
enum_list:
381 
        |
382 
        enum_list '(' NAME NAME ')' {
383 
          switch (writecode)
384 
            {
385 
            case 'd':
386 
              printf("#define %s %s\n", $3,$4);
387 
              break;
388 
            case 'c':
389 
                printf("if (ptr->%s%s == %s) { tabout(); printf(\"%s\\n\");}\n", name, names[rdepth],$4,$3);
390 
            }
391 
        }
392 
 
393 
        ;
394 
 
395 
 
396 
 
397 
%%
398 
/* four modes
399 
 
400 
   -d write structure definitions for sysroff in host format
401 
   -i write functions to swap into sysroff format in
402 
   -o write functions to swap into sysroff format out
403 
   -c write code to print info in human form */
404 
 
405 
int yydebug;
406 
 
407 
int
408 
main (int ac, char **av)
409 
{
410 
  yydebug=0;
411 
  if (ac > 1)
412 
    writecode = av[1][1];
413 
if (writecode == 'd')
414 
  {
415 
    printf("typedef struct { unsigned char *data; int len; } barray; \n");
416 
    printf("typedef  int INT;\n");
417 
    printf("typedef  char * CHARS;\n");
418 
 
419 
  }
420 
  yyparse();
421 
return 0;
422 
}
423 
 
424 
static int
425 
yyerror (char *s)
426 
{
427 
  fprintf(stderr, "%s\n" , s);
428 
  return 0;
429 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.