Handle end of line as a syntactic element in the spec file parser;

tools/winebuild/build.h

@@ -136,6 +136,7 @@ extern char *xstrdup( const char *str );
 extern char *strupper(char *s);
 extern void fatal_error( const char *msg, ... );
 extern void fatal_perror( const char *msg, ... );
+extern void error( const char *msg, ... );
 extern void warning( const char *msg, ... );
 extern void output_standard_file_header( FILE *outfile );
 extern FILE *open_input_file( const char *srcdir, const char *name );
@@ -156,7 +157,7 @@ extern void load_res16_file( const char *name );
 extern int output_res16_data( FILE *outfile );
 extern int output_res16_directory( unsigned char *buffer );
 extern void output_dll_init( FILE *outfile, const char *constructor, const char *destructor );
-extern void parse_debug_channels( const char *srcdir, const char *filename );
+extern int parse_debug_channels( const char *srcdir, const char *filename );
 
 extern void BuildGlue( FILE *outfile, const char *srcdir, char **argv );
 extern void BuildRelays16( FILE *outfile );
@@ -165,7 +166,7 @@ extern void BuildSpec16File( FILE *outfile );
 extern void BuildSpec32File( FILE *outfile );
 extern void BuildDef32File( FILE *outfile );
 extern void BuildDebugFile( FILE *outfile, const char *srcdir, char **argv );
-extern void ParseTopLevel( FILE *file );
+extern int ParseTopLevel( FILE *file );
 
 /* global variables */
 
@@ -180,6 +181,7 @@ extern int debugging;
 extern int stack_size;
 extern int nb_debug_channels;
 extern int nb_lib_paths;
+extern int nb_errors;
 extern int display_warnings;
 extern int kill_at;
 

tools/winebuild/import.c

@@ -281,10 +281,18 @@ static int read_import_lib( const char *name, struct import *imp )
 
         if (!strcmp( name, "LIBRARY" ))
         {
-            if (!p) fatal_error( "Expected name after LIBRARY\n" );
+            if (!p)
+            {
+                error( "Expected name after LIBRARY\n" );
+                goto next;
+            }
             name = p;
             p = next_token( name );
-            if (p) fatal_error( "Garbage after LIBRARY statement\n" );
+            if (p)
+            {
+                error( "Garbage after LIBRARY statement\n" );
+                goto next;
+            }
             if (is_already_imported( name ))
             {
                 close_input_file( f );
@@ -297,11 +305,22 @@ static int read_import_lib( const char *name, struct import *imp )
         if (!strcmp( name, "EXPORTS" )) goto next;
 
         /* check for ordinal */
-        if (!p) fatal_error( "Expected ordinal after function name\n" );
+        if (!p)
+        {
+            error( "Expected ordinal after function name\n" );
+            goto next;
+        }
         if (*p != '@' || !isdigit(p[1]))
-            fatal_error( "Expected ordinal after function name '%s'\n", name );
+        {
+            error( "Expected ordinal after function name '%s'\n", name );
+            goto next;
+        }
         ordinal = strtol( p+1, &p, 10 );
-        if (ordinal >= MAX_ORDINALS) fatal_error( "Invalid ordinal number %d\n", ordinal );
+        if (ordinal >= MAX_ORDINALS)
+        {
+            error( "Invalid ordinal number %d\n", ordinal );
+            goto next;
+        }
 
         /* check for optional flags */
         while (p && (p = skip_whitespace(p)))
@@ -311,14 +330,22 @@ static int read_import_lib( const char *name, struct import *imp )
             if (!strcmp( flags, "NONAME" ))
             {
                 ord_only = 1;
-                if (!ordinal) fatal_error( "Invalid ordinal number %d\n", ordinal );
+                if (!ordinal)
+                {
+                    error( "Invalid ordinal number %d\n", ordinal );
+                    goto next;
+                }
             }
             else if (!strcmp( flags, "CONSTANT" ) || !strcmp( flags, "DATA" ))
             {
                 /* we don't support importing non-function entry points */
                 goto next;
             }
-            else fatal_error( "Garbage after ordinal declaration\n" );
+            else
+            {
+                error( "Garbage after ordinal declaration\n" );
+                goto next;
+            }
         }
 
         if (imp->nb_exports == size)
@@ -338,7 +365,7 @@ static int read_import_lib( const char *name, struct import *imp )
     close_input_file( f );
     if (imp->nb_exports)
         qsort( imp->exports, imp->nb_exports, sizeof(*imp->exports), func_cmp );
-    return 1;
+    return !nb_errors;
 }
 
 /* add a dll to the list of imports */
@@ -371,7 +398,11 @@ void add_import_dll( const char *name, int delay )
         dll_imports = xrealloc( dll_imports, (nb_imports+1) * sizeof(*dll_imports) );
         dll_imports[nb_imports++] = imp;
     }
-    else free_imports( imp );
+    else
+    {
+        free_imports( imp );
+        if (nb_errors) exit(1);
+    }
 }
 
 /* remove an imported dll, based on its index in the dll_imports array */

tools/winebuild/main.c

@@ -49,6 +49,7 @@ int nb_entry_points = 0;
 int nb_names = 0;
 int nb_debug_channels = 0;
 int nb_lib_paths = 0;
+int nb_errors = 0;
 int display_warnings = 0;
 int kill_at = 0;
 
@@ -467,7 +468,7 @@ int main(int argc, char **argv)
     {
     case MODE_SPEC:
         load_resources( argv + 1 );
-        ParseTopLevel( input_file );
+        if (!ParseTopLevel( input_file )) break;
         switch (SpecType)
         {
             case SPEC_WIN16:
@@ -491,7 +492,7 @@ int main(int argc, char **argv)
     case MODE_DEF:
         if (argv[1]) fatal_error( "file argument '%s' not allowed in this mode\n", argv[1] );
         if (SpecType == SPEC_WIN16) fatal_error( "Cannot yet build .def file for 16-bit dlls\n" );
-        ParseTopLevel( input_file );
+        if (!ParseTopLevel( input_file )) break;
         BuildDef32File( output_file );
         break;
     case MODE_DEBUG:
@@ -512,6 +513,7 @@ int main(int argc, char **argv)
         do_usage();
         break;
     }
+    if (nb_errors) exit(1);
     if (output_file_name)
     {
         fclose( output_file );

tools/winebuild/parser.c

@@ -76,17 +76,41 @@ inline static int is_token_separator( char ch )
     return (ch == '(' || ch == ')' || ch == '-');
 }
 
-static const char * GetTokenInLine(void)
+/* get the next line from the input file, or return 0 if at eof */
+static int get_next_line(void)
+{
+    ParseNext = ParseBuffer;
+    current_line++;
+    return (fgets(ParseBuffer, sizeof(ParseBuffer), input_file) != NULL);
+}
+
+static const char * GetToken( int allow_eol )
 {
     char *p = ParseNext;
     char *token = TokenBuffer;
 
-    /*
-     * Remove initial white space.
-     */
-    while (isspace(*p)) p++;
+    for (;;)
+    {
+        /* remove initial white space */
+        p = ParseNext;
+        while (isspace(*p)) p++;
 
-    if ((*p == '\0') || (*p == '#')) return NULL;
+        if (*p == '\\' && p[1] == '\n')  /* line continuation */
+        {
+            if (!get_next_line())
+            {
+                if (!allow_eol) error( "Unexpected end of file\n" );
+                return NULL;
+            }
+        }
+        else break;
+    }
+
+    if ((*p == '\0') || (*p == '#'))
+    {
+        if (!allow_eol) error( "Declaration not terminated properly\n" );
+        return NULL;
+    }
 
     /*
      * Find end of token.
@@ -106,30 +130,13 @@ static const char * GetTokenInLine(void)
     return TokenBuffer;
 }
 
-static const char * GetToken( int allow_eof )
-{
-    const char *token;
-
-    while ((token = GetTokenInLine()) == NULL)
-    {
-	ParseNext = ParseBuffer;
-        current_line++;
-        if (fgets(ParseBuffer, sizeof(ParseBuffer), input_file) == NULL)
-        {
-            if (!allow_eof) fatal_error( "Unexpected end of file\n" );
-            return NULL;
-        }
-    }
-    return token;
-}
-
 
 /*******************************************************************
  *         ParseVariable
  *
  * Parse a variable definition.
  */
-static void ParseVariable( ORDDEF *odp )
+static int ParseVariable( ORDDEF *odp )
 {
     char *endptr;
     int *value_array;
@@ -138,10 +145,17 @@ static void ParseVariable( ORDDEF *odp )
     const char *token;
 
     if (SpecType == SPEC_WIN32)
-        fatal_error( "'variable' not supported in Win32, use 'extern' instead\n" );
+    {
+        error( "'variable' not supported in Win32, use 'extern' instead\n" );
+        return 0;
+    }
 
-    token = GetToken(0);
-    if (*token != '(') fatal_error( "Expected '(' got '%s'\n", token );
+    if (!(token = GetToken(0))) return 0;
+    if (*token != '(')
+    {
+        error( "Expected '(' got '%s'\n", token );
+        return 0;
+    }
 
     n_values = 0;
     value_array_size = 25;
@@ -149,7 +163,11 @@ static void ParseVariable( ORDDEF *odp )
 
     for (;;)
     {
-        token = GetToken(0);
+        if (!(token = GetToken(0)))
+        {
+            free( value_array );
+            return 0;
+        }
 	if (*token == ')')
 	    break;
 
@@ -162,11 +180,16 @@ static void ParseVariable( ORDDEF *odp )
 	}
 
 	if (endptr == NULL || *endptr != '\0')
-	    fatal_error( "Expected number value, got '%s'\n", token );
+        {
+            error( "Expected number value, got '%s'\n", token );
+            free( value_array );
+            return 0;
+        }
     }
 
     odp->u.var.n_values = n_values;
     odp->u.var.values = xrealloc(value_array, sizeof(*value_array) * n_values);
+    return 1;
 }
 
 
@@ -175,7 +198,7 @@ static void ParseVariable( ORDDEF *odp )
  *
  * Parse a function definition.
  */
-static void ParseExportFunction( ORDDEF *odp )
+static int ParseExportFunction( ORDDEF *odp )
 {
     const char *token;
     unsigned int i;
@@ -184,26 +207,42 @@ static void ParseExportFunction( ORDDEF *odp )
     {
     case SPEC_WIN16:
         if (odp->type == TYPE_STDCALL)
-            fatal_error( "'stdcall' not supported for Win16\n" );
+        {
+            error( "'stdcall' not supported for Win16\n" );
+            return 0;
+        }
         if (odp->type == TYPE_VARARGS)
-	    fatal_error( "'varargs' not supported for Win16\n" );
+        {
+            error( "'varargs' not supported for Win16\n" );
+            return 0;
+        }
         break;
     case SPEC_WIN32:
         if ((odp->type == TYPE_PASCAL) || (odp->type == TYPE_PASCAL_16))
-            fatal_error( "'pascal' not supported for Win32\n" );
+        {
+            error( "'pascal' not supported for Win32\n" );
+            return 0;
+        }
         if (odp->flags & FLAG_INTERRUPT)
-            fatal_error( "'interrupt' not supported for Win32\n" );
+        {
+            error( "'interrupt' not supported for Win32\n" );
+            return 0;
+        }
         break;
     default:
         break;
     }
 
-    token = GetToken(0);
-    if (*token != '(') fatal_error( "Expected '(' got '%s'\n", token );
+    if (!(token = GetToken(0))) return 0;
+    if (*token != '(')
+    {
+        error( "Expected '(' got '%s'\n", token );
+        return 0;
+    }
 
     for (i = 0; i < sizeof(odp->u.func.arg_types); i++)
     {
-	token = GetToken(0);
+        if (!(token = GetToken(0))) return 0;
 	if (*token == ')')
 	    break;
 
@@ -226,7 +265,11 @@ static void ParseExportFunction( ORDDEF *odp )
             odp->u.func.arg_types[i++] = 'l';
             if (i < sizeof(odp->u.func.arg_types)) odp->u.func.arg_types[i] = 'l';
         }
-        else fatal_error( "Unknown variable type '%s'\n", token );
+        else
+        {
+            error( "Unknown argument type '%s'\n", token );
+            return 0;
+        }
 
         if (SpecType == SPEC_WIN32)
         {
@@ -236,22 +279,44 @@ static void ParseExportFunction( ORDDEF *odp )
                 strcmp(token, "wstr") &&
                 strcmp(token, "double"))
             {
-                fatal_error( "Type '%s' not supported for Win32\n", token );
+                error( "Type '%s' not supported for Win32\n", token );
+                return 0;
             }
         }
     }
     if ((*token != ')') || (i >= sizeof(odp->u.func.arg_types)))
-        fatal_error( "Too many arguments\n" );
+    {
+        error( "Too many arguments\n" );
+        return 0;
+    }
 
     odp->u.func.arg_types[i] = '\0';
     if (odp->type == TYPE_VARARGS)
         odp->flags |= FLAG_NORELAY;  /* no relay debug possible for varags entry point */
-    odp->link_name = xstrdup( GetToken(0) );
-    if (strchr( odp->link_name, '.' ))
+
+    if (!(token = GetToken(1)))
     {
-        if (SpecType == SPEC_WIN16) fatal_error( "Forwarded functions not supported for Win16\n" );
-        odp->flags |= FLAG_FORWARD;
+        if (!strcmp( odp->name, "@" ))
+        {
+            error( "Missing handler name for anonymous function\n" );
+            return 0;
+        }
+        odp->link_name = xstrdup( odp->name );
     }
+    else
+    {
+        odp->link_name = xstrdup( token );
+        if (strchr( odp->link_name, '.' ))
+        {
+            if (SpecType == SPEC_WIN16)
+            {
+                error( "Forwarded functions not supported for Win16\n" );
+                return 0;
+            }
+            odp->flags |= FLAG_FORWARD;
+        }
+    }
+    return 1;
 }
 
 
@@ -260,17 +325,26 @@ static void ParseExportFunction( ORDDEF *odp )
  *
  * Parse an 'equate' definition.
  */
-static void ParseEquate( ORDDEF *odp )
+static int ParseEquate( ORDDEF *odp )
 {
     char *endptr;
+    int value;
+    const char *token;
 
-    const char *token = GetToken(0);
-    int value = strtol(token, &endptr, 0);
-    if (endptr == NULL || *endptr != '\0')
-	fatal_error( "Expected number value, got '%s'\n", token );
     if (SpecType == SPEC_WIN32)
-        fatal_error( "'equate' not supported for Win32\n" );
+    {
+        error( "'equate' not supported for Win32\n" );
+        return 0;
+    }
+    if (!(token = GetToken(0))) return 0;
+    value = strtol(token, &endptr, 0);
+    if (endptr == NULL || *endptr != '\0')
+    {
+        error( "Expected number value, got '%s'\n", token );
+        return 0;
+    }
     odp->u.abs.value = value;
+    return 1;
 }
 
 
@@ -279,10 +353,11 @@ static void ParseEquate( ORDDEF *odp )
  *
  * Parse a 'stub' definition.
  */
-static void ParseStub( ORDDEF *odp )
+static int ParseStub( ORDDEF *odp )
 {
     odp->u.func.arg_types[0] = '\0';
     odp->link_name = xstrdup("");
+    return 1;
 }
 
 
@@ -291,12 +366,30 @@ static void ParseStub( ORDDEF *odp )
  *
  * Parse an 'extern' definition.
  */
-static void ParseExtern( ORDDEF *odp )
+static int ParseExtern( ORDDEF *odp )
 {
+    const char *token;
+
     if (SpecType == SPEC_WIN16)
-        fatal_error( "'extern' not supported for Win16, use 'variable' instead\n" );
-    odp->link_name = xstrdup( GetToken(0) );
-    if (strchr( odp->link_name, '.' )) odp->flags |= FLAG_FORWARD;
+    {
+        error( "'extern' not supported for Win16, use 'variable' instead\n" );
+        return 0;
+    }
+    if (!(token = GetToken(1)))
+    {
+        if (!strcmp( odp->name, "@" ))
+        {
+            error( "Missing handler name for anonymous extern\n" );
+            return 0;
+        }
+        odp->link_name = xstrdup( odp->name );
+    }
+    else
+    {
+        odp->link_name = xstrdup( token );
+        if (strchr( odp->link_name, '.' )) odp->flags |= FLAG_FORWARD;
+    }
+    return 1;
 }
 
 
@@ -312,13 +405,17 @@ static const char *ParseFlags( ORDDEF *odp )
 
     do
     {
-        token = GetToken(0);
+        if (!(token = GetToken(0))) break;
         for (i = 0; FlagNames[i]; i++)
             if (!strcmp( FlagNames[i], token )) break;
-        if (!FlagNames[i]) fatal_error( "Unknown flag '%s'\n", token );
+        if (!FlagNames[i])
+        {
+            error( "Unknown flag '%s'\n", token );
+            return NULL;
+        }
         odp->flags |= 1 << i;
         token = GetToken(0);
-    } while (*token == '-');
+    } while (token && *token == '-');
 
     return token;
 }
@@ -342,7 +439,7 @@ static void fix_export_name( char *name )
  *
  * Parse an ordinal definition.
  */
-static void ParseOrdinal(int ordinal)
+static int ParseOrdinal(int ordinal)
 {
     const char *token;
 
@@ -350,17 +447,20 @@ static void ParseOrdinal(int ordinal)
     memset( odp, 0, sizeof(*odp) );
     EntryPoints[nb_entry_points++] = odp;
 
-    token = GetToken(0);
+    if (!(token = GetToken(0))) goto error;
 
     for (odp->type = 0; odp->type < TYPE_NBTYPES; odp->type++)
         if (TypeNames[odp->type] && !strcmp( token, TypeNames[odp->type] ))
             break;
 
     if (odp->type >= TYPE_NBTYPES)
-        fatal_error( "Expected type after ordinal, found '%s' instead\n", token );
+    {
+        error( "Expected type after ordinal, found '%s' instead\n", token );
+        goto error;
+    }
 
-    token = GetToken(0);
-    if (*token == '-') token = ParseFlags( odp );
+    if (!(token = GetToken(0))) goto error;
+    if (*token == '-' && !(token = ParseFlags( odp ))) goto error;
 
     odp->name = xstrdup( token );
     fix_export_name( odp->name );
@@ -370,23 +470,23 @@ static void ParseOrdinal(int ordinal)
     switch(odp->type)
     {
     case TYPE_VARIABLE:
-        ParseVariable( odp );
+        if (!ParseVariable( odp )) goto error;
         break;
     case TYPE_PASCAL_16:
     case TYPE_PASCAL:
     case TYPE_STDCALL:
     case TYPE_VARARGS:
     case TYPE_CDECL:
-        ParseExportFunction( odp );
+        if (!ParseExportFunction( odp )) goto error;
         break;
     case TYPE_ABS:
-        ParseEquate( odp );
+        if (!ParseEquate( odp )) goto error;
         break;
     case TYPE_STUB:
-        ParseStub( odp );
+        if (!ParseStub( odp )) goto error;
         break;
     case TYPE_EXTERN:
-        ParseExtern( odp );
+        if (!ParseExtern( odp )) goto error;
         break;
     default:
         assert( 0 );
@@ -398,14 +498,22 @@ static void ParseOrdinal(int ordinal)
         /* ignore this entry point on non-Intel archs */
         EntryPoints[--nb_entry_points] = NULL;
         free( odp );
-        return;
+        return 1;
     }
 #endif
 
     if (ordinal != -1)
     {
-        if (!ordinal) fatal_error( "Ordinal 0 is not valid\n" );
-        if (ordinal >= MAX_ORDINALS) fatal_error( "Ordinal number %d too large\n", ordinal );
+        if (!ordinal)
+        {
+            error( "Ordinal 0 is not valid\n" );
+            goto error;
+        }
+        if (ordinal >= MAX_ORDINALS)
+        {
+            error( "Ordinal number %d too large\n", ordinal );
+            goto error;
+        }
         if (ordinal > Limit) Limit = ordinal;
         if (ordinal < Base) Base = ordinal;
         odp->ordinal = ordinal;
@@ -415,14 +523,27 @@ static void ParseOrdinal(int ordinal)
     if (!strcmp( odp->name, "@" ) || odp->flags & FLAG_NONAME)
     {
         if (ordinal == -1)
-            fatal_error( "Nameless function needs an explicit ordinal number\n" );
+        {
+            error( "Nameless function needs an explicit ordinal number\n" );
+            goto error;
+        }
         if (SpecType != SPEC_WIN32)
-            fatal_error( "Nameless functions not supported for Win16\n" );
+        {
+            error( "Nameless functions not supported for Win16\n" );
+            goto error;
+        }
         if (!strcmp( odp->name, "@" )) free( odp->name );
         else odp->export_name = odp->name;
         odp->name = NULL;
     }
     else Names[nb_names++] = odp;
+    return 1;
+
+error:
+    EntryPoints[--nb_entry_points] = NULL;
+    free( odp->name );
+    free( odp );
+    return 0;
 }
 
 
@@ -453,9 +574,9 @@ static void sort_names(void)
         if (!strcmp( Names[i]->name, Names[i+1]->name ))
         {
             current_line = max( Names[i]->lineno, Names[i+1]->lineno );
-            fatal_error( "'%s' redefined\n%s:%d: First defined here\n",
-                         Names[i]->name, input_file_name,
-                         min( Names[i]->lineno, Names[i+1]->lineno ) );
+            error( "'%s' redefined\n%s:%d: First defined here\n",
+                   Names[i]->name, input_file_name,
+                   min( Names[i]->lineno, Names[i+1]->lineno ) );
         }
     }
 }
@@ -466,31 +587,40 @@ static void sort_names(void)
  *
  * Parse a spec file.
  */
-void ParseTopLevel( FILE *file )
+int ParseTopLevel( FILE *file )
 {
     const char *token;
 
     input_file = file;
     current_line = 0;
 
-    while ((token = GetToken(1)) != NULL)
+    while (get_next_line())
     {
+        if (!(token = GetToken(1))) continue;
         if (strcmp(token, "@") == 0)
-	{
+        {
             if (SpecType != SPEC_WIN32)
-                fatal_error( "'@' ordinals not supported for Win16\n" );
-	    ParseOrdinal( -1 );
-	}
-	else if (IsNumberString(token))
-	{
-	    ParseOrdinal( atoi(token) );
-	}
-	else
-            fatal_error( "Expected ordinal declaration\n" );
+            {
+                error( "'@' ordinals not supported for Win16\n" );
+                continue;
+            }
+            if (!ParseOrdinal( -1 )) continue;
+        }
+        else if (IsNumberString(token))
+        {
+            if (!ParseOrdinal( atoi(token) )) continue;
+        }
+        else
+        {
+            error( "Expected ordinal declaration, got '%s'\n", token );
+            continue;
+        }
+        if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
     }
 
     current_line = 0;  /* no longer parsing the input file */
     sort_names();
+    return !nb_errors;
 }
 
 
@@ -514,7 +644,7 @@ static void add_debug_channel( const char *name )
  *
  * Parse a source file and extract the debug channel definitions.
  */
-void parse_debug_channels( const char *srcdir, const char *filename )
+int parse_debug_channels( const char *srcdir, const char *filename )
 {
     FILE *file;
     int eol_seen = 1;
@@ -540,21 +670,32 @@ void parse_debug_channels( const char *srcdir, const char *filename )
             p += 26;
             while (isspace(*p)) p++;
             if (*p != '(')
-                fatal_error( "invalid debug channel specification '%s'\n", ParseBuffer );
+            {
+                error( "invalid debug channel specification '%s'\n", ParseBuffer );
+                goto next;
+            }
             p++;
             while (isspace(*p)) p++;
             if (!isalpha(*p))
-                fatal_error( "invalid debug channel specification '%s'\n", ParseBuffer );
+            {
+                error( "invalid debug channel specification '%s'\n", ParseBuffer );
+                goto next;
+            }
             channel = p;
             while (isalnum(*p) || *p == '_') p++;
             end = p;
             while (isspace(*p)) p++;
             if (*p != ')')
-                fatal_error( "invalid debug channel specification '%s'\n", ParseBuffer );
+            {
+                error( "invalid debug channel specification '%s'\n", ParseBuffer );
+                goto next;
+            }
             *end = 0;
             add_debug_channel( channel );
         }
+    next:
         current_line++;
     }
     close_input_file( file );
+    return !nb_errors;
 }

tools/winebuild/spec16.c

@@ -451,14 +451,17 @@ static void BuildCallFrom16Func( FILE *outfile, const char *profile, const char
  * routines by yourself.
  *
  */
-static void BuildCallTo16Func( FILE *outfile, const char *profile, const char *prefix )
+static int BuildCallTo16Func( FILE *outfile, const char *profile, const char *prefix )
 {
     const char *args = profile + 5;
     int i, argsize = 0, short_ret = 0;
 
     if (!strncmp( "word_", profile, 5 )) short_ret = 1;
     else if (strncmp( "long_", profile, 5 ))
-        fatal_error( "Invalid function name '%s'\n", profile );
+    {
+        error( "Invalid function name '%s'\n", profile );
+        return 0;
+    }
 
     fprintf( outfile, "unsigned %s __stdcall %s_CallTo16_%s( void (*proc)()",
              short_ret? "short" : "int", prefix, profile );
@@ -470,7 +473,9 @@ static void BuildCallTo16Func( FILE *outfile, const char *profile, const char *p
         {
         case 'w': fprintf( outfile, "unsigned short" ); argsize += 2; break;
         case 'l': fprintf( outfile, "unsigned int" ); argsize += 4; break;
-        default: fatal_error( "Invalid letter '%c' in function name '%s'\n", args[i], profile );
+        default:
+            error( "Invalid letter '%c' in function name '%s'\n", args[i], profile );
+            return 0;
         }
         fprintf( outfile, " arg%d", i+1 );
     }
@@ -509,6 +514,7 @@ static void BuildCallTo16Func( FILE *outfile, const char *profile, const char *p
 #else  /* __i386__ */
     fprintf( outfile, "    assert(0);\n}\n\n" );
 #endif  /* __i386__ */
+    return 1;
 }
 
 

tools/winebuild/spec32.c

@@ -868,7 +868,10 @@ void BuildDebugFile( FILE *outfile, const char *srcdir, char **argv )
     int nr_debug;
     char *prefix, *p;
 
-    while (*argv) parse_debug_channels( srcdir, *argv++ );
+    while (*argv)
+    {
+        if (!parse_debug_channels( srcdir, *argv++ )) exit(1);
+    }
 
     output_standard_file_header( outfile );
     nr_debug = output_debug( outfile );

tools/winebuild/utils.c

@@ -104,6 +104,22 @@ void fatal_perror( const char *msg, ... )
     exit(1);
 }
 
+void error( const char *msg, ... )
+{
+    va_list valist;
+    va_start( valist, msg );
+    if (input_file_name)
+    {
+        fprintf( stderr, "%s:", input_file_name );
+        if (current_line)
+            fprintf( stderr, "%d:", current_line );
+        fputc( ' ', stderr );
+    }
+    vfprintf( stderr, msg, valist );
+    va_end( valist );
+    nb_errors++;
+}
+
 void warning( const char *msg, ... )
 {
     va_list valist;

tools/winebuild/winebuild.man.in

@@ -191,13 +191,13 @@ A spec file should contain a list of ordinal declarations. The general
 syntax is the following:
 .PP
 .I ordinal functype
-.RI [ flags ]\  exportname \ \fB(\fR\ [ args... ] \ \fB)\fI\ handler
+.RI [ flags ]\  exportname \ \fB(\fR\ [ args... ] \ \fB) \ [ handler ]
 .br
 .IB ordinal\  variable
 .RI [ flags ]\  exportname \ \fB(\fR\ [ data... ] \ \fB)
 .br
 .IB ordinal\  extern
-.RI [ flags ]\  exportname\ symbolname
+.RI [ flags ]\  exportname \ [ symbolname ]
 .br
 .IB ordinal\  stub
 .RI [ flags ]\  exportname
@@ -207,9 +207,11 @@ syntax is the following:
 .br
 .BI #\  comments
 .PP
-Lines whose first character is a
+Declarations must fit on a single line, except if the end of line is
+escaped using a backslash character. The
 .B #
-will be ignored as comments.
+character anywhere in a line causes the rest of the line to be ignored
+as a comment.
 .PP
 .I ordinal
 specifies the ordinal number corresponding to the entry point, or '@'
@@ -242,7 +244,7 @@ The function is an interrupt handler routine.
 Syntax:
 .br
 .I ordinal functype
-.RI [ flags ]\  exportname \ \fB(\fR\ [ args... ] \ \fB)\fI\ handler
+.RI [ flags ]\  exportname \ \fB(\fR\ [ args... ] \ \fB) \ [ handler ]
 .br
 
 This declaration defines a function entry point.  The prototype defined by
@@ -312,25 +314,30 @@ is the name of the actual C function that will implement that entry
 point in 32-bit mode. The handler can also be specified as
 .IB dllname . function
 to define a forwarded function (one whose implementation is in another
-dll).
-.PP
-This first example defines an entry point for the 16-bit
-CreateWindow() call (the ordinal 100 is just an example):
-.IP
-100 pascal CreateWindow(ptr ptr long s_word s_word s_word s_word word word word ptr) WIN_CreateWindow
+dll). If
+.I handler
+is not specified, it is assumed to be identical to
+.I exportname.
 .PP
-This second example defines an entry point for the 32-bit GetFocus()
+This first example defines an entry point for the 32-bit GetFocus()
 call:
 .IP
 @ stdcall GetFocus() GetFocus
 .PP
+This second example defines an entry point for the 16-bit
+CreateWindow() call (the ordinal 100 is just an example); it also
+shows how long lines can be split using a backslash:
+.IP
+100 pascal CreateWindow(ptr ptr long s_word s_word s_word \\
+    s_word word word word ptr) WIN_CreateWindow
+.PP
 To declare a function using a variable number of arguments in Win16,
 specify the function as taking no arguments. The arguments are then
 available with CURRENT_STACK16->args. In Win32, specify the function
 as
 .B varargs
 and declare it with a '...' parameter in the C file.  See the
-wsprintf* functions in user.spec and user32.spec for an example.
+wsprintf* functions in user.exe.spec and user32.spec for an example.
 .SS "Variable ordinals"
 Syntax:
 .br
@@ -357,7 +364,7 @@ instead (see below).
 Syntax:
 .br
 .IB ordinal\  extern
-.RI [ flags ]\  exportname\ symbolname
+.RI [ flags ]\  exportname \ [ symbolname ]
 .PP
 This declaration defines an entry that simply maps to a C symbol
 (variable or function). It only works in Win32 spec files.
@@ -368,8 +375,10 @@ that must be defined in the C code. Alternatively, it can be of the
 form
 .IB dllname . symbolname
 to define a forwarded symbol (one whose implementation is in another
-dll).
-
+dll). If
+.I symbolname
+is not specified, it is assumed to be identical to
+.I exportname.
 .SS "Stub ordinals"
 Syntax:
 .br