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"
41 static char ParseBuffer[512];
42 static char TokenBuffer[512];
43 static char *ParseNext = ParseBuffer;
44 static FILE *input_file;
46 static const char *separator_chars;
47 static const char *comment_chars;
49 /* valid characters in ordinal names */
50 static const char valid_ordname_chars[] = "/$:-_@?abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
52 static const char * const TypeNames[TYPE_NBTYPES] =
54 "variable", /* TYPE_VARIABLE */
55 "pascal", /* TYPE_PASCAL */
56 "equate", /* TYPE_ABS */
57 "stub", /* TYPE_STUB */
58 "stdcall", /* TYPE_STDCALL */
59 "cdecl", /* TYPE_CDECL */
60 "varargs", /* TYPE_VARARGS */
61 "extern" /* TYPE_EXTERN */
64 static const char * const FlagNames[] =
66 "norelay", /* FLAG_NORELAY */
67 "noname", /* FLAG_NONAME */
68 "ret16", /* FLAG_RET16 */
69 "ret64", /* FLAG_RET64 */
70 "i386", /* FLAG_I386 */
71 "register", /* FLAG_REGISTER */
72 "private", /* FLAG_PRIVATE */
73 "ordinal", /* FLAG_ORDINAL */
77 static int IsNumberString(const char *s)
79 while (*s) if (!isdigit(*s++)) return 0;
83 static inline int is_token_separator( char ch )
85 return strchr( separator_chars, ch ) != NULL;
88 static inline int is_token_comment( char ch )
90 return strchr( comment_chars, ch ) != NULL;
93 /* get the next line from the input file, or return 0 if at eof */
94 static int get_next_line(void)
96 ParseNext = ParseBuffer;
98 return (fgets(ParseBuffer, sizeof(ParseBuffer), input_file) != NULL);
101 static const char * GetToken( int allow_eol )
104 char *token = TokenBuffer;
108 /* remove initial white space */
110 while (isspace(*p)) p++;
112 if (*p == '\\' && p[1] == '\n') /* line continuation */
114 if (!get_next_line())
116 if (!allow_eol) error( "Unexpected end of file\n" );
123 if ((*p == '\0') || is_token_comment(*p))
125 if (!allow_eol) error( "Declaration not terminated properly\n" );
132 if (is_token_separator(*p))
134 /* a separator is always a complete token */
137 else while (*p != '\0' && !is_token_separator(*p) && !isspace(*p))
140 if (*p) *token++ = *p++;
148 static ORDDEF *add_entry_point( DLLSPEC *spec )
150 if (spec->nb_entry_points == spec->alloc_entry_points)
152 spec->alloc_entry_points += 128;
153 spec->entry_points = xrealloc( spec->entry_points,
154 spec->alloc_entry_points * sizeof(*spec->entry_points) );
156 return &spec->entry_points[spec->nb_entry_points++];
159 /*******************************************************************
160 * parse_spec_variable
162 * Parse a variable definition in a .spec file.
164 static int parse_spec_variable( ORDDEF *odp, DLLSPEC *spec )
169 int value_array_size;
172 if (spec->type == SPEC_WIN32)
174 error( "'variable' not supported in Win32, use 'extern' instead\n" );
178 if (!(token = GetToken(0))) return 0;
181 error( "Expected '(' got '%s'\n", token );
186 value_array_size = 25;
187 value_array = xmalloc(sizeof(*value_array) * value_array_size);
191 if (!(token = GetToken(0)))
199 value_array[n_values++] = strtol(token, &endptr, 0);
200 if (n_values == value_array_size)
202 value_array_size += 25;
203 value_array = xrealloc(value_array,
204 sizeof(*value_array) * value_array_size);
207 if (endptr == NULL || *endptr != '\0')
209 error( "Expected number value, got '%s'\n", token );
215 odp->u.var.n_values = n_values;
216 odp->u.var.values = xrealloc(value_array, sizeof(*value_array) * n_values);
221 /*******************************************************************
224 * Parse an exported function definition in a .spec file.
226 static int parse_spec_export( ORDDEF *odp, DLLSPEC *spec )
234 if (odp->type == TYPE_STDCALL)
236 error( "'stdcall' not supported for Win16\n" );
241 if (odp->type == TYPE_PASCAL)
243 error( "'pascal' not supported for Win32\n" );
251 if (!(token = GetToken(0))) return 0;
254 error( "Expected '(' got '%s'\n", token );
258 for (i = 0; i < sizeof(odp->u.func.arg_types); i++)
260 if (!(token = GetToken(0))) return 0;
264 if (!strcmp(token, "word"))
265 odp->u.func.arg_types[i] = 'w';
266 else if (!strcmp(token, "s_word"))
267 odp->u.func.arg_types[i] = 's';
268 else if (!strcmp(token, "long") || !strcmp(token, "segptr"))
269 odp->u.func.arg_types[i] = 'l';
270 else if (!strcmp(token, "ptr"))
271 odp->u.func.arg_types[i] = 'p';
272 else if (!strcmp(token, "str"))
273 odp->u.func.arg_types[i] = 't';
274 else if (!strcmp(token, "wstr"))
275 odp->u.func.arg_types[i] = 'W';
276 else if (!strcmp(token, "segstr"))
277 odp->u.func.arg_types[i] = 'T';
278 else if (!strcmp(token, "double"))
280 odp->u.func.arg_types[i++] = 'l';
281 if (get_ptr_size() == 4 && i < sizeof(odp->u.func.arg_types))
282 odp->u.func.arg_types[i] = 'l';
286 error( "Unknown argument type '%s'\n", token );
290 if (spec->type == SPEC_WIN32)
292 if (strcmp(token, "long") &&
293 strcmp(token, "ptr") &&
294 strcmp(token, "str") &&
295 strcmp(token, "wstr") &&
296 strcmp(token, "double"))
298 error( "Type '%s' not supported for Win32\n", token );
303 if ((*token != ')') || (i >= sizeof(odp->u.func.arg_types)))
305 error( "Too many arguments\n" );
309 odp->u.func.arg_types[i] = '\0';
310 if (odp->type == TYPE_VARARGS)
311 odp->flags |= FLAG_NORELAY; /* no relay debug possible for varags entry point */
313 if (!(token = GetToken(1)))
315 if (!strcmp( odp->name, "@" ))
317 error( "Missing handler name for anonymous function\n" );
320 odp->link_name = xstrdup( odp->name );
324 odp->link_name = xstrdup( token );
325 if (strchr( odp->link_name, '.' ))
327 if (spec->type == SPEC_WIN16)
329 error( "Forwarded functions not supported for Win16\n" );
332 odp->flags |= FLAG_FORWARD;
339 /*******************************************************************
342 * Parse an 'equate' definition in a .spec file.
344 static int parse_spec_equate( ORDDEF *odp, DLLSPEC *spec )
350 if (spec->type == SPEC_WIN32)
352 error( "'equate' not supported for Win32\n" );
355 if (!(token = GetToken(0))) return 0;
356 value = strtol(token, &endptr, 0);
357 if (endptr == NULL || *endptr != '\0')
359 error( "Expected number value, got '%s'\n", token );
362 if (value < -0x8000 || value > 0xffff)
364 error( "Value %d for absolute symbol doesn't fit in 16 bits\n", value );
367 odp->u.abs.value = value;
372 /*******************************************************************
375 * Parse a 'stub' definition in a .spec file
377 static int parse_spec_stub( ORDDEF *odp, DLLSPEC *spec )
379 odp->u.func.arg_types[0] = '\0';
380 odp->link_name = xstrdup("");
381 odp->flags |= FLAG_I386; /* don't bother generating stubs for Winelib */
386 /*******************************************************************
389 * Parse an 'extern' definition in a .spec file.
391 static int parse_spec_extern( ORDDEF *odp, DLLSPEC *spec )
395 if (spec->type == SPEC_WIN16)
397 error( "'extern' not supported for Win16, use 'variable' instead\n" );
400 if (!(token = GetToken(1)))
402 if (!strcmp( odp->name, "@" ))
404 error( "Missing handler name for anonymous extern\n" );
407 odp->link_name = xstrdup( odp->name );
411 odp->link_name = xstrdup( token );
412 if (strchr( odp->link_name, '.' )) odp->flags |= FLAG_FORWARD;
418 /*******************************************************************
421 * Parse the optional flags for an entry point in a .spec file.
423 static const char *parse_spec_flags( ORDDEF *odp )
430 if (!(token = GetToken(0))) break;
431 for (i = 0; FlagNames[i]; i++)
432 if (!strcmp( FlagNames[i], token )) break;
435 error( "Unknown flag '%s'\n", token );
438 odp->flags |= 1 << i;
440 } while (token && *token == '-');
446 /*******************************************************************
449 * Parse an ordinal definition in a .spec file.
451 static int parse_spec_ordinal( int ordinal, DLLSPEC *spec )
456 ORDDEF *odp = add_entry_point( spec );
457 memset( odp, 0, sizeof(*odp) );
459 if (!(token = GetToken(0))) goto error;
461 for (odp->type = 0; odp->type < TYPE_NBTYPES; odp->type++)
462 if (TypeNames[odp->type] && !strcmp( token, TypeNames[odp->type] ))
465 if (odp->type >= TYPE_NBTYPES)
467 error( "Expected type after ordinal, found '%s' instead\n", token );
471 if (!(token = GetToken(0))) goto error;
472 if (*token == '-' && !(token = parse_spec_flags( odp ))) goto error;
474 odp->name = xstrdup( token );
475 odp->lineno = current_line;
476 odp->ordinal = ordinal;
478 len = strspn( odp->name, valid_ordname_chars );
479 if (len < strlen( odp->name ))
481 error( "Character '%c' is not allowed in exported name '%s'\n", odp->name[len], odp->name );
488 if (!parse_spec_variable( odp, spec )) goto error;
494 if (!parse_spec_export( odp, spec )) goto error;
497 if (!parse_spec_equate( odp, spec )) goto error;
500 if (!parse_spec_stub( odp, spec )) goto error;
503 if (!parse_spec_extern( odp, spec )) goto error;
509 if ((target_cpu != CPU_x86) && (odp->flags & FLAG_I386))
511 /* ignore this entry point on non-Intel archs */
512 spec->nb_entry_points--;
520 error( "Ordinal 0 is not valid\n" );
523 if (ordinal >= MAX_ORDINALS)
525 error( "Ordinal number %d too large\n", ordinal );
528 if (ordinal > spec->limit) spec->limit = ordinal;
529 if (ordinal < spec->base) spec->base = ordinal;
530 odp->ordinal = ordinal;
533 if (odp->type == TYPE_STDCALL && !(odp->flags & FLAG_PRIVATE))
535 if (!strcmp( odp->name, "DllRegisterServer" ) ||
536 !strcmp( odp->name, "DllUnregisterServer" ) ||
537 !strcmp( odp->name, "DllGetClassObject" ) ||
538 !strcmp( odp->name, "DllGetVersion" ) ||
539 !strcmp( odp->name, "DllInstall" ) ||
540 !strcmp( odp->name, "DllCanUnloadNow" ))
542 warning( "Function %s should be marked private\n", odp->name );
543 if (strcmp( odp->name, odp->link_name ))
544 warning( "Function %s should not use a different internal name (%s)\n",
545 odp->name, odp->link_name );
549 if (!strcmp( odp->name, "@" ) || odp->flags & (FLAG_NONAME | FLAG_ORDINAL))
553 if (!strcmp( odp->name, "@" ))
554 error( "Nameless function needs an explicit ordinal number\n" );
556 error( "Function imported by ordinal needs an explicit ordinal number\n" );
559 if (spec->type != SPEC_WIN32)
561 error( "Nameless functions not supported for Win16\n" );
564 if (!strcmp( odp->name, "@" ))
569 else if (!(odp->flags & FLAG_ORDINAL)) /* -ordinal only affects the import library */
571 odp->export_name = odp->name;
578 spec->nb_entry_points--;
584 static int name_compare( const void *ptr1, const void *ptr2 )
586 const ORDDEF *odp1 = *(const ORDDEF * const *)ptr1;
587 const ORDDEF *odp2 = *(const ORDDEF * const *)ptr2;
588 const char *name1 = odp1->name ? odp1->name : odp1->export_name;
589 const char *name2 = odp2->name ? odp2->name : odp2->export_name;
590 return strcmp( name1, name2 );
593 /*******************************************************************
596 * Build the name array and catch duplicates.
598 static void assign_names( DLLSPEC *spec )
600 int i, j, nb_exp_names = 0;
604 for (i = 0; i < spec->nb_entry_points; i++)
605 if (spec->entry_points[i].name) spec->nb_names++;
606 else if (spec->entry_points[i].export_name) nb_exp_names++;
608 if (!spec->nb_names && !nb_exp_names) return;
610 /* check for duplicates */
612 all_names = xmalloc( (spec->nb_names + nb_exp_names) * sizeof(all_names[0]) );
613 for (i = j = 0; i < spec->nb_entry_points; i++)
614 if (spec->entry_points[i].name || spec->entry_points[i].export_name)
615 all_names[j++] = &spec->entry_points[i];
617 qsort( all_names, j, sizeof(all_names[0]), name_compare );
619 for (i = 0; i < j - 1; i++)
621 const char *name1 = all_names[i]->name ? all_names[i]->name : all_names[i]->export_name;
622 const char *name2 = all_names[i+1]->name ? all_names[i+1]->name : all_names[i+1]->export_name;
623 if (!strcmp( name1, name2 ))
625 current_line = max( all_names[i]->lineno, all_names[i+1]->lineno );
626 error( "'%s' redefined\n%s:%d: First defined here\n",
627 name1, input_file_name,
628 min( all_names[i]->lineno, all_names[i+1]->lineno ) );
635 spec->names = xmalloc( spec->nb_names * sizeof(spec->names[0]) );
636 for (i = j = 0; i < spec->nb_entry_points; i++)
637 if (spec->entry_points[i].name) spec->names[j++] = &spec->entry_points[i];
639 /* sort the list of names */
640 qsort( spec->names, spec->nb_names, sizeof(spec->names[0]), name_compare );
644 /*******************************************************************
647 * Build the ordinal array.
649 static void assign_ordinals( DLLSPEC *spec )
651 int i, count, ordinal;
653 /* start assigning from base, or from 1 if no ordinal defined yet */
655 spec->base = MAX_ORDINALS;
657 for (i = 0; i < spec->nb_entry_points; i++)
659 ordinal = spec->entry_points[i].ordinal;
660 if (ordinal == -1) continue;
661 if (ordinal > spec->limit) spec->limit = ordinal;
662 if (ordinal < spec->base) spec->base = ordinal;
664 if (spec->base == MAX_ORDINALS) spec->base = 1;
665 if (spec->limit < spec->base) spec->limit = spec->base;
667 count = max( spec->limit + 1, spec->base + spec->nb_entry_points );
668 spec->ordinals = xmalloc( count * sizeof(spec->ordinals[0]) );
669 memset( spec->ordinals, 0, count * sizeof(spec->ordinals[0]) );
671 /* fill in all explicitly specified ordinals */
672 for (i = 0; i < spec->nb_entry_points; i++)
674 ordinal = spec->entry_points[i].ordinal;
675 if (ordinal == -1) continue;
676 if (spec->ordinals[ordinal])
678 current_line = max( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno );
679 error( "ordinal %d redefined\n%s:%d: First defined here\n",
680 ordinal, input_file_name,
681 min( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno ) );
683 else spec->ordinals[ordinal] = &spec->entry_points[i];
686 /* now assign ordinals to the rest */
687 for (i = 0, ordinal = spec->base; i < spec->nb_entry_points; i++)
689 if (spec->entry_points[i].ordinal != -1) continue;
690 while (spec->ordinals[ordinal]) ordinal++;
691 if (ordinal >= MAX_ORDINALS)
693 current_line = spec->entry_points[i].lineno;
694 fatal_error( "Too many functions defined (max %d)\n", MAX_ORDINALS );
696 spec->entry_points[i].ordinal = ordinal;
697 spec->ordinals[ordinal] = &spec->entry_points[i];
699 if (ordinal > spec->limit) spec->limit = ordinal;
703 /*******************************************************************
706 * Parse a .spec file.
708 int parse_spec_file( FILE *file, DLLSPEC *spec )
715 comment_chars = "#;";
716 separator_chars = "()-";
718 while (get_next_line())
720 if (!(token = GetToken(1))) continue;
721 if (strcmp(token, "@") == 0)
723 if (spec->type != SPEC_WIN32)
725 error( "'@' ordinals not supported for Win16\n" );
728 if (!parse_spec_ordinal( -1, spec )) continue;
730 else if (IsNumberString(token))
732 if (!parse_spec_ordinal( atoi(token), spec )) continue;
736 error( "Expected ordinal declaration, got '%s'\n", token );
739 if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
742 current_line = 0; /* no longer parsing the input file */
743 assign_names( spec );
744 assign_ordinals( spec );
749 /*******************************************************************
752 * Parse a LIBRARY declaration in a .def file.
754 static int parse_def_library( DLLSPEC *spec )
756 const char *token = GetToken(1);
758 if (!token) return 1;
759 if (strcmp( token, "BASE" ))
761 free( spec->file_name );
762 spec->file_name = xstrdup( token );
763 if (!(token = GetToken(1))) return 1;
765 if (strcmp( token, "BASE" ))
767 error( "Expected library name or BASE= declaration, got '%s'\n", token );
770 if (!(token = GetToken(0))) return 0;
771 if (strcmp( token, "=" ))
773 error( "Expected '=' after BASE, got '%s'\n", token );
776 if (!(token = GetToken(0))) return 0;
777 /* FIXME: do something with base address */
783 /*******************************************************************
784 * parse_def_stack_heap_size
786 * Parse a STACKSIZE or HEAPSIZE declaration in a .def file.
788 static int parse_def_stack_heap_size( int is_stack, DLLSPEC *spec )
790 const char *token = GetToken(0);
794 if (!token) return 0;
795 size = strtoul( token, &end, 0 );
798 error( "Invalid number '%s'\n", token );
801 if (is_stack) spec->stack_size = size / 1024;
802 else spec->heap_size = size / 1024;
803 if (!(token = GetToken(1))) return 1;
804 if (strcmp( token, "," ))
806 error( "Expected ',' after size, got '%s'\n", token );
809 if (!(token = GetToken(0))) return 0;
810 /* FIXME: do something with reserve size */
815 /*******************************************************************
818 * Parse an export declaration in a .def file.
820 static int parse_def_export( char *name, DLLSPEC *spec )
823 const char *token = GetToken(1);
825 ORDDEF *odp = add_entry_point( spec );
826 memset( odp, 0, sizeof(*odp) );
828 odp->lineno = current_line;
831 args = remove_stdcall_decoration( odp->name );
832 if (args == -1) odp->type = TYPE_CDECL;
835 odp->type = TYPE_STDCALL;
836 args /= get_ptr_size();
837 if (args >= sizeof(odp->u.func.arg_types))
839 error( "Too many arguments in stdcall function '%s'\n", odp->name );
842 for (i = 0; i < args; i++) odp->u.func.arg_types[i] = 'l';
845 /* check for optional internal name */
847 if (token && !strcmp( token, "=" ))
849 if (!(token = GetToken(0))) goto error;
850 odp->link_name = xstrdup( token );
851 remove_stdcall_decoration( odp->link_name );
856 odp->link_name = xstrdup( name );
859 /* check for optional ordinal */
861 if (token && token[0] == '@')
865 if (!IsNumberString( token+1 ))
867 error( "Expected number after '@', got '%s'\n", token+1 );
870 ordinal = atoi( token+1 );
873 error( "Ordinal 0 is not valid\n" );
876 if (ordinal >= MAX_ORDINALS)
878 error( "Ordinal number %d too large\n", ordinal );
881 odp->ordinal = ordinal;
885 /* check for other optional keywords */
887 if (token && !strcmp( token, "NONAME" ))
889 if (odp->ordinal == -1)
891 error( "NONAME requires an ordinal\n" );
894 odp->export_name = odp->name;
896 odp->flags |= FLAG_NONAME;
899 if (token && !strcmp( token, "PRIVATE" ))
901 odp->flags |= FLAG_PRIVATE;
904 if (token && !strcmp( token, "DATA" ))
906 odp->type = TYPE_EXTERN;
911 error( "Garbage text '%s' found at end of export declaration\n", token );
917 spec->nb_entry_points--;
923 /*******************************************************************
928 int parse_def_file( FILE *file, DLLSPEC *spec )
937 separator_chars = ",=";
939 while (get_next_line())
941 if (!(token = GetToken(1))) continue;
943 if (!strcmp( token, "LIBRARY" ) || !strcmp( token, "NAME" ))
945 if (!parse_def_library( spec )) continue;
948 else if (!strcmp( token, "STACKSIZE" ))
950 if (!parse_def_stack_heap_size( 1, spec )) continue;
953 else if (!strcmp( token, "HEAPSIZE" ))
955 if (!parse_def_stack_heap_size( 0, spec )) continue;
958 else if (!strcmp( token, "EXPORTS" ))
961 if (!(token = GetToken(1))) continue;
963 else if (!strcmp( token, "IMPORTS" ))
966 if (!(token = GetToken(1))) continue;
968 else if (!strcmp( token, "SECTIONS" ))
971 if (!(token = GetToken(1))) continue;
974 if (!in_exports) continue; /* ignore this line */
975 if (!parse_def_export( xstrdup(token), spec )) continue;
978 if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
981 current_line = 0; /* no longer parsing the input file */
982 assign_names( spec );
983 assign_ordinals( spec );