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
;
490 if ((target_cpu
!= CPU_x86
) && (odp
->flags
& FLAG_I386
))
492 /* ignore this entry point on non-Intel archs */
493 spec
->nb_entry_points
--;
501 error( "Ordinal 0 is not valid\n" );
504 if (ordinal
>= MAX_ORDINALS
)
506 error( "Ordinal number %d too large\n", ordinal
);
509 if (ordinal
> spec
->limit
) spec
->limit
= ordinal
;
510 if (ordinal
< spec
->base
) spec
->base
= ordinal
;
511 odp
->ordinal
= ordinal
;
514 if (spec
->type
== SPEC_WIN32
&& odp
->flags
& FLAG_REGISTER
)
516 error( "-register flag not supported for Win32 entry points\n" );
520 if (odp
->type
== TYPE_STDCALL
&& !(odp
->flags
& FLAG_PRIVATE
))
522 if (!strcmp( odp
->name
, "DllRegisterServer" ) ||
523 !strcmp( odp
->name
, "DllUnregisterServer" ) ||
524 !strcmp( odp
->name
, "DllGetClassObject" ) ||
525 !strcmp( odp
->name
, "DllCanUnloadNow" ))
527 warning( "Function %s should be marked private\n", odp
->name
);
531 if (!strcmp( odp
->name
, "@" ) || odp
->flags
& FLAG_NONAME
)
535 error( "Nameless function needs an explicit ordinal number\n" );
538 if (spec
->type
!= SPEC_WIN32
)
540 error( "Nameless functions not supported for Win16\n" );
543 if (!strcmp( odp
->name
, "@" )) free( odp
->name
);
544 else odp
->export_name
= odp
->name
;
550 spec
->nb_entry_points
--;
556 static int name_compare( const void *name1
, const void *name2
)
558 const ORDDEF
*odp1
= *(const ORDDEF
* const *)name1
;
559 const ORDDEF
*odp2
= *(const ORDDEF
* const *)name2
;
560 return strcmp( odp1
->name
, odp2
->name
);
563 /*******************************************************************
566 * Build the name array and catch duplicates.
568 static void assign_names( DLLSPEC
*spec
)
573 for (i
= 0; i
< spec
->nb_entry_points
; i
++)
574 if (spec
->entry_points
[i
].name
) spec
->nb_names
++;
575 if (!spec
->nb_names
) return;
577 spec
->names
= xmalloc( spec
->nb_names
* sizeof(spec
->names
[0]) );
578 for (i
= j
= 0; i
< spec
->nb_entry_points
; i
++)
579 if (spec
->entry_points
[i
].name
) spec
->names
[j
++] = &spec
->entry_points
[i
];
581 /* sort the list of names */
582 qsort( spec
->names
, spec
->nb_names
, sizeof(spec
->names
[0]), name_compare
);
584 /* check for duplicate names */
585 for (i
= 0; i
< spec
->nb_names
- 1; i
++)
587 if (!strcmp( spec
->names
[i
]->name
, spec
->names
[i
+1]->name
))
589 current_line
= max( spec
->names
[i
]->lineno
, spec
->names
[i
+1]->lineno
);
590 error( "'%s' redefined\n%s:%d: First defined here\n",
591 spec
->names
[i
]->name
, input_file_name
,
592 min( spec
->names
[i
]->lineno
, spec
->names
[i
+1]->lineno
) );
597 /*******************************************************************
600 * Build the ordinal array.
602 static void assign_ordinals( DLLSPEC
*spec
)
604 int i
, count
, ordinal
;
606 /* start assigning from base, or from 1 if no ordinal defined yet */
607 if (spec
->base
== MAX_ORDINALS
) spec
->base
= 1;
608 if (spec
->limit
< spec
->base
) spec
->limit
= spec
->base
;
610 count
= max( spec
->limit
+ 1, spec
->base
+ spec
->nb_entry_points
);
611 spec
->ordinals
= xmalloc( count
* sizeof(spec
->ordinals
[0]) );
612 memset( spec
->ordinals
, 0, count
* sizeof(spec
->ordinals
[0]) );
614 /* fill in all explicitly specified ordinals */
615 for (i
= 0; i
< spec
->nb_entry_points
; i
++)
617 ordinal
= spec
->entry_points
[i
].ordinal
;
618 if (ordinal
== -1) continue;
619 if (spec
->ordinals
[ordinal
])
621 current_line
= max( spec
->entry_points
[i
].lineno
, spec
->ordinals
[ordinal
]->lineno
);
622 error( "ordinal %d redefined\n%s:%d: First defined here\n",
623 ordinal
, input_file_name
,
624 min( spec
->entry_points
[i
].lineno
, spec
->ordinals
[ordinal
]->lineno
) );
626 else spec
->ordinals
[ordinal
] = &spec
->entry_points
[i
];
629 /* now assign ordinals to the rest */
630 for (i
= 0, ordinal
= spec
->base
; i
< spec
->nb_entry_points
; i
++)
632 if (spec
->entry_points
[i
].ordinal
!= -1) continue;
633 while (spec
->ordinals
[ordinal
]) ordinal
++;
634 if (ordinal
>= MAX_ORDINALS
)
636 current_line
= spec
->entry_points
[i
].lineno
;
637 fatal_error( "Too many functions defined (max %d)\n", MAX_ORDINALS
);
639 spec
->entry_points
[i
].ordinal
= ordinal
;
640 spec
->ordinals
[ordinal
] = &spec
->entry_points
[i
];
642 if (ordinal
> spec
->limit
) spec
->limit
= ordinal
;
646 /*******************************************************************
649 * Parse a .spec file.
651 int parse_spec_file( FILE *file
, DLLSPEC
*spec
)
658 comment_chars
= "#;";
659 separator_chars
= "()-";
661 while (get_next_line())
663 if (!(token
= GetToken(1))) continue;
664 if (strcmp(token
, "@") == 0)
666 if (spec
->type
!= SPEC_WIN32
)
668 error( "'@' ordinals not supported for Win16\n" );
671 if (!parse_spec_ordinal( -1, spec
)) continue;
673 else if (IsNumberString(token
))
675 if (!parse_spec_ordinal( atoi(token
), spec
)) continue;
679 error( "Expected ordinal declaration, got '%s'\n", token
);
682 if ((token
= GetToken(1))) error( "Syntax error near '%s'\n", token
);
685 current_line
= 0; /* no longer parsing the input file */
686 assign_names( spec
);
687 assign_ordinals( spec
);
692 /*******************************************************************
695 * Parse a LIBRARY declaration in a .def file.
697 static int parse_def_library( DLLSPEC
*spec
)
699 const char *token
= GetToken(1);
701 if (!token
) return 1;
702 if (strcmp( token
, "BASE" ))
704 free( spec
->file_name
);
705 spec
->file_name
= xstrdup( token
);
706 if (!(token
= GetToken(1))) return 1;
708 if (strcmp( token
, "BASE" ))
710 error( "Expected library name or BASE= declaration, got '%s'\n", token
);
713 if (!(token
= GetToken(0))) return 0;
714 if (strcmp( token
, "=" ))
716 error( "Expected '=' after BASE, got '%s'\n", token
);
719 if (!(token
= GetToken(0))) return 0;
720 /* FIXME: do something with base address */
726 /*******************************************************************
727 * parse_def_stack_heap_size
729 * Parse a STACKSIZE or HEAPSIZE declaration in a .def file.
731 static int parse_def_stack_heap_size( int is_stack
, DLLSPEC
*spec
)
733 const char *token
= GetToken(0);
737 if (!token
) return 0;
738 size
= strtoul( token
, &end
, 0 );
741 error( "Invalid number '%s'\n", token
);
744 if (is_stack
) spec
->stack_size
= size
/ 1024;
745 else spec
->heap_size
= size
/ 1024;
746 if (!(token
= GetToken(1))) return 1;
747 if (strcmp( token
, "," ))
749 error( "Expected ',' after size, got '%s'\n", token
);
752 if (!(token
= GetToken(0))) return 0;
753 /* FIXME: do something with reserve size */
758 /*******************************************************************
761 * Parse an export declaration in a .def file.
763 static int parse_def_export( char *name
, DLLSPEC
*spec
)
766 const char *token
= GetToken(1);
768 ORDDEF
*odp
= add_entry_point( spec
);
769 memset( odp
, 0, sizeof(*odp
) );
771 odp
->lineno
= current_line
;
774 args
= remove_stdcall_decoration( odp
->name
);
775 if (args
== -1) odp
->type
= TYPE_CDECL
;
778 odp
->type
= TYPE_STDCALL
;
780 if (args
>= sizeof(odp
->u
.func
.arg_types
))
782 error( "Too many arguments in stdcall function '%s'\n", odp
->name
);
785 for (i
= 0; i
< args
; i
++) odp
->u
.func
.arg_types
[i
] = 'l';
788 /* check for optional internal name */
790 if (token
&& !strcmp( token
, "=" ))
792 if (!(token
= GetToken(0))) goto error
;
793 odp
->link_name
= xstrdup( token
);
794 remove_stdcall_decoration( odp
->link_name
);
799 odp
->link_name
= xstrdup( name
);
802 /* check for optional ordinal */
804 if (token
&& token
[0] == '@')
808 if (!IsNumberString( token
+1 ))
810 error( "Expected number after '@', got '%s'\n", token
+1 );
813 ordinal
= atoi( token
+1 );
816 error( "Ordinal 0 is not valid\n" );
819 if (ordinal
>= MAX_ORDINALS
)
821 error( "Ordinal number %d too large\n", ordinal
);
824 if (ordinal
> spec
->limit
) spec
->limit
= ordinal
;
825 if (ordinal
< spec
->base
) spec
->base
= ordinal
;
826 odp
->ordinal
= ordinal
;
830 /* check for other optional keywords */
832 if (token
&& !strcmp( token
, "NONAME" ))
834 if (odp
->ordinal
== -1)
836 error( "NONAME requires an ordinal\n" );
839 odp
->export_name
= odp
->name
;
841 odp
->flags
|= FLAG_NONAME
;
844 if (token
&& !strcmp( token
, "PRIVATE" ))
846 odp
->flags
|= FLAG_PRIVATE
;
849 if (token
&& !strcmp( token
, "DATA" ))
851 odp
->type
= TYPE_EXTERN
;
856 error( "Garbage text '%s' found at end of export declaration\n", token
);
862 spec
->nb_entry_points
--;
868 /*******************************************************************
873 int parse_def_file( FILE *file
, DLLSPEC
*spec
)
882 separator_chars
= ",=";
884 while (get_next_line())
886 if (!(token
= GetToken(1))) continue;
888 if (!strcmp( token
, "LIBRARY" ) || !strcmp( token
, "NAME" ))
890 if (!parse_def_library( spec
)) continue;
893 else if (!strcmp( token
, "STACKSIZE" ))
895 if (!parse_def_stack_heap_size( 1, spec
)) continue;
898 else if (!strcmp( token
, "HEAPSIZE" ))
900 if (!parse_def_stack_heap_size( 0, spec
)) continue;
903 else if (!strcmp( token
, "EXPORTS" ))
906 if (!(token
= GetToken(1))) continue;
908 else if (!strcmp( token
, "IMPORTS" ))
911 if (!(token
= GetToken(1))) continue;
913 else if (!strcmp( token
, "SECTIONS" ))
916 if (!(token
= GetToken(1))) continue;
919 if (!in_exports
) continue; /* ignore this line */
920 if (!parse_def_export( xstrdup(token
), spec
)) continue;
923 if ((token
= GetToken(1))) error( "Syntax error near '%s'\n", token
);
926 current_line
= 0; /* no longer parsing the input file */
927 assign_names( spec
);
928 assign_ordinals( spec
);
933 /*******************************************************************
936 static void add_debug_channel( const char *name
)
940 for (i
= 0; i
< nb_debug_channels
; i
++)
941 if (!strcmp( debug_channels
[i
], name
)) return;
943 debug_channels
= xrealloc( debug_channels
, (nb_debug_channels
+ 1) * sizeof(*debug_channels
));
944 debug_channels
[nb_debug_channels
++] = xstrdup(name
);
948 /*******************************************************************
949 * parse_debug_channels
951 * Parse a source file and extract the debug channel definitions.
953 int parse_debug_channels( const char *srcdir
, const char *filename
)
958 file
= open_input_file( srcdir
, filename
);
959 while (fgets( ParseBuffer
, sizeof(ParseBuffer
), file
))
961 char *channel
, *end
, *p
= ParseBuffer
;
963 p
= ParseBuffer
+ strlen(ParseBuffer
) - 1;
964 if (!eol_seen
) /* continuation line */
966 eol_seen
= (*p
== '\n');
969 if ((eol_seen
= (*p
== '\n'))) *p
= 0;
972 while (isspace(*p
)) p
++;
973 if (!memcmp( p
, "WINE_DECLARE_DEBUG_CHANNEL", 26 ) ||
974 !memcmp( p
, "WINE_DEFAULT_DEBUG_CHANNEL", 26 ))
977 while (isspace(*p
)) p
++;
980 error( "invalid debug channel specification '%s'\n", ParseBuffer
);
984 while (isspace(*p
)) p
++;
987 error( "invalid debug channel specification '%s'\n", ParseBuffer
);
991 while (isalnum(*p
) || *p
== '_') p
++;
993 while (isspace(*p
)) p
++;
996 error( "invalid debug channel specification '%s'\n", ParseBuffer
);
1000 add_debug_channel( channel
);
1005 close_input_file( file
);