source: vendor/emx/0.9d-fix04/src/libmoddef/moddef2.c

Last change on this file was 18, checked in by bird, 23 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 20.1 KB
Line 
1/* moddef2.c (emx+gcc) -- Copyright (c) 1992-1995 by Eberhard Mattes */
2
3#include <stdio.h>
4#include <string.h>
5#include <sys/moddef.h>
6
7#define FALSE 0
8#define TRUE 1
9
10typedef int _md_callback (struct _md *md, const _md_stmt *stmt,
11 _md_token token, void *arg);
12
13static int error (struct _md *md, _md_callback *callback, _md_stmt *stmt,
14 _md_token stmt_token, _md_error code, void *arg)
15{
16 stmt->error.code = code;
17 stmt->error.stmt = stmt_token;
18 return callback (md, stmt, _MD_parseerror, arg);
19}
20
21static _md_token sync (struct _md *md)
22{
23 _md_token token;
24
25 token = _md_get_token (md);
26 for (;;)
27 switch (token)
28 {
29 case _MD_BASE:
30 case _MD_CODE:
31 case _MD_DATA:
32 case _MD_DESCRIPTION:
33 case _MD_EXETYPE:
34 case _MD_EXPORTS:
35 case _MD_HEAPSIZE:
36 case _MD_IMPORTS:
37 case _MD_OLD:
38 case _MD_PROTMODE:
39 case _MD_REALMODE:
40 case _MD_SEGMENTS:
41 case _MD_STACKSIZE:
42 case _MD_STUB:
43 case _MD_eof:
44 case _MD_ioerror:
45 case _MD_missingquote:
46 return token;
47 default:
48 token = _md_next_token (md);
49 break;
50 }
51}
52
53
54#define ERROR(CODE) \
55 do { result = error (md, callback, &stmt, stmt_token, (CODE), arg); \
56 if (result != 0) return result; \
57 token = sync (md); goto next_stmt;} while (FALSE)
58
59#define CALLBACK \
60 do { result = callback (md, &stmt, stmt_token, arg); \
61 if (result != 0) return result; } while (FALSE)
62
63int _md_parse (struct _md *md, _md_callback *callback, void *arg)
64{
65 _md_token token, stmt_token;
66 _md_stmt stmt;
67 const char *s;
68 long n;
69 int ok, result;
70
71 token = _md_get_token (md);
72 stmt_token = token;
73 switch (stmt_token)
74 {
75 case _MD_eof:
76 ERROR (_MDE_EMPTY);
77 break;
78
79 case _MD_NAME:
80 token = _md_next_token (md);
81 stmt.name.name[0] = 0;
82 if (token == _MD_quote || token == _MD_word)
83 {
84 _strncpy (stmt.name.name, _md_get_string (md),
85 sizeof (stmt.name.name));
86 token = _md_next_token (md);
87 }
88 switch (token)
89 {
90 case _MD_WINDOWAPI:
91 stmt.name.pmtype = _MDT_WINDOWAPI;
92 token = _md_next_token (md);
93 break;
94 case _MD_WINDOWCOMPAT:
95 stmt.name.pmtype = _MDT_WINDOWCOMPAT;
96 token = _md_next_token (md);
97 break;
98 case _MD_NOTWINDOWCOMPAT:
99 stmt.name.pmtype = _MDT_NOTWINDOWCOMPAT;
100 token = _md_next_token (md);
101 break;
102 default:
103 stmt.name.pmtype = _MDT_DEFAULT;
104 break;
105 }
106 stmt.name.newfiles = FALSE;
107 if (token == _MD_NEWFILES)
108 {
109 stmt.name.newfiles = TRUE;
110 token = _md_next_token (md);
111 }
112 CALLBACK;
113 break;
114
115 case _MD_LIBRARY:
116 token = _md_next_token (md);
117 if (token == _MD_quote || token == _MD_word)
118 {
119 _strncpy (stmt.library.name, _md_get_string (md),
120 sizeof (stmt.library.name));
121 token = _md_next_token (md);
122 }
123 switch (token)
124 {
125 case _MD_INITGLOBAL:
126 stmt.library.init = _MDIT_GLOBAL;
127 token = _md_next_token (md);
128 break;
129 case _MD_INITINSTANCE:
130 stmt.library.init = _MDIT_INSTANCE;
131 token = _md_next_token (md);
132 break;
133 default:
134 stmt.library.init = _MDIT_DEFAULT;
135 break;
136 }
137 switch (token)
138 {
139 case _MD_TERMGLOBAL:
140 stmt.library.term = _MDIT_GLOBAL;
141 token = _md_next_token (md);
142 break;
143 case _MD_TERMINSTANCE:
144 stmt.library.term = _MDIT_INSTANCE;
145 token = _md_next_token (md);
146 break;
147 default:
148 stmt.library.term = _MDIT_DEFAULT;
149 break;
150 }
151 if (token == _MD_PRIVATELIB)
152 token = _md_next_token (md);
153 CALLBACK;
154 break;
155
156 case _MD_VIRTUAL:
157 case _MD_PHYSICAL:
158 token = _md_next_token (md);
159 if (token != _MD_DEVICE)
160 ERROR (_MDE_DEVICE_EXPECTED);
161 token = _md_next_token (md);
162 stmt.device.name[0] = 0;
163 if (token == _MD_quote || token == _MD_word)
164 {
165 _strncpy (stmt.device.name, _md_get_string (md),
166 sizeof (stmt.device.name));
167 token = _md_next_token (md);
168 }
169 CALLBACK;
170 break;
171
172 default:
173 break;
174 }
175
176next_stmt:
177 while (token != _MD_eof)
178 {
179 stmt_token = token;
180 switch (stmt_token)
181 {
182 case _MD_BASE:
183 token = _md_next_token (md);
184 if (token != _MD_equal)
185 ERROR (_MDE_EQUAL_EXPECTED);
186 token = _md_next_token (md);
187 if (token != _MD_number)
188 ERROR (_MDE_NUMBER_EXPECTED);
189 stmt.base.addr = _md_get_number (md);
190 token = _md_next_token (md);
191 CALLBACK;
192 break;
193
194 case _MD_CODE:
195 token = _md_next_token (md);
196 stmt.segment.segname[0] = 0;
197 stmt.segment.classname[0] = 0;
198 stmt.segment.attr = 0;
199 ok = TRUE;
200 while (ok)
201 {
202 switch (token)
203 {
204 case _MD_CONFORMING:
205 stmt.segment.attr |= _MDS_CONFORMING;
206 break;
207 case _MD_DISCARDABLE:
208 stmt.segment.attr |= _MDS_DISCARDABLE;
209 break;
210 case _MD_EXECUTEONLY:
211 stmt.segment.attr |= _MDS_EXECUTEONLY;
212 break;
213 case _MD_EXECUTEREAD:
214 stmt.segment.attr |= _MDS_EXECUTEREAD;
215 break;
216 case _MD_FIXED:
217 stmt.segment.attr |= _MDS_FIXED;
218 break;
219 case _MD_IOPL:
220 stmt.segment.attr |= _MDS_IOPL;
221 break;
222 case _MD_LOADONCALL:
223 stmt.segment.attr |= _MDS_LOADONCALL;
224 break;
225 case _MD_MOVEABLE:
226 stmt.segment.attr |= _MDS_MOVEABLE;
227 break;
228 case _MD_NOIOPL:
229 stmt.segment.attr |= _MDS_NOIOPL;
230 break;
231 case _MD_NONCONFORMING:
232 stmt.segment.attr |= _MDS_NONCONFORMING;
233 break;
234 case _MD_NONDISCARDABLE:
235 stmt.segment.attr |= _MDS_NONDISCARDABLE;
236 break;
237 case _MD_NONSHARED:
238 case _MD_IMPURE:
239 stmt.segment.attr |= _MDS_NONSHARED;
240 break;
241 case _MD_PRELOAD:
242 stmt.segment.attr |= _MDS_PRELOAD;
243 break;
244 case _MD_SHARED:
245 case _MD_PURE:
246 stmt.segment.attr |= _MDS_SHARED;
247 break;
248 default:
249 ok = FALSE;
250 break;
251 }
252 if (ok)
253 token = _md_next_token (md);
254 }
255 CALLBACK;
256 break;
257
258 case _MD_DATA:
259 token = _md_next_token (md);
260 stmt.segment.segname[0] = 0;
261 stmt.segment.classname[0] = 0;
262 stmt.segment.attr = 0;
263 ok = TRUE;
264 while (ok)
265 {
266 switch (token)
267 {
268 case _MD_FIXED:
269 stmt.segment.attr |= _MDS_FIXED;
270 break;
271 case _MD_IOPL:
272 stmt.segment.attr |= _MDS_IOPL;
273 break;
274 case _MD_LOADONCALL:
275 stmt.segment.attr |= _MDS_LOADONCALL;
276 break;
277 case _MD_MOVEABLE:
278 stmt.segment.attr |= _MDS_MOVEABLE;
279 break;
280 case _MD_MULTIPLE:
281 stmt.segment.attr |= _MDS_MULTIPLE;
282 break;
283 case _MD_NOIOPL:
284 stmt.segment.attr |= _MDS_NOIOPL;
285 break;
286 case _MD_NONE:
287 stmt.segment.attr |= _MDS_NONE;
288 break;
289 case _MD_NONSHARED:
290 case _MD_IMPURE:
291 stmt.segment.attr |= _MDS_NONSHARED;
292 break;
293 case _MD_PRELOAD:
294 stmt.segment.attr |= _MDS_PRELOAD;
295 break;
296 case _MD_READONLY:
297 stmt.segment.attr |= _MDS_READONLY;
298 break;
299 case _MD_READWRITE:
300 stmt.segment.attr |= _MDS_READWRITE;
301 break;
302 case _MD_SHARED:
303 case _MD_PURE:
304 stmt.segment.attr |= _MDS_SHARED;
305 break;
306 case _MD_SINGLE:
307 stmt.segment.attr |= _MDS_SINGLE;
308 break;
309 default:
310 ok = FALSE;
311 break;
312 }
313 if (ok)
314 token = _md_next_token (md);
315 }
316 CALLBACK;
317 break;
318
319 case _MD_DESCRIPTION:
320 token = _md_next_token (md);
321 if (token != _MD_quote)
322 ERROR (_MDE_STRING_EXPECTED);
323 s = _md_get_string (md);
324 if (*s == 0 || strlen (s) > 255)
325 ERROR (_MDE_STRING_TOO_LONG);
326 _strncpy (stmt.descr.string, s, sizeof (stmt.descr.string));
327 token = _md_next_token (md);
328 CALLBACK;
329 break;
330
331 case _MD_EXETYPE:
332 token = _md_next_token (md);
333 switch (token)
334 {
335 case _MD_OS2:
336 stmt.exetype.type = _MDX_OS2;
337 token = _md_next_token (md);
338 break;
339 case _MD_UNKNOWN:
340 stmt.exetype.type = _MDX_UNKNOWN;
341 token = _md_next_token (md);
342 break;
343 case _MD_WINDOWS:
344 stmt.exetype.type = _MDX_WINDOWS;
345 stmt.exetype.major_version = 0;
346 stmt.exetype.minor_version = 0;
347 token = _md_next_token (md);
348 if (token == _MD_number)
349 {
350 stmt.exetype.major_version = _md_get_number (md);
351 token = _md_next_token (md);
352 if (token == _MD_dot)
353 {
354 token = _md_next_token (md);
355 if (token == _MD_number)
356 {
357 stmt.exetype.minor_version = _md_get_number (md);
358 token = _md_next_token (md);
359 }
360 }
361 }
362 break;
363 default:
364 stmt.exetype.type = _MDX_DEFAULT;
365 break;
366 }
367 CALLBACK;
368 break;
369
370 case _MD_EXPORTS:
371 token = _md_next_token (md);
372 while (token == _MD_quote || token == _MD_word)
373 {
374 stmt.export.ordinal = 0;
375 stmt.export.pwords = 0;
376 stmt.export.flags = 0;
377 stmt.export.internalname[0] = 0;
378 _strncpy (stmt.export.entryname, _md_get_string (md),
379 sizeof (stmt.export.entryname));
380 token = _md_next_token (md);
381 if (token == _MD_equal)
382 {
383 token = _md_next_token (md);
384 if (token != _MD_quote && token != _MD_word)
385 ERROR (_MDE_NAME_EXPECTED);
386 _strncpy (stmt.export.internalname, _md_get_string (md),
387 sizeof (stmt.export.internalname));
388 token = _md_next_token (md);
389 }
390 if (token == _MD_at)
391 {
392 stmt.export.flags |= _MDEP_ORDINAL;
393 token = _md_next_token (md);
394 if (token != _MD_number)
395 ERROR (_MDE_NUMBER_EXPECTED);
396 n = _md_get_number (md);
397 if (n < 1 || n > 65535)
398 ERROR (_MDE_INVALID_ORDINAL);
399 stmt.export.ordinal = n;
400 token = _md_next_token (md);
401 if (token == _MD_NONAME)
402 {
403 stmt.export.flags |= _MDEP_NONAME;
404 token = _md_next_token (md);
405 }
406 else if (token == _MD_RESIDENTNAME)
407 {
408 stmt.export.flags |= _MDEP_RESIDENTNAME;
409 token = _md_next_token (md);
410 }
411 }
412 if (token == _MD_NODATA)
413 {
414 stmt.export.flags |= _MDEP_NODATA;
415 token = _md_next_token (md);
416 }
417 if (token == _MD_number)
418 {
419 stmt.export.flags |= _MDEP_PWORDS;
420 stmt.export.pwords = _md_get_number (md);
421 token = _md_next_token (md);
422 }
423 CALLBACK;
424 }
425 break;
426
427 case _MD_HEAPSIZE:
428 token = _md_next_token (md);
429 if (token == _MD_number)
430 {
431 stmt.heapsize.maxval = FALSE;
432 stmt.heapsize.size = _md_get_number (md);
433 }
434 else if (token == _MD_MAXVAL)
435 {
436 stmt.heapsize.size = 0;
437 stmt.heapsize.maxval = TRUE;
438 }
439 else
440 ERROR (_MDE_NUMBER_EXPECTED);
441 token = _md_next_token (md);
442 CALLBACK;
443 break;
444
445 case _MD_IMPORTS:
446 token = _md_next_token (md);
447 while (token == _MD_quote || token == _MD_word)
448 {
449 _strncpy (stmt.import.modulename, _md_get_string (md),
450 sizeof (stmt.import.modulename));
451 stmt.import.entryname[0] = 0;
452 stmt.import.internalname[0] = 0;
453 stmt.import.ordinal = 0;
454 stmt.import.flags = 0;
455 token = _md_next_token (md);
456 if (token == _MD_equal)
457 {
458 _strncpy (stmt.import.internalname, stmt.import.modulename,
459 sizeof (stmt.import.internalname));
460 token = _md_next_token (md);
461 if (token != _MD_quote && token != _MD_word)
462 ERROR (_MDE_NAME_EXPECTED);
463 _strncpy (stmt.import.modulename, _md_get_string (md),
464 sizeof (stmt.import.modulename));
465 token = _md_next_token (md);
466 }
467 if (token != _MD_dot)
468 ERROR (_MDE_DOT_EXPECTED);
469 token = _md_next_token (md);
470 if (token == _MD_word)
471 _strncpy (stmt.import.entryname, _md_get_string (md),
472 sizeof (stmt.import.entryname));
473 else if (token == _MD_number)
474 {
475 stmt.import.flags |= _MDIP_ORDINAL;
476 n = _md_get_number (md);
477 if (n < 1 || n > 65535)
478 ERROR (_MDE_INVALID_ORDINAL);
479 stmt.import.ordinal = n;
480 }
481 else
482 ERROR (_MDE_NUMBER_EXPECTED);
483 token = _md_next_token (md);
484 CALLBACK;
485 }
486 break;
487
488 case _MD_OLD:
489 token = _md_next_token (md);
490 if (token != _MD_quote)
491 ERROR (_MDE_STRING_EXPECTED);
492 _strncpy (stmt.old.name, _md_get_string (md),
493 sizeof (stmt.old.name));
494 token = _md_next_token (md);
495 CALLBACK;
496 break;
497
498 case _MD_PROTMODE:
499 case _MD_REALMODE:
500 token = _md_next_token (md);
501 CALLBACK;
502 break;
503
504 case _MD_SEGMENTS:
505 token = _md_next_token (md);
506 while (token == _MD_quote || token == _MD_word)
507 {
508 _strncpy (stmt.segment.segname, _md_get_string (md),
509 sizeof (stmt.segment.segname));
510 token = _md_next_token (md);
511 if (token == _MD_CLASS)
512 {
513 token = _md_next_token (md);
514 if (token != _MD_quote && token != _MD_word)
515 ERROR (_MDE_NAME_EXPECTED);
516 _strncpy (stmt.segment.classname, _md_get_string (md),
517 sizeof (stmt.segment.classname));
518 token = _md_next_token (md);
519 }
520 else
521 stmt.segment.classname[0] = 0;
522 stmt.segment.attr = 0;
523 ok = TRUE;
524 while (ok)
525 {
526 switch (token)
527 {
528 case _MD_ALIAS:
529 stmt.segment.attr |= _MDS_ALIAS;
530 break;
531 case _MD_CONFORMING:
532 stmt.segment.attr |= _MDS_CONFORMING;
533 break;
534 case _MD_DISCARDABLE:
535 stmt.segment.attr |= _MDS_DISCARDABLE;
536 break;
537 case _MD_EXECUTEONLY:
538 stmt.segment.attr |= _MDS_EXECUTEONLY;
539 break;
540 case _MD_EXECUTEREAD:
541 stmt.segment.attr |= _MDS_EXECUTEREAD;
542 break;
543 case _MD_FIXED:
544 stmt.segment.attr |= _MDS_FIXED;
545 break;
546 case _MD_INVALID:
547 stmt.segment.attr |= _MDS_INVALID;
548 break;
549 case _MD_IOPL:
550 stmt.segment.attr |= _MDS_IOPL;
551 break;
552 case _MD_LOADONCALL:
553 stmt.segment.attr |= _MDS_LOADONCALL;
554 break;
555 case _MD_MIXED1632:
556 stmt.segment.attr |= _MDS_MIXED1632;
557 break;
558 case _MD_MOVEABLE:
559 stmt.segment.attr |= _MDS_MOVEABLE;
560 break;
561 case _MD_NOIOPL:
562 stmt.segment.attr |= _MDS_NOIOPL;
563 break;
564 case _MD_NONCONFORMING:
565 stmt.segment.attr |= _MDS_NONCONFORMING;
566 break;
567 case _MD_NONDISCARDABLE:
568 stmt.segment.attr |= _MDS_NONDISCARDABLE;
569 break;
570 case _MD_NONSHARED:
571 case _MD_IMPURE:
572 stmt.segment.attr |= _MDS_NONSHARED;
573 break;
574 case _MD_PRELOAD:
575 stmt.segment.attr |= _MDS_PRELOAD;
576 break;
577 case _MD_READONLY:
578 stmt.segment.attr |= _MDS_READONLY;
579 break;
580 case _MD_READWRITE:
581 stmt.segment.attr |= _MDS_READWRITE;
582 break;
583 case _MD_SHARED:
584 case _MD_PURE:
585 stmt.segment.attr |= _MDS_SHARED;
586 break;
587 default:
588 ok = FALSE;
589 break;
590 }
591 if (ok)
592 token = _md_next_token (md);
593 }
594 CALLBACK;
595 }
596 break;
597
598 case _MD_STACKSIZE:
599 token = _md_next_token (md);
600 if (token != _MD_number)
601 ERROR (_MDE_NUMBER_EXPECTED);
602 stmt.stacksize.size = _md_get_number (md);
603 token = _md_next_token (md);
604 CALLBACK;
605 break;
606
607 case _MD_STUB:
608 token = _md_next_token (md);
609 if (token == _MD_quote)
610 {
611 _strncpy (stmt.stub.name, _md_get_string (md),
612 sizeof (stmt.stub.name));
613 stmt.stub.none = FALSE;
614 }
615 else if (token == _MD_NONE)
616 {
617 stmt.stub.name[0] = 0;
618 stmt.stub.none = TRUE;
619 }
620 else
621 ERROR (_MDE_STRING_EXPECTED);
622 token = _md_next_token (md);
623 CALLBACK;
624 break;
625
626 case _MD_ioerror:
627 ERROR (_MDE_IO_ERROR);
628 break;
629
630 case _MD_missingquote:
631 ERROR (_MDE_MISSING_QUOTE);
632 break;
633
634 default:
635 ERROR (_MDE_INVALID_STMT);
636 }
637 }
638 return 0;
639}
Note: See TracBrowser for help on using the repository browser.