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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 static const char * const TypeNames[TYPE_NBTYPES] =
51 "variable", /* TYPE_VARIABLE */
52 "pascal", /* TYPE_PASCAL */
53 "equate", /* TYPE_ABS */
54 "stub", /* TYPE_STUB */
55 "stdcall", /* TYPE_STDCALL */
56 "cdecl", /* TYPE_CDECL */
57 "varargs", /* TYPE_VARARGS */
58 "extern" /* TYPE_EXTERN */
61 static const char * const FlagNames[] =
63 "norelay", /* FLAG_NORELAY */
64 "noname", /* FLAG_NONAME */
65 "ret16", /* FLAG_RET16 */
66 "ret64", /* FLAG_RET64 */
67 "i386", /* FLAG_I386 */
68 "register", /* FLAG_REGISTER */
69 "private", /* FLAG_PRIVATE */
73 static int IsNumberString(const char *s)
75 while (*s) if (!isdigit(*s++)) return 0;
79 inline static int is_token_separator( char ch )
81 return strchr( separator_chars, ch ) != NULL;
84 inline static int is_token_comment( char ch )
86 return strchr( comment_chars, ch ) != NULL;
89 /* get the next line from the input file, or return 0 if at eof */
90 static int get_next_line(void)
92 ParseNext = ParseBuffer;
94 return (fgets(ParseBuffer, sizeof(ParseBuffer), input_file) != NULL);
97 static const char * GetToken( int allow_eol )
100 char *token = TokenBuffer;
104 /* remove initial white space */
106 while (isspace(*p)) p++;
108 if (*p == '\\' && p[1] == '\n') /* line continuation */
110 if (!get_next_line())
112 if (!allow_eol) error( "Unexpected end of file\n" );
119 if ((*p == '\0') || is_token_comment(*p))
121 if (!allow_eol) error( "Declaration not terminated properly\n" );
128 if (is_token_separator(*p))
130 /* a separator is always a complete token */
133 else while (*p != '\0' && !is_token_separator(*p) && !isspace(*p))
136 if (*p) *token++ = *p++;
144 static ORDDEF *add_entry_point( DLLSPEC *spec )
146 if (spec->nb_entry_points == spec->alloc_entry_points)
148 spec->alloc_entry_points += 128;
149 spec->entry_points = xrealloc( spec->entry_points,
150 spec->alloc_entry_points * sizeof(*spec->entry_points) );
152 return &spec->entry_points[spec->nb_entry_points++];
155 /*******************************************************************
156 * parse_spec_variable
158 * Parse a variable definition in a .spec file.
160 static int parse_spec_variable( ORDDEF *odp, DLLSPEC *spec )
165 int value_array_size;
168 if (spec->type == SPEC_WIN32)
170 error( "'variable' not supported in Win32, use 'extern' instead\n" );
174 if (!(token = GetToken(0))) return 0;
177 error( "Expected '(' got '%s'\n", token );
182 value_array_size = 25;
183 value_array = xmalloc(sizeof(*value_array) * value_array_size);
187 if (!(token = GetToken(0)))
195 value_array[n_values++] = strtol(token, &endptr, 0);
196 if (n_values == value_array_size)
198 value_array_size += 25;
199 value_array = xrealloc(value_array,
200 sizeof(*value_array) * value_array_size);
203 if (endptr == NULL || *endptr != '\0')
205 error( "Expected number value, got '%s'\n", token );
211 odp->u.var.n_values = n_values;
212 odp->u.var.values = xrealloc(value_array, sizeof(*value_array) * n_values);
217 /*******************************************************************
220 * Parse an exported function definition in a .spec file.
222 static int parse_spec_export( ORDDEF *odp, DLLSPEC *spec )
230 if (odp->type == TYPE_STDCALL)
232 error( "'stdcall' not supported for Win16\n" );
237 if (odp->type == TYPE_PASCAL)
239 error( "'pascal' not supported for Win32\n" );
247 if (!(token = GetToken(0))) return 0;
250 error( "Expected '(' got '%s'\n", token );
254 for (i = 0; i < sizeof(odp->u.func.arg_types); i++)
256 if (!(token = GetToken(0))) return 0;
260 if (!strcmp(token, "word"))
261 odp->u.func.arg_types[i] = 'w';
262 else if (!strcmp(token, "s_word"))
263 odp->u.func.arg_types[i] = 's';
264 else if (!strcmp(token, "long") || !strcmp(token, "segptr"))
265 odp->u.func.arg_types[i] = 'l';
266 else if (!strcmp(token, "ptr"))
267 odp->u.func.arg_types[i] = 'p';
268 else if (!strcmp(token, "str"))
269 odp->u.func.arg_types[i] = 't';
270 else if (!strcmp(token, "wstr"))
271 odp->u.func.arg_types[i] = 'W';
272 else if (!strcmp(token, "segstr"))
273 odp->u.func.arg_types[i] = 'T';
274 else if (!strcmp(token, "double"))
276 odp->u.func.arg_types[i++] = 'l';
277 if (i < sizeof(odp->u.func.arg_types)) odp->u.func.arg_types[i] = 'l';
281 error( "Unknown argument type '%s'\n", token );
285 if (spec->type == SPEC_WIN32)
287 if (strcmp(token, "long") &&
288 strcmp(token, "ptr") &&
289 strcmp(token, "str") &&
290 strcmp(token, "wstr") &&
291 strcmp(token, "double"))
293 error( "Type '%s' not supported for Win32\n", token );
298 if ((*token != ')') || (i >= sizeof(odp->u.func.arg_types)))
300 error( "Too many arguments\n" );
304 odp->u.func.arg_types[i] = '\0';
305 if (odp->type == TYPE_VARARGS)
306 odp->flags |= FLAG_NORELAY; /* no relay debug possible for varags entry point */
308 if (!(token = GetToken(1)))
310 if (!strcmp( odp->name, "@" ))
312 error( "Missing handler name for anonymous function\n" );
315 odp->link_name = xstrdup( odp->name );
319 odp->link_name = xstrdup( token );
320 if (strchr( odp->link_name, '.' ))
322 if (spec->type == SPEC_WIN16)
324 error( "Forwarded functions not supported for Win16\n" );
327 odp->flags |= FLAG_FORWARD;
334 /*******************************************************************
337 * Parse an 'equate' definition in a .spec file.
339 static int parse_spec_equate( ORDDEF *odp, DLLSPEC *spec )
345 if (spec->type == SPEC_WIN32)
347 error( "'equate' not supported for Win32\n" );
350 if (!(token = GetToken(0))) return 0;
351 value = strtol(token, &endptr, 0);
352 if (endptr == NULL || *endptr != '\0')
354 error( "Expected number value, got '%s'\n", token );
357 odp->u.abs.value = value;
362 /*******************************************************************
365 * Parse a 'stub' definition in a .spec file
367 static int parse_spec_stub( ORDDEF *odp, DLLSPEC *spec )
369 odp->u.func.arg_types[0] = '\0';
370 odp->link_name = xstrdup("");
375 /*******************************************************************
378 * Parse an 'extern' definition in a .spec file.
380 static int parse_spec_extern( ORDDEF *odp, DLLSPEC *spec )
384 if (spec->type == SPEC_WIN16)
386 error( "'extern' not supported for Win16, use 'variable' instead\n" );
389 if (!(token = GetToken(1)))
391 if (!strcmp( odp->name, "@" ))
393 error( "Missing handler name for anonymous extern\n" );
396 odp->link_name = xstrdup( odp->name );
400 odp->link_name = xstrdup( token );
401 if (strchr( odp->link_name, '.' )) odp->flags |= FLAG_FORWARD;
407 /*******************************************************************
410 * Parse the optional flags for an entry point in a .spec file.
412 static const char *parse_spec_flags( ORDDEF *odp )
419 if (!(token = GetToken(0))) break;
420 for (i = 0; FlagNames[i]; i++)
421 if (!strcmp( FlagNames[i], token )) break;
424 error( "Unknown flag '%s'\n", token );
427 odp->flags |= 1 << i;
429 } while (token && *token == '-');
435 /*******************************************************************
438 * Parse an ordinal definition in a .spec file.
440 static int parse_spec_ordinal( int ordinal, DLLSPEC *spec )
444 ORDDEF *odp = add_entry_point( spec );
445 memset( odp, 0, sizeof(*odp) );
447 if (!(token = GetToken(0))) goto error;
449 for (odp->type = 0; odp->type < TYPE_NBTYPES; odp->type++)
450 if (TypeNames[odp->type] && !strcmp( token, TypeNames[odp->type] ))
453 if (odp->type >= TYPE_NBTYPES)
455 error( "Expected type after ordinal, found '%s' instead\n", token );
459 if (!(token = GetToken(0))) goto error;
460 if (*token == '-' && !(token = parse_spec_flags( odp ))) goto error;
462 odp->name = xstrdup( token );
463 odp->lineno = current_line;
464 odp->ordinal = ordinal;
469 if (!parse_spec_variable( odp, spec )) goto error;
475 if (!parse_spec_export( odp, spec )) goto error;
478 if (!parse_spec_equate( odp, spec )) goto error;
481 if (!parse_spec_stub( odp, spec )) goto error;
484 if (!parse_spec_extern( odp, spec )) goto error;
491 if (odp->flags & FLAG_I386)
493 /* ignore this entry point on non-Intel archs */
494 spec->nb_entry_points--;
503 error( "Ordinal 0 is not valid\n" );
506 if (ordinal >= MAX_ORDINALS)
508 error( "Ordinal number %d too large\n", ordinal );
511 if (ordinal > spec->limit) spec->limit = ordinal;
512 if (ordinal < spec->base) spec->base = ordinal;
513 odp->ordinal = ordinal;
516 if (spec->type == SPEC_WIN32 && odp->flags & FLAG_REGISTER)
518 error( "-register flag not supported for Win32 entry points\n" );
522 if (odp->type == TYPE_STDCALL && !(odp->flags & FLAG_PRIVATE))
524 if (!strcmp( odp->name, "DllRegisterServer" ) ||
525 !strcmp( odp->name, "DllUnregisterServer" ) ||
526 !strcmp( odp->name, "DllGetClassObject" ) ||
527 !strcmp( odp->name, "DllCanUnloadNow" ))
529 warning( "Function %s should be marked private\n", odp->name );
533 if (!strcmp( odp->name, "@" ) || odp->flags & FLAG_NONAME)
537 error( "Nameless function needs an explicit ordinal number\n" );
540 if (spec->type != SPEC_WIN32)
542 error( "Nameless functions not supported for Win16\n" );
545 if (!strcmp( odp->name, "@" )) free( odp->name );
546 else odp->export_name = odp->name;
552 spec->nb_entry_points--;
558 static int name_compare( const void *name1, const void *name2 )
560 const ORDDEF *odp1 = *(const ORDDEF * const *)name1;
561 const ORDDEF *odp2 = *(const ORDDEF * const *)name2;
562 return strcmp( odp1->name, odp2->name );
565 /*******************************************************************
568 * Build the name array and catch duplicates.
570 static void assign_names( DLLSPEC *spec )
575 for (i = 0; i < spec->nb_entry_points; i++)
576 if (spec->entry_points[i].name) spec->nb_names++;
577 if (!spec->nb_names) return;
579 spec->names = xmalloc( spec->nb_names * sizeof(spec->names[0]) );
580 for (i = j = 0; i < spec->nb_entry_points; i++)
581 if (spec->entry_points[i].name) spec->names[j++] = &spec->entry_points[i];
583 /* sort the list of names */
584 qsort( spec->names, spec->nb_names, sizeof(spec->names[0]), name_compare );
586 /* check for duplicate names */
587 for (i = 0; i < spec->nb_names - 1; i++)
589 if (!strcmp( spec->names[i]->name, spec->names[i+1]->name ))
591 current_line = max( spec->names[i]->lineno, spec->names[i+1]->lineno );
592 error( "'%s' redefined\n%s:%d: First defined here\n",
593 spec->names[i]->name, input_file_name,
594 min( spec->names[i]->lineno, spec->names[i+1]->lineno ) );
599 /*******************************************************************
602 * Build the ordinal array.
604 static void assign_ordinals( DLLSPEC *spec )
606 int i, count, ordinal;
608 /* start assigning from base, or from 1 if no ordinal defined yet */
609 if (spec->base == MAX_ORDINALS) spec->base = 1;
610 if (spec->limit < spec->base) spec->limit = spec->base;
612 count = max( spec->limit + 1, spec->base + spec->nb_entry_points );
613 spec->ordinals = xmalloc( count * sizeof(spec->ordinals[0]) );
614 memset( spec->ordinals, 0, count * sizeof(spec->ordinals[0]) );
616 /* fill in all explicitly specified ordinals */
617 for (i = 0; i < spec->nb_entry_points; i++)
619 ordinal = spec->entry_points[i].ordinal;
620 if (ordinal == -1) continue;
621 if (spec->ordinals[ordinal])
623 current_line = max( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno );
624 error( "ordinal %d redefined\n%s:%d: First defined here\n",
625 ordinal, input_file_name,
626 min( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno ) );
628 else spec->ordinals[ordinal] = &spec->entry_points[i];
631 /* now assign ordinals to the rest */
632 for (i = 0, ordinal = spec->base; i < spec->nb_entry_points; i++)
634 if (spec->entry_points[i].ordinal != -1) continue;
635 while (spec->ordinals[ordinal]) ordinal++;
636 if (ordinal >= MAX_ORDINALS)
638 current_line = spec->entry_points[i].lineno;
639 fatal_error( "Too many functions defined (max %d)\n", MAX_ORDINALS );
641 spec->entry_points[i].ordinal = ordinal;
642 spec->ordinals[ordinal] = &spec->entry_points[i];
644 if (ordinal > spec->limit) spec->limit = ordinal;
648 /*******************************************************************
651 * Parse a .spec file.
653 int parse_spec_file( FILE *file, DLLSPEC *spec )
660 comment_chars = "#;";
661 separator_chars = "()-";
663 while (get_next_line())
665 if (!(token = GetToken(1))) continue;
666 if (strcmp(token, "@") == 0)
668 if (spec->type != SPEC_WIN32)
670 error( "'@' ordinals not supported for Win16\n" );
673 if (!parse_spec_ordinal( -1, spec )) continue;
675 else if (IsNumberString(token))
677 if (!parse_spec_ordinal( atoi(token), spec )) continue;
681 error( "Expected ordinal declaration, got '%s'\n", token );
684 if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
687 current_line = 0; /* no longer parsing the input file */
688 assign_names( spec );
689 assign_ordinals( spec );
694 /*******************************************************************
697 * Parse a LIBRARY declaration in a .def file.
699 static int parse_def_library( DLLSPEC *spec )
701 const char *token = GetToken(1);
703 if (!token) return 1;
704 if (strcmp( token, "BASE" ))
706 free( spec->file_name );
707 spec->file_name = xstrdup( token );
708 if (!(token = GetToken(1))) return 1;
710 if (strcmp( token, "BASE" ))
712 error( "Expected library name or BASE= declaration, got '%s'\n", token );
715 if (!(token = GetToken(0))) return 0;
716 if (strcmp( token, "=" ))
718 error( "Expected '=' after BASE, got '%s'\n", token );
721 if (!(token = GetToken(0))) return 0;
722 /* FIXME: do something with base address */
728 /*******************************************************************
729 * parse_def_stack_heap_size
731 * Parse a STACKSIZE or HEAPSIZE declaration in a .def file.
733 static int parse_def_stack_heap_size( int is_stack, DLLSPEC *spec )
735 const char *token = GetToken(0);
739 if (!token) return 0;
740 size = strtoul( token, &end, 0 );
743 error( "Invalid number '%s'\n", token );
746 if (is_stack) spec->stack_size = size / 1024;
747 else spec->heap_size = size / 1024;
748 if (!(token = GetToken(1))) return 1;
749 if (strcmp( token, "," ))
751 error( "Expected ',' after size, got '%s'\n", token );
754 if (!(token = GetToken(0))) return 0;
755 /* FIXME: do something with reserve size */
760 /*******************************************************************
763 * Parse an export declaration in a .def file.
765 static int parse_def_export( char *name, DLLSPEC *spec )
768 const char *token = GetToken(1);
770 ORDDEF *odp = add_entry_point( spec );
771 memset( odp, 0, sizeof(*odp) );
773 odp->lineno = current_line;
776 args = remove_stdcall_decoration( odp->name );
777 if (args == -1) odp->type = TYPE_CDECL;
780 odp->type = TYPE_STDCALL;
782 if (args >= sizeof(odp->u.func.arg_types))
784 error( "Too many arguments in stdcall function '%s'\n", odp->name );
787 for (i = 0; i < args; i++) odp->u.func.arg_types[i] = 'l';
790 /* check for optional internal name */
792 if (token && !strcmp( token, "=" ))
794 if (!(token = GetToken(0))) goto error;
795 odp->link_name = xstrdup( token );
796 remove_stdcall_decoration( odp->link_name );
801 odp->link_name = xstrdup( name );
804 /* check for optional ordinal */
806 if (token && token[0] == '@')
810 if (!IsNumberString( token+1 ))
812 error( "Expected number after '@', got '%s'\n", token+1 );
815 ordinal = atoi( token+1 );
818 error( "Ordinal 0 is not valid\n" );
821 if (ordinal >= MAX_ORDINALS)
823 error( "Ordinal number %d too large\n", ordinal );
826 if (ordinal > spec->limit) spec->limit = ordinal;
827 if (ordinal < spec->base) spec->base = ordinal;
828 odp->ordinal = ordinal;
832 /* check for other optional keywords */
834 if (token && !strcmp( token, "NONAME" ))
836 if (odp->ordinal == -1)
838 error( "NONAME requires an ordinal\n" );
841 odp->export_name = odp->name;
843 odp->flags |= FLAG_NONAME;
846 if (token && !strcmp( token, "PRIVATE" ))
848 odp->flags |= FLAG_PRIVATE;
851 if (token && !strcmp( token, "DATA" ))
853 odp->type = TYPE_EXTERN;
858 error( "Garbage text '%s' found at end of export declaration\n", token );
864 spec->nb_entry_points--;
870 /*******************************************************************
875 int parse_def_file( FILE *file, DLLSPEC *spec )
884 separator_chars = ",=";
886 while (get_next_line())
888 if (!(token = GetToken(1))) continue;
890 if (!strcmp( token, "LIBRARY" ) || !strcmp( token, "NAME" ))
892 if (!parse_def_library( spec )) continue;
895 else if (!strcmp( token, "STACKSIZE" ))
897 if (!parse_def_stack_heap_size( 1, spec )) continue;
900 else if (!strcmp( token, "HEAPSIZE" ))
902 if (!parse_def_stack_heap_size( 0, spec )) continue;
905 else if (!strcmp( token, "EXPORTS" ))
908 if (!(token = GetToken(1))) continue;
910 else if (!strcmp( token, "IMPORTS" ))
913 if (!(token = GetToken(1))) continue;
915 else if (!strcmp( token, "SECTIONS" ))
918 if (!(token = GetToken(1))) continue;
921 if (!in_exports) continue; /* ignore this line */
922 if (!parse_def_export( xstrdup(token), spec )) continue;
925 if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
928 current_line = 0; /* no longer parsing the input file */
929 assign_names( spec );
930 assign_ordinals( spec );
935 /*******************************************************************
938 static void add_debug_channel( const char *name )
942 for (i = 0; i < nb_debug_channels; i++)
943 if (!strcmp( debug_channels[i], name )) return;
945 debug_channels = xrealloc( debug_channels, (nb_debug_channels + 1) * sizeof(*debug_channels));
946 debug_channels[nb_debug_channels++] = xstrdup(name);
950 /*******************************************************************
951 * parse_debug_channels
953 * Parse a source file and extract the debug channel definitions.
955 int parse_debug_channels( const char *srcdir, const char *filename )
960 file = open_input_file( srcdir, filename );
961 while (fgets( ParseBuffer, sizeof(ParseBuffer), file ))
963 char *channel, *end, *p = ParseBuffer;
965 p = ParseBuffer + strlen(ParseBuffer) - 1;
966 if (!eol_seen) /* continuation line */
968 eol_seen = (*p == '\n');
971 if ((eol_seen = (*p == '\n'))) *p = 0;
974 while (isspace(*p)) p++;
975 if (!memcmp( p, "WINE_DECLARE_DEBUG_CHANNEL", 26 ) ||
976 !memcmp( p, "WINE_DEFAULT_DEBUG_CHANNEL", 26 ))
979 while (isspace(*p)) p++;
982 error( "invalid debug channel specification '%s'\n", ParseBuffer );
986 while (isspace(*p)) p++;
989 error( "invalid debug channel specification '%s'\n", ParseBuffer );
993 while (isalnum(*p) || *p == '_') p++;
995 while (isspace(*p)) p++;
998 error( "invalid debug channel specification '%s'\n", ParseBuffer );
1002 add_debug_channel( channel );
1007 close_input_file( file );