4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Martin von Loewis
6 * Copyright 1995, 1996, 1997, 2004 Alexandre Julliard
7 * Copyright 1997 Eric Youngdale
8 * Copyright 1999 Ulrich Weigand
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wine/port.h"
39 static char ParseBuffer
[512];
40 static char TokenBuffer
[512];
41 static char *ParseNext
= ParseBuffer
;
42 static FILE *input_file
;
44 static const char *separator_chars
;
45 static const char *comment_chars
;
47 /* valid characters in ordinal names */
48 static const char valid_ordname_chars
[] = "/$:-_@?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
50 static const char * const TypeNames
[TYPE_NBTYPES
] =
52 "variable", /* TYPE_VARIABLE */
53 "pascal", /* TYPE_PASCAL */
54 "equate", /* TYPE_ABS */
55 "stub", /* TYPE_STUB */
56 "stdcall", /* TYPE_STDCALL */
57 "cdecl", /* TYPE_CDECL */
58 "varargs", /* TYPE_VARARGS */
59 "extern" /* TYPE_EXTERN */
62 static const char * const FlagNames
[] =
64 "norelay", /* FLAG_NORELAY */
65 "noname", /* FLAG_NONAME */
66 "ret16", /* FLAG_RET16 */
67 "ret64", /* FLAG_RET64 */
68 "register", /* FLAG_REGISTER */
69 "private", /* FLAG_PRIVATE */
70 "ordinal", /* FLAG_ORDINAL */
74 static int IsNumberString(const char *s
)
76 while (*s
) if (!isdigit(*s
++)) return 0;
80 static inline int is_token_separator( char ch
)
82 return strchr( separator_chars
, ch
) != NULL
;
85 static inline int is_token_comment( char ch
)
87 return strchr( comment_chars
, ch
) != NULL
;
90 /* get the next line from the input file, or return 0 if at eof */
91 static int get_next_line(void)
93 ParseNext
= ParseBuffer
;
95 return (fgets(ParseBuffer
, sizeof(ParseBuffer
), input_file
) != NULL
);
98 static const char * GetToken( int allow_eol
)
101 char *token
= TokenBuffer
;
105 /* remove initial white space */
107 while (isspace(*p
)) p
++;
109 if (*p
== '\\' && p
[1] == '\n') /* line continuation */
111 if (!get_next_line())
113 if (!allow_eol
) error( "Unexpected end of file\n" );
120 if ((*p
== '\0') || is_token_comment(*p
))
122 if (!allow_eol
) error( "Declaration not terminated properly\n" );
129 if (is_token_separator(*p
))
131 /* a separator is always a complete token */
134 else while (*p
!= '\0' && !is_token_separator(*p
) && !isspace(*p
))
137 if (*p
) *token
++ = *p
++;
145 static ORDDEF
*add_entry_point( DLLSPEC
*spec
)
149 if (spec
->nb_entry_points
== spec
->alloc_entry_points
)
151 spec
->alloc_entry_points
+= 128;
152 spec
->entry_points
= xrealloc( spec
->entry_points
,
153 spec
->alloc_entry_points
* sizeof(*spec
->entry_points
) );
155 ret
= &spec
->entry_points
[spec
->nb_entry_points
++];
156 memset( ret
, 0, sizeof(*ret
) );
160 /*******************************************************************
161 * parse_spec_variable
163 * Parse a variable definition in a .spec file.
165 static int parse_spec_variable( ORDDEF
*odp
, DLLSPEC
*spec
)
170 int value_array_size
;
173 if (spec
->type
== SPEC_WIN32
)
175 error( "'variable' not supported in Win32, use 'extern' instead\n" );
179 if (!(token
= GetToken(0))) return 0;
182 error( "Expected '(' got '%s'\n", token
);
187 value_array_size
= 25;
188 value_array
= xmalloc(sizeof(*value_array
) * value_array_size
);
192 if (!(token
= GetToken(0)))
200 value_array
[n_values
++] = strtol(token
, &endptr
, 0);
201 if (n_values
== value_array_size
)
203 value_array_size
+= 25;
204 value_array
= xrealloc(value_array
,
205 sizeof(*value_array
) * value_array_size
);
208 if (endptr
== NULL
|| *endptr
!= '\0')
210 error( "Expected number value, got '%s'\n", token
);
216 odp
->u
.var
.n_values
= n_values
;
217 odp
->u
.var
.values
= xrealloc(value_array
, sizeof(*value_array
) * n_values
);
222 /*******************************************************************
225 * Parse an exported function definition in a .spec file.
227 static int parse_spec_export( ORDDEF
*odp
, DLLSPEC
*spec
)
235 if (odp
->type
== TYPE_STDCALL
)
237 error( "'stdcall' not supported for Win16\n" );
242 if (odp
->type
== TYPE_PASCAL
)
244 error( "'pascal' not supported for Win32\n" );
252 if (!(token
= GetToken(0))) return 0;
255 error( "Expected '(' got '%s'\n", token
);
259 for (i
= 0; i
< sizeof(odp
->u
.func
.arg_types
); i
++)
261 if (!(token
= GetToken(0))) return 0;
265 if (!strcmp(token
, "word"))
266 odp
->u
.func
.arg_types
[i
] = 'w';
267 else if (!strcmp(token
, "s_word"))
268 odp
->u
.func
.arg_types
[i
] = 's';
269 else if (!strcmp(token
, "long") || !strcmp(token
, "segptr"))
270 odp
->u
.func
.arg_types
[i
] = 'l';
271 else if (!strcmp(token
, "ptr"))
272 odp
->u
.func
.arg_types
[i
] = 'p';
273 else if (!strcmp(token
, "str"))
274 odp
->u
.func
.arg_types
[i
] = 't';
275 else if (!strcmp(token
, "wstr"))
276 odp
->u
.func
.arg_types
[i
] = 'W';
277 else if (!strcmp(token
, "segstr"))
278 odp
->u
.func
.arg_types
[i
] = 'T';
279 else if (!strcmp(token
, "double"))
281 odp
->u
.func
.arg_types
[i
++] = 'l';
282 if (get_ptr_size() == 4 && i
< sizeof(odp
->u
.func
.arg_types
))
283 odp
->u
.func
.arg_types
[i
] = 'l';
287 error( "Unknown argument type '%s'\n", token
);
291 if (spec
->type
== SPEC_WIN32
)
293 if (strcmp(token
, "long") &&
294 strcmp(token
, "ptr") &&
295 strcmp(token
, "str") &&
296 strcmp(token
, "wstr") &&
297 strcmp(token
, "double"))
299 error( "Type '%s' not supported for Win32\n", token
);
304 if ((*token
!= ')') || (i
>= sizeof(odp
->u
.func
.arg_types
)))
306 error( "Too many arguments\n" );
310 odp
->u
.func
.arg_types
[i
] = '\0';
311 if (odp
->type
== TYPE_VARARGS
)
312 odp
->flags
|= FLAG_NORELAY
; /* no relay debug possible for varags entry point */
314 if (!(token
= GetToken(1)))
316 if (!strcmp( odp
->name
, "@" ))
318 error( "Missing handler name for anonymous function\n" );
321 odp
->link_name
= xstrdup( odp
->name
);
325 odp
->link_name
= xstrdup( token
);
326 if (strchr( odp
->link_name
, '.' ))
328 if (spec
->type
== SPEC_WIN16
)
330 error( "Forwarded functions not supported for Win16\n" );
333 odp
->flags
|= FLAG_FORWARD
;
340 /*******************************************************************
343 * Parse an 'equate' definition in a .spec file.
345 static int parse_spec_equate( ORDDEF
*odp
, DLLSPEC
*spec
)
351 if (spec
->type
== SPEC_WIN32
)
353 error( "'equate' not supported for Win32\n" );
356 if (!(token
= GetToken(0))) return 0;
357 value
= strtol(token
, &endptr
, 0);
358 if (endptr
== NULL
|| *endptr
!= '\0')
360 error( "Expected number value, got '%s'\n", token
);
363 if (value
< -0x8000 || value
> 0xffff)
365 error( "Value %d for absolute symbol doesn't fit in 16 bits\n", value
);
368 odp
->u
.abs
.value
= value
;
373 /*******************************************************************
376 * Parse a 'stub' definition in a .spec file
378 static int parse_spec_stub( ORDDEF
*odp
, DLLSPEC
*spec
)
380 odp
->u
.func
.arg_types
[0] = '\0';
381 odp
->link_name
= xstrdup("");
382 odp
->flags
|= FLAG_CPU(CPU_x86
) | FLAG_CPU(CPU_x86_64
); /* don't bother generating stubs for Winelib */
387 /*******************************************************************
390 * Parse an 'extern' definition in a .spec file.
392 static int parse_spec_extern( ORDDEF
*odp
, DLLSPEC
*spec
)
396 if (spec
->type
== SPEC_WIN16
)
398 error( "'extern' not supported for Win16, use 'variable' instead\n" );
401 if (!(token
= GetToken(1)))
403 if (!strcmp( odp
->name
, "@" ))
405 error( "Missing handler name for anonymous extern\n" );
408 odp
->link_name
= xstrdup( odp
->name
);
412 odp
->link_name
= xstrdup( token
);
413 if (strchr( odp
->link_name
, '.' )) odp
->flags
|= FLAG_FORWARD
;
419 /*******************************************************************
422 * Parse the optional flags for an entry point in a .spec file.
424 static const char *parse_spec_flags( ORDDEF
*odp
)
431 if (!(token
= GetToken(0))) break;
432 if (!strncmp( token
, "arch=", 5))
434 char *args
= xstrdup( token
+ 5 );
435 char *cpu_name
= strtok( args
, "," );
438 if (!strcmp( cpu_name
, "win32" ))
439 odp
->flags
|= FLAG_CPU_WIN32
;
440 else if (!strcmp( cpu_name
, "win64" ))
441 odp
->flags
|= FLAG_CPU_WIN64
;
444 enum target_cpu cpu
= get_cpu_from_name( cpu_name
);
447 error( "Unknown architecture '%s'\n", cpu_name
);
450 odp
->flags
|= FLAG_CPU( cpu
);
452 cpu_name
= strtok( NULL
, "," );
456 else if (!strcmp( token
, "i386" )) /* backwards compatibility */
458 odp
->flags
|= FLAG_CPU(CPU_x86
);
462 for (i
= 0; FlagNames
[i
]; i
++)
463 if (!strcmp( FlagNames
[i
], token
)) break;
466 error( "Unknown flag '%s'\n", token
);
469 odp
->flags
|= 1 << i
;
472 } while (token
&& *token
== '-');
478 /*******************************************************************
481 * Parse an ordinal definition in a .spec file.
483 static int parse_spec_ordinal( int ordinal
, DLLSPEC
*spec
)
487 ORDDEF
*odp
= add_entry_point( spec
);
489 if (!(token
= GetToken(0))) goto error
;
491 for (odp
->type
= 0; odp
->type
< TYPE_NBTYPES
; odp
->type
++)
492 if (TypeNames
[odp
->type
] && !strcmp( token
, TypeNames
[odp
->type
] ))
495 if (odp
->type
>= TYPE_NBTYPES
)
497 error( "Expected type after ordinal, found '%s' instead\n", token
);
501 if (!(token
= GetToken(0))) goto error
;
502 if (*token
== '-' && !(token
= parse_spec_flags( odp
))) goto error
;
504 odp
->name
= xstrdup( token
);
505 odp
->lineno
= current_line
;
506 odp
->ordinal
= ordinal
;
508 len
= strspn( odp
->name
, valid_ordname_chars
);
509 if (len
< strlen( odp
->name
))
511 error( "Character '%c' is not allowed in exported name '%s'\n", odp
->name
[len
], odp
->name
);
518 if (!parse_spec_variable( odp
, spec
)) goto error
;
524 if (!parse_spec_export( odp
, spec
)) goto error
;
527 if (!parse_spec_equate( odp
, spec
)) goto error
;
530 if (!parse_spec_stub( odp
, spec
)) goto error
;
533 if (!parse_spec_extern( odp
, spec
)) goto error
;
539 if ((odp
->flags
& FLAG_CPU_MASK
) && !(odp
->flags
& FLAG_CPU(target_cpu
)))
541 /* ignore this entry point */
542 spec
->nb_entry_points
--;
550 error( "Ordinal 0 is not valid\n" );
553 if (ordinal
>= MAX_ORDINALS
)
555 error( "Ordinal number %d too large\n", ordinal
);
558 if (ordinal
> spec
->limit
) spec
->limit
= ordinal
;
559 if (ordinal
< spec
->base
) spec
->base
= ordinal
;
560 odp
->ordinal
= ordinal
;
563 if (odp
->type
== TYPE_STDCALL
&& !(odp
->flags
& FLAG_PRIVATE
))
565 if (!strcmp( odp
->name
, "DllRegisterServer" ) ||
566 !strcmp( odp
->name
, "DllUnregisterServer" ) ||
567 !strcmp( odp
->name
, "DllGetClassObject" ) ||
568 !strcmp( odp
->name
, "DllGetVersion" ) ||
569 !strcmp( odp
->name
, "DllInstall" ) ||
570 !strcmp( odp
->name
, "DllCanUnloadNow" ))
572 warning( "Function %s should be marked private\n", odp
->name
);
573 if (strcmp( odp
->name
, odp
->link_name
))
574 warning( "Function %s should not use a different internal name (%s)\n",
575 odp
->name
, odp
->link_name
);
579 if (!strcmp( odp
->name
, "@" ) || odp
->flags
& (FLAG_NONAME
| FLAG_ORDINAL
))
583 if (!strcmp( odp
->name
, "@" ))
584 error( "Nameless function needs an explicit ordinal number\n" );
586 error( "Function imported by ordinal needs an explicit ordinal number\n" );
589 if (spec
->type
!= SPEC_WIN32
)
591 error( "Nameless functions not supported for Win16\n" );
594 if (!strcmp( odp
->name
, "@" ))
599 else if (!(odp
->flags
& FLAG_ORDINAL
)) /* -ordinal only affects the import library */
601 odp
->export_name
= odp
->name
;
608 spec
->nb_entry_points
--;
614 static int name_compare( const void *ptr1
, const void *ptr2
)
616 const ORDDEF
*odp1
= *(const ORDDEF
* const *)ptr1
;
617 const ORDDEF
*odp2
= *(const ORDDEF
* const *)ptr2
;
618 const char *name1
= odp1
->name
? odp1
->name
: odp1
->export_name
;
619 const char *name2
= odp2
->name
? odp2
->name
: odp2
->export_name
;
620 return strcmp( name1
, name2
);
623 /*******************************************************************
626 * Build the name array and catch duplicates.
628 static void assign_names( DLLSPEC
*spec
)
630 int i
, j
, nb_exp_names
= 0;
634 for (i
= 0; i
< spec
->nb_entry_points
; i
++)
635 if (spec
->entry_points
[i
].name
) spec
->nb_names
++;
636 else if (spec
->entry_points
[i
].export_name
) nb_exp_names
++;
638 if (!spec
->nb_names
&& !nb_exp_names
) return;
640 /* check for duplicates */
642 all_names
= xmalloc( (spec
->nb_names
+ nb_exp_names
) * sizeof(all_names
[0]) );
643 for (i
= j
= 0; i
< spec
->nb_entry_points
; i
++)
644 if (spec
->entry_points
[i
].name
|| spec
->entry_points
[i
].export_name
)
645 all_names
[j
++] = &spec
->entry_points
[i
];
647 qsort( all_names
, j
, sizeof(all_names
[0]), name_compare
);
649 for (i
= 0; i
< j
- 1; i
++)
651 const char *name1
= all_names
[i
]->name
? all_names
[i
]->name
: all_names
[i
]->export_name
;
652 const char *name2
= all_names
[i
+1]->name
? all_names
[i
+1]->name
: all_names
[i
+1]->export_name
;
653 if (!strcmp( name1
, name2
))
655 current_line
= max( all_names
[i
]->lineno
, all_names
[i
+1]->lineno
);
656 error( "'%s' redefined\n%s:%d: First defined here\n",
657 name1
, input_file_name
,
658 min( all_names
[i
]->lineno
, all_names
[i
+1]->lineno
) );
665 spec
->names
= xmalloc( spec
->nb_names
* sizeof(spec
->names
[0]) );
666 for (i
= j
= 0; i
< spec
->nb_entry_points
; i
++)
667 if (spec
->entry_points
[i
].name
) spec
->names
[j
++] = &spec
->entry_points
[i
];
669 /* sort the list of names */
670 qsort( spec
->names
, spec
->nb_names
, sizeof(spec
->names
[0]), name_compare
);
674 /*******************************************************************
677 * Build the ordinal array.
679 static void assign_ordinals( DLLSPEC
*spec
)
681 int i
, count
, ordinal
;
683 /* start assigning from base, or from 1 if no ordinal defined yet */
685 spec
->base
= MAX_ORDINALS
;
687 for (i
= 0; i
< spec
->nb_entry_points
; i
++)
689 ordinal
= spec
->entry_points
[i
].ordinal
;
690 if (ordinal
== -1) continue;
691 if (ordinal
> spec
->limit
) spec
->limit
= ordinal
;
692 if (ordinal
< spec
->base
) spec
->base
= ordinal
;
694 if (spec
->base
== MAX_ORDINALS
) spec
->base
= 1;
695 if (spec
->limit
< spec
->base
) spec
->limit
= spec
->base
;
697 count
= max( spec
->limit
+ 1, spec
->base
+ spec
->nb_entry_points
);
698 spec
->ordinals
= xmalloc( count
* sizeof(spec
->ordinals
[0]) );
699 memset( spec
->ordinals
, 0, count
* sizeof(spec
->ordinals
[0]) );
701 /* fill in all explicitly specified ordinals */
702 for (i
= 0; i
< spec
->nb_entry_points
; i
++)
704 ordinal
= spec
->entry_points
[i
].ordinal
;
705 if (ordinal
== -1) continue;
706 if (spec
->ordinals
[ordinal
])
708 current_line
= max( spec
->entry_points
[i
].lineno
, spec
->ordinals
[ordinal
]->lineno
);
709 error( "ordinal %d redefined\n%s:%d: First defined here\n",
710 ordinal
, input_file_name
,
711 min( spec
->entry_points
[i
].lineno
, spec
->ordinals
[ordinal
]->lineno
) );
713 else spec
->ordinals
[ordinal
] = &spec
->entry_points
[i
];
716 /* now assign ordinals to the rest */
717 for (i
= 0, ordinal
= spec
->base
; i
< spec
->nb_entry_points
; i
++)
719 if (spec
->entry_points
[i
].ordinal
!= -1) continue;
720 while (spec
->ordinals
[ordinal
]) ordinal
++;
721 if (ordinal
>= MAX_ORDINALS
)
723 current_line
= spec
->entry_points
[i
].lineno
;
724 fatal_error( "Too many functions defined (max %d)\n", MAX_ORDINALS
);
726 spec
->entry_points
[i
].ordinal
= ordinal
;
727 spec
->ordinals
[ordinal
] = &spec
->entry_points
[i
];
729 if (ordinal
> spec
->limit
) spec
->limit
= ordinal
;
733 /*******************************************************************
736 * Add the necessary exports to the 32-bit counterpart of a 16-bit module.
738 void add_16bit_exports( DLLSPEC
*spec32
, DLLSPEC
*spec16
)
742 /* add an export for the NE module */
744 odp
= add_entry_point( spec32
);
745 odp
->type
= TYPE_EXTERN
;
746 odp
->name
= xstrdup( "__wine_spec_dos_header" );
749 odp
->link_name
= xstrdup( ".L__wine_spec_dos_header" );
751 if (spec16
->main_module
)
753 odp
= add_entry_point( spec32
);
754 odp
->type
= TYPE_EXTERN
;
755 odp
->name
= xstrdup( "__wine_spec_main_module" );
758 odp
->link_name
= xstrdup( ".L__wine_spec_main_module" );
761 assign_names( spec32
);
762 assign_ordinals( spec32
);
766 /*******************************************************************
769 * Parse a .spec file.
771 int parse_spec_file( FILE *file
, DLLSPEC
*spec
)
778 comment_chars
= "#;";
779 separator_chars
= "()-";
781 while (get_next_line())
783 if (!(token
= GetToken(1))) continue;
784 if (strcmp(token
, "@") == 0)
786 if (spec
->type
!= SPEC_WIN32
)
788 error( "'@' ordinals not supported for Win16\n" );
791 if (!parse_spec_ordinal( -1, spec
)) continue;
793 else if (IsNumberString(token
))
795 if (!parse_spec_ordinal( atoi(token
), spec
)) continue;
799 error( "Expected ordinal declaration, got '%s'\n", token
);
802 if ((token
= GetToken(1))) error( "Syntax error near '%s'\n", token
);
805 current_line
= 0; /* no longer parsing the input file */
806 assign_names( spec
);
807 assign_ordinals( spec
);
812 /*******************************************************************
815 * Parse a LIBRARY declaration in a .def file.
817 static int parse_def_library( DLLSPEC
*spec
)
819 const char *token
= GetToken(1);
821 if (!token
) return 1;
822 if (strcmp( token
, "BASE" ))
824 free( spec
->file_name
);
825 spec
->file_name
= xstrdup( token
);
826 if (!(token
= GetToken(1))) return 1;
828 if (strcmp( token
, "BASE" ))
830 error( "Expected library name or BASE= declaration, got '%s'\n", token
);
833 if (!(token
= GetToken(0))) return 0;
834 if (strcmp( token
, "=" ))
836 error( "Expected '=' after BASE, got '%s'\n", token
);
839 if (!(token
= GetToken(0))) return 0;
840 /* FIXME: do something with base address */
846 /*******************************************************************
847 * parse_def_stack_heap_size
849 * Parse a STACKSIZE or HEAPSIZE declaration in a .def file.
851 static int parse_def_stack_heap_size( int is_stack
, DLLSPEC
*spec
)
853 const char *token
= GetToken(0);
857 if (!token
) return 0;
858 size
= strtoul( token
, &end
, 0 );
861 error( "Invalid number '%s'\n", token
);
864 if (is_stack
) spec
->stack_size
= size
/ 1024;
865 else spec
->heap_size
= size
/ 1024;
866 if (!(token
= GetToken(1))) return 1;
867 if (strcmp( token
, "," ))
869 error( "Expected ',' after size, got '%s'\n", token
);
872 if (!(token
= GetToken(0))) return 0;
873 /* FIXME: do something with reserve size */
878 /*******************************************************************
881 * Parse an export declaration in a .def file.
883 static int parse_def_export( char *name
, DLLSPEC
*spec
)
886 const char *token
= GetToken(1);
887 ORDDEF
*odp
= add_entry_point( spec
);
889 odp
->lineno
= current_line
;
892 args
= remove_stdcall_decoration( odp
->name
);
893 if (args
== -1) odp
->type
= TYPE_CDECL
;
896 odp
->type
= TYPE_STDCALL
;
897 args
/= get_ptr_size();
898 if (args
>= sizeof(odp
->u
.func
.arg_types
))
900 error( "Too many arguments in stdcall function '%s'\n", odp
->name
);
903 for (i
= 0; i
< args
; i
++) odp
->u
.func
.arg_types
[i
] = 'l';
906 /* check for optional internal name */
908 if (token
&& !strcmp( token
, "=" ))
910 if (!(token
= GetToken(0))) goto error
;
911 odp
->link_name
= xstrdup( token
);
912 remove_stdcall_decoration( odp
->link_name
);
917 odp
->link_name
= xstrdup( name
);
920 /* check for optional ordinal */
922 if (token
&& token
[0] == '@')
926 if (!IsNumberString( token
+1 ))
928 error( "Expected number after '@', got '%s'\n", token
+1 );
931 ordinal
= atoi( token
+1 );
934 error( "Ordinal 0 is not valid\n" );
937 if (ordinal
>= MAX_ORDINALS
)
939 error( "Ordinal number %d too large\n", ordinal
);
942 odp
->ordinal
= ordinal
;
946 /* check for other optional keywords */
948 if (token
&& !strcmp( token
, "NONAME" ))
950 if (odp
->ordinal
== -1)
952 error( "NONAME requires an ordinal\n" );
955 odp
->export_name
= odp
->name
;
957 odp
->flags
|= FLAG_NONAME
;
960 if (token
&& !strcmp( token
, "PRIVATE" ))
962 odp
->flags
|= FLAG_PRIVATE
;
965 if (token
&& !strcmp( token
, "DATA" ))
967 odp
->type
= TYPE_EXTERN
;
972 error( "Garbage text '%s' found at end of export declaration\n", token
);
978 spec
->nb_entry_points
--;
984 /*******************************************************************
989 int parse_def_file( FILE *file
, DLLSPEC
*spec
)
998 separator_chars
= ",=";
1000 while (get_next_line())
1002 if (!(token
= GetToken(1))) continue;
1004 if (!strcmp( token
, "LIBRARY" ) || !strcmp( token
, "NAME" ))
1006 if (!parse_def_library( spec
)) continue;
1009 else if (!strcmp( token
, "STACKSIZE" ))
1011 if (!parse_def_stack_heap_size( 1, spec
)) continue;
1014 else if (!strcmp( token
, "HEAPSIZE" ))
1016 if (!parse_def_stack_heap_size( 0, spec
)) continue;
1019 else if (!strcmp( token
, "EXPORTS" ))
1022 if (!(token
= GetToken(1))) continue;
1024 else if (!strcmp( token
, "IMPORTS" ))
1027 if (!(token
= GetToken(1))) continue;
1029 else if (!strcmp( token
, "SECTIONS" ))
1032 if (!(token
= GetToken(1))) continue;
1035 if (!in_exports
) continue; /* ignore this line */
1036 if (!parse_def_export( xstrdup(token
), spec
)) continue;
1039 if ((token
= GetToken(1))) error( "Syntax error near '%s'\n", token
);
1042 current_line
= 0; /* no longer parsing the input file */
1043 assign_names( spec
);
1044 assign_ordinals( spec
);