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 remove_stdcall_decoration( odp->name );
464 odp->lineno = current_line;
465 odp->ordinal = ordinal;
470 if (!parse_spec_variable( odp, spec )) goto error;
476 if (!parse_spec_export( odp, spec )) goto error;
479 if (!parse_spec_equate( odp, spec )) goto error;
482 if (!parse_spec_stub( odp, spec )) goto error;
485 if (!parse_spec_extern( odp, spec )) goto error;
492 if (odp->flags & FLAG_I386)
494 /* ignore this entry point on non-Intel archs */
495 spec->nb_entry_points--;
504 error( "Ordinal 0 is not valid\n" );
507 if (ordinal >= MAX_ORDINALS)
509 error( "Ordinal number %d too large\n", ordinal );
512 if (ordinal > spec->limit) spec->limit = ordinal;
513 if (ordinal < spec->base) spec->base = ordinal;
514 odp->ordinal = ordinal;
517 if (!strcmp( odp->name, "@" ) || odp->flags & FLAG_NONAME)
521 error( "Nameless function needs an explicit ordinal number\n" );
524 if (spec->type != SPEC_WIN32)
526 error( "Nameless functions not supported for Win16\n" );
529 if (!strcmp( odp->name, "@" )) free( odp->name );
530 else odp->export_name = odp->name;
536 spec->nb_entry_points--;
542 static int name_compare( const void *name1, const void *name2 )
544 ORDDEF *odp1 = *(ORDDEF **)name1;
545 ORDDEF *odp2 = *(ORDDEF **)name2;
546 return strcmp( odp1->name, odp2->name );
549 /*******************************************************************
552 * Build the name array and catch duplicates.
554 static void assign_names( DLLSPEC *spec )
559 for (i = 0; i < spec->nb_entry_points; i++)
560 if (spec->entry_points[i].name) spec->nb_names++;
561 if (!spec->nb_names) return;
563 spec->names = xmalloc( spec->nb_names * sizeof(spec->names[0]) );
564 for (i = j = 0; i < spec->nb_entry_points; i++)
565 if (spec->entry_points[i].name) spec->names[j++] = &spec->entry_points[i];
567 /* sort the list of names */
568 qsort( spec->names, spec->nb_names, sizeof(spec->names[0]), name_compare );
570 /* check for duplicate names */
571 for (i = 0; i < spec->nb_names - 1; i++)
573 if (!strcmp( spec->names[i]->name, spec->names[i+1]->name ))
575 current_line = max( spec->names[i]->lineno, spec->names[i+1]->lineno );
576 error( "'%s' redefined\n%s:%d: First defined here\n",
577 spec->names[i]->name, input_file_name,
578 min( spec->names[i]->lineno, spec->names[i+1]->lineno ) );
583 /*******************************************************************
586 * Build the ordinal array.
588 static void assign_ordinals( DLLSPEC *spec )
590 int i, count, ordinal;
592 /* start assigning from base, or from 1 if no ordinal defined yet */
593 if (spec->base == MAX_ORDINALS) spec->base = 1;
594 if (spec->limit < spec->base) spec->limit = spec->base;
596 count = max( spec->limit + 1, spec->base + spec->nb_entry_points );
597 spec->ordinals = xmalloc( count * sizeof(spec->ordinals[0]) );
598 memset( spec->ordinals, 0, count * sizeof(spec->ordinals[0]) );
600 /* fill in all explicitly specified ordinals */
601 for (i = 0; i < spec->nb_entry_points; i++)
603 ordinal = spec->entry_points[i].ordinal;
604 if (ordinal == -1) continue;
605 if (spec->ordinals[ordinal])
607 current_line = max( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno );
608 error( "ordinal %d redefined\n%s:%d: First defined here\n",
609 ordinal, input_file_name,
610 min( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno ) );
612 else spec->ordinals[ordinal] = &spec->entry_points[i];
615 /* now assign ordinals to the rest */
616 for (i = 0, ordinal = spec->base; i < spec->nb_names; i++)
618 if (spec->names[i]->ordinal != -1) continue; /* already has an ordinal */
619 while (spec->ordinals[ordinal]) ordinal++;
620 if (ordinal >= MAX_ORDINALS)
622 current_line = spec->names[i]->lineno;
623 fatal_error( "Too many functions defined (max %d)\n", MAX_ORDINALS );
625 spec->names[i]->ordinal = ordinal;
626 spec->ordinals[ordinal] = spec->names[i];
628 if (ordinal > spec->limit) spec->limit = ordinal;
632 /*******************************************************************
635 * Parse a .spec file.
637 int parse_spec_file( FILE *file, DLLSPEC *spec )
644 comment_chars = "#;";
645 separator_chars = "()-";
647 while (get_next_line())
649 if (!(token = GetToken(1))) continue;
650 if (strcmp(token, "@") == 0)
652 if (spec->type != SPEC_WIN32)
654 error( "'@' ordinals not supported for Win16\n" );
657 if (!parse_spec_ordinal( -1, spec )) continue;
659 else if (IsNumberString(token))
661 if (!parse_spec_ordinal( atoi(token), spec )) continue;
665 error( "Expected ordinal declaration, got '%s'\n", token );
668 if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
671 current_line = 0; /* no longer parsing the input file */
672 assign_names( spec );
673 assign_ordinals( spec );
678 /*******************************************************************
681 * Parse a LIBRARY declaration in a .def file.
683 static int parse_def_library( DLLSPEC *spec )
685 const char *token = GetToken(1);
687 if (!token) return 1;
688 if (strcmp( token, "BASE" ))
690 free( spec->file_name );
691 spec->file_name = xstrdup( token );
692 if (!(token = GetToken(1))) return 1;
694 if (strcmp( token, "BASE" ))
696 error( "Expected library name or BASE= declaration, got '%s'\n", token );
699 if (!(token = GetToken(0))) return 0;
700 if (strcmp( token, "=" ))
702 error( "Expected '=' after BASE, got '%s'\n", token );
705 if (!(token = GetToken(0))) return 0;
706 /* FIXME: do something with base address */
712 /*******************************************************************
713 * parse_def_stack_heap_size
715 * Parse a STACKSIZE or HEAPSIZE declaration in a .def file.
717 static int parse_def_stack_heap_size( int is_stack, DLLSPEC *spec )
719 const char *token = GetToken(0);
723 if (!token) return 0;
724 size = strtoul( token, &end, 0 );
727 error( "Invalid number '%s'\n", token );
730 if (is_stack) spec->stack_size = size / 1024;
731 else spec->heap_size = size / 1024;
732 if (!(token = GetToken(1))) return 1;
733 if (strcmp( token, "," ))
735 error( "Expected ',' after size, got '%s'\n", token );
738 if (!(token = GetToken(0))) return 0;
739 /* FIXME: do something with reserve size */
744 /*******************************************************************
747 * Parse an export declaration in a .def file.
749 static int parse_def_export( char *name, DLLSPEC *spec )
752 const char *token = GetToken(1);
754 ORDDEF *odp = add_entry_point( spec );
755 memset( odp, 0, sizeof(*odp) );
757 odp->lineno = current_line;
760 args = remove_stdcall_decoration( odp->name );
761 if (args == -1) odp->type = TYPE_CDECL;
764 odp->type = TYPE_STDCALL;
766 if (args >= sizeof(odp->u.func.arg_types))
768 error( "Too many arguments in stdcall function '%s'\n", odp->name );
771 for (i = 0; i < args; i++) odp->u.func.arg_types[i] = 'l';
774 /* check for optional internal name */
776 if (token && !strcmp( token, "=" ))
778 if (!(token = GetToken(0))) goto error;
779 odp->link_name = xstrdup( token );
780 remove_stdcall_decoration( odp->link_name );
784 /* check for optional ordinal */
786 if (token && token[0] == '@')
790 if (!IsNumberString( token+1 ))
792 error( "Expected number after '@', got '%s'\n", token+1 );
795 ordinal = atoi( token+1 );
798 error( "Ordinal 0 is not valid\n" );
801 if (ordinal >= MAX_ORDINALS)
803 error( "Ordinal number %d too large\n", ordinal );
806 if (ordinal > spec->limit) spec->limit = ordinal;
807 if (ordinal < spec->base) spec->base = ordinal;
808 odp->ordinal = ordinal;
812 /* check for other optional keywords */
814 if (token && !strcmp( token, "NONAME" ))
816 if (odp->ordinal == -1)
818 error( "NONAME requires an ordinal\n" );
821 odp->export_name = odp->name;
823 odp->flags |= FLAG_NONAME;
826 if (token && !strcmp( token, "PRIVATE" ))
828 odp->flags |= FLAG_PRIVATE;
831 if (token && !strcmp( token, "DATA" ))
833 odp->type = TYPE_EXTERN;
838 error( "Garbage text '%s' found at end of export declaration\n", token );
844 spec->nb_entry_points--;
850 /*******************************************************************
855 int parse_def_file( FILE *file, DLLSPEC *spec )
864 separator_chars = ",=";
866 while (get_next_line())
868 if (!(token = GetToken(1))) continue;
870 if (!strcmp( token, "LIBRARY" ) || !strcmp( token, "NAME" ))
872 if (!parse_def_library( spec )) continue;
875 else if (!strcmp( token, "STACKSIZE" ))
877 if (!parse_def_stack_heap_size( 1, spec )) continue;
880 else if (!strcmp( token, "HEAPSIZE" ))
882 if (!parse_def_stack_heap_size( 0, spec )) continue;
885 else if (!strcmp( token, "EXPORTS" ))
888 if (!(token = GetToken(1))) continue;
890 else if (!strcmp( token, "IMPORTS" ))
893 if (!(token = GetToken(1))) continue;
895 else if (!strcmp( token, "SECTIONS" ))
898 if (!(token = GetToken(1))) continue;
901 if (!in_exports) continue; /* ignore this line */
902 if (!parse_def_export( xstrdup(token), spec )) continue;
905 if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
908 current_line = 0; /* no longer parsing the input file */
909 assign_names( spec );
910 assign_ordinals( spec );
915 /*******************************************************************
918 static void add_debug_channel( const char *name )
922 for (i = 0; i < nb_debug_channels; i++)
923 if (!strcmp( debug_channels[i], name )) return;
925 debug_channels = xrealloc( debug_channels, (nb_debug_channels + 1) * sizeof(*debug_channels));
926 debug_channels[nb_debug_channels++] = xstrdup(name);
930 /*******************************************************************
931 * parse_debug_channels
933 * Parse a source file and extract the debug channel definitions.
935 int parse_debug_channels( const char *srcdir, const char *filename )
940 file = open_input_file( srcdir, filename );
941 while (fgets( ParseBuffer, sizeof(ParseBuffer), file ))
943 char *channel, *end, *p = ParseBuffer;
945 p = ParseBuffer + strlen(ParseBuffer) - 1;
946 if (!eol_seen) /* continuation line */
948 eol_seen = (*p == '\n');
951 if ((eol_seen = (*p == '\n'))) *p = 0;
954 while (isspace(*p)) p++;
955 if (!memcmp( p, "WINE_DECLARE_DEBUG_CHANNEL", 26 ) ||
956 !memcmp( p, "WINE_DEFAULT_DEBUG_CHANNEL", 26 ))
959 while (isspace(*p)) p++;
962 error( "invalid debug channel specification '%s'\n", ParseBuffer );
966 while (isspace(*p)) p++;
969 error( "invalid debug channel specification '%s'\n", ParseBuffer );
973 while (isalnum(*p) || *p == '_') p++;
975 while (isspace(*p)) p++;
978 error( "invalid debug channel specification '%s'\n", ParseBuffer );
982 add_debug_channel( channel );
987 close_input_file( file );