setupapi: Implement SetupDiCreateDeviceInfoListExW.
[wine] / dlls / setupapi / parser.c
1 /*
2  * INF file parsing
3  *
4  * Copyright 2002 Alexandre Julliard for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <limits.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <stdlib.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winnls.h"
35 #include "winreg.h"
36 #include "winternl.h"
37 #include "winerror.h"
38 #include "setupapi.h"
39 #include "setupapi_private.h"
40
41 #include "wine/unicode.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
45
46 #define CONTROL_Z  '\x1a'
47 #define MAX_SECTION_NAME_LEN  255
48 #define MAX_FIELD_LEN         511  /* larger fields get silently truncated */
49 /* actual string limit is MAX_INF_STRING_LENGTH+1 (plus terminating null) under Windows */
50 #define MAX_STRING_LEN        (MAX_INF_STRING_LENGTH+1)
51
52 /* inf file structure definitions */
53
54 struct field
55 {
56     const WCHAR *text;         /* field text */
57 };
58
59 struct line
60 {
61     int first_field;           /* index of first field in field array */
62     int nb_fields;             /* number of fields in line */
63     int key_field;             /* index of field for key or -1 if no key */
64 };
65
66 struct section
67 {
68     const WCHAR *name;         /* section name */
69     unsigned int nb_lines;     /* number of used lines */
70     unsigned int alloc_lines;  /* total number of allocated lines in array below */
71     struct line  lines[16];    /* lines information (grown dynamically, 16 is initial size) */
72 };
73
74 struct inf_file
75 {
76     struct inf_file *next;            /* next appended file */
77     WCHAR           *strings;         /* buffer for string data (section names and field values) */
78     WCHAR           *string_pos;      /* position of next available string in buffer */
79     unsigned int     nb_sections;     /* number of used sections */
80     unsigned int     alloc_sections;  /* total number of allocated section pointers */
81     struct section **sections;        /* section pointers array */
82     unsigned int     nb_fields;
83     unsigned int     alloc_fields;
84     struct field    *fields;
85     int              strings_section; /* index of [Strings] section or -1 if none */
86     WCHAR           *filename;        /* filename of the INF */
87 };
88
89 /* parser definitions */
90
91 enum parser_state
92 {
93     LINE_START,      /* at beginning of a line */
94     SECTION_NAME,    /* parsing a section name */
95     KEY_NAME,        /* parsing a key name */
96     VALUE_NAME,      /* parsing a value name */
97     EOL_BACKSLASH,   /* backslash at end of line */
98     QUOTES,          /* inside quotes */
99     LEADING_SPACES,  /* leading spaces */
100     TRAILING_SPACES, /* trailing spaces */
101     COMMENT,         /* inside a comment */
102     NB_PARSER_STATES
103 };
104
105 struct parser
106 {
107     const WCHAR      *start;        /* start position of item being parsed */
108     const WCHAR      *end;          /* end of buffer */
109     struct inf_file  *file;         /* file being built */
110     enum parser_state state;        /* current parser state */
111     enum parser_state stack[4];     /* state stack */
112     int               stack_pos;    /* current pos in stack */
113
114     int               cur_section;  /* index of section being parsed*/
115     struct line      *line;         /* current line */
116     unsigned int      line_pos;     /* current line position in file */
117     unsigned int      error;        /* error code */
118     unsigned int      token_len;    /* current token len */
119     WCHAR token[MAX_FIELD_LEN+1];   /* current token */
120 };
121
122 typedef const WCHAR * (*parser_state_func)( struct parser *parser, const WCHAR *pos );
123
124 /* parser state machine functions */
125 static const WCHAR *line_start_state( struct parser *parser, const WCHAR *pos );
126 static const WCHAR *section_name_state( struct parser *parser, const WCHAR *pos );
127 static const WCHAR *key_name_state( struct parser *parser, const WCHAR *pos );
128 static const WCHAR *value_name_state( struct parser *parser, const WCHAR *pos );
129 static const WCHAR *eol_backslash_state( struct parser *parser, const WCHAR *pos );
130 static const WCHAR *quotes_state( struct parser *parser, const WCHAR *pos );
131 static const WCHAR *leading_spaces_state( struct parser *parser, const WCHAR *pos );
132 static const WCHAR *trailing_spaces_state( struct parser *parser, const WCHAR *pos );
133 static const WCHAR *comment_state( struct parser *parser, const WCHAR *pos );
134
135 static const parser_state_func parser_funcs[NB_PARSER_STATES] =
136 {
137     line_start_state,      /* LINE_START */
138     section_name_state,    /* SECTION_NAME */
139     key_name_state,        /* KEY_NAME */
140     value_name_state,      /* VALUE_NAME */
141     eol_backslash_state,   /* EOL_BACKSLASH */
142     quotes_state,          /* QUOTES */
143     leading_spaces_state,  /* LEADING_SPACES */
144     trailing_spaces_state, /* TRAILING_SPACES */
145     comment_state          /* COMMENT */
146 };
147
148
149 /* Unicode string constants */
150 static const WCHAR Version[]    = {'V','e','r','s','i','o','n',0};
151 static const WCHAR Signature[]  = {'S','i','g','n','a','t','u','r','e',0};
152 static const WCHAR Chicago[]    = {'$','C','h','i','c','a','g','o','$',0};
153 static const WCHAR WindowsNT[]  = {'$','W','i','n','d','o','w','s',' ','N','T','$',0};
154 static const WCHAR Windows95[]  = {'$','W','i','n','d','o','w','s',' ','9','5','$',0};
155 static const WCHAR LayoutFile[] = {'L','a','y','o','u','t','F','i','l','e',0};
156
157 /* extend an array, allocating more memory if necessary */
158 static void *grow_array( void *array, unsigned int *count, size_t elem )
159 {
160     void *new_array;
161     unsigned int new_count = *count + *count / 2;
162     if (new_count < 32) new_count = 32;
163
164     if (array)
165         new_array = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, array, new_count * elem );
166     else
167         new_array = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * elem );
168
169     if (new_array)
170         *count = new_count;
171     else
172         HeapFree( GetProcessHeap(), 0, array );
173     return new_array;
174 }
175
176
177 /* get the directory of the inf file (as counted string, not null-terminated) */
178 static const WCHAR *get_inf_dir( struct inf_file *file, unsigned int *len )
179 {
180     const WCHAR *p = strrchrW( file->filename, '\\' );
181     *len = p ? (p + 1 - file->filename) : 0;
182     return file->filename;
183 }
184
185
186 /* find a section by name */
187 static int find_section( struct inf_file *file, const WCHAR *name )
188 {
189     unsigned int i;
190
191     for (i = 0; i < file->nb_sections; i++)
192         if (!strcmpiW( name, file->sections[i]->name )) return i;
193     return -1;
194 }
195
196
197 /* find a line by name */
198 static struct line *find_line( struct inf_file *file, int section_index, const WCHAR *name )
199 {
200     struct section *section;
201     struct line *line;
202     int i;
203
204     if (section_index < 0 || section_index >= file->nb_sections) return NULL;
205     section = file->sections[section_index];
206     for (i = 0, line = section->lines; i < section->nb_lines; i++, line++)
207     {
208         if (line->key_field == -1) continue;
209         if (!strcmpiW( name, file->fields[line->key_field].text )) return line;
210     }
211     return NULL;
212 }
213
214
215 /* add a section to the file and return the section index */
216 static int add_section( struct inf_file *file, const WCHAR *name )
217 {
218     struct section *section;
219
220     if (file->nb_sections >= file->alloc_sections)
221     {
222         if (!(file->sections = grow_array( file->sections, &file->alloc_sections,
223                                            sizeof(file->sections[0]) ))) return -1;
224     }
225     if (!(section = HeapAlloc( GetProcessHeap(), 0, sizeof(*section) ))) return -1;
226     section->name        = name;
227     section->nb_lines    = 0;
228     section->alloc_lines = sizeof(section->lines)/sizeof(section->lines[0]);
229     file->sections[file->nb_sections] = section;
230     return file->nb_sections++;
231 }
232
233
234 /* add a line to a given section */
235 static struct line *add_line( struct inf_file *file, int section_index )
236 {
237     struct section *section;
238     struct line *line;
239
240     assert( section_index >= 0 && section_index < file->nb_sections );
241
242     section = file->sections[section_index];
243     if (section->nb_lines == section->alloc_lines)  /* need to grow the section */
244     {
245         int size = sizeof(*section) - sizeof(section->lines) + 2*section->alloc_lines*sizeof(*line);
246         if (!(section = HeapReAlloc( GetProcessHeap(), 0, section, size ))) return NULL;
247         section->alloc_lines *= 2;
248         file->sections[section_index] = section;
249     }
250     line = &section->lines[section->nb_lines++];
251     line->first_field = file->nb_fields;
252     line->nb_fields   = 0;
253     line->key_field   = -1;
254     return line;
255 }
256
257
258 /* retrieve a given line from section/line index */
259 inline static struct line *get_line( struct inf_file *file, unsigned int section_index,
260                                      unsigned int line_index )
261 {
262     struct section *section;
263
264     if (section_index >= file->nb_sections) return NULL;
265     section = file->sections[section_index];
266     if (line_index >= section->nb_lines) return NULL;
267     return &section->lines[line_index];
268 }
269
270
271 /* retrieve a given field from section/line/field index */
272 static struct field *get_field( struct inf_file *file, int section_index, int line_index,
273                                 int field_index )
274 {
275     struct line *line = get_line( file, section_index, line_index );
276
277     if (!line) return NULL;
278     if (!field_index)  /* get the key */
279     {
280         if (line->key_field == -1) return NULL;
281         return &file->fields[line->key_field];
282     }
283     field_index--;
284     if (field_index >= line->nb_fields) return NULL;
285     return &file->fields[line->first_field + field_index];
286 }
287
288
289 /* allocate a new field, growing the array if necessary */
290 static struct field *add_field( struct inf_file *file, const WCHAR *text )
291 {
292     struct field *field;
293
294     if (file->nb_fields >= file->alloc_fields)
295     {
296         if (!(file->fields = grow_array( file->fields, &file->alloc_fields,
297                                          sizeof(file->fields[0]) ))) return NULL;
298     }
299     field = &file->fields[file->nb_fields++];
300     field->text = text;
301     return field;
302 }
303
304
305 /* retrieve the string substitution for a directory id */
306 static const WCHAR *get_dirid_subst( struct inf_file *file, int dirid, unsigned int *len )
307 {
308     const WCHAR *ret;
309
310     if (dirid == DIRID_SRCPATH) return get_inf_dir( file, len );
311     ret = DIRID_get_string( dirid );
312     if (ret) *len = strlenW(ret);
313     return ret;
314 }
315
316
317 /* retrieve the string substitution for a given string, or NULL if not found */
318 /* if found, len is set to the substitution length */
319 static const WCHAR *get_string_subst( struct inf_file *file, const WCHAR *str, unsigned int *len )
320 {
321     static const WCHAR percent = '%';
322
323     struct section *strings_section;
324     struct line *line;
325     struct field *field;
326     unsigned int i;
327     int dirid;
328     WCHAR *dirid_str, *end;
329     const WCHAR *ret = NULL;
330
331     if (!*len)  /* empty string (%%) is replaced by single percent */
332     {
333         *len = 1;
334         return &percent;
335     }
336     if (file->strings_section == -1) goto not_found;
337     strings_section = file->sections[file->strings_section];
338     for (i = 0, line = strings_section->lines; i < strings_section->nb_lines; i++, line++)
339     {
340         if (line->key_field == -1) continue;
341         if (strncmpiW( str, file->fields[line->key_field].text, *len )) continue;
342         if (!file->fields[line->key_field].text[*len]) break;
343     }
344     if (i == strings_section->nb_lines || !line->nb_fields) goto not_found;
345     field = &file->fields[line->first_field];
346     *len = strlenW( field->text );
347     return field->text;
348
349  not_found:  /* check for integer id */
350     if ((dirid_str = HeapAlloc( GetProcessHeap(), 0, (*len+1) * sizeof(WCHAR) )))
351     {
352         memcpy( dirid_str, str, *len * sizeof(WCHAR) );
353         dirid_str[*len] = 0;
354         dirid = strtolW( dirid_str, &end, 10 );
355         if (!*end) ret = get_dirid_subst( file, dirid, len );
356         HeapFree( GetProcessHeap(), 0, dirid_str );
357         return ret;
358     }
359     return NULL;
360 }
361
362
363 /* do string substitutions on the specified text */
364 /* the buffer is assumed to be large enough */
365 /* returns necessary length not including terminating null */
366 unsigned int PARSER_string_substW( struct inf_file *file, const WCHAR *text, WCHAR *buffer,
367                                    unsigned int size )
368 {
369     const WCHAR *start, *subst, *p;
370     unsigned int len, total = 0;
371     int inside = 0;
372
373     if (!buffer) size = MAX_STRING_LEN + 1;
374     for (p = start = text; *p; p++)
375     {
376         if (*p != '%') continue;
377         inside = !inside;
378         if (inside)  /* start of a %xx% string */
379         {
380             len = p - start;
381             if (len > size - 1) len = size - 1;
382             if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
383             total += len;
384             size -= len;
385             start = p;
386         }
387         else /* end of the %xx% string, find substitution */
388         {
389             len = p - start - 1;
390             subst = get_string_subst( file, start + 1, &len );
391             if (!subst)
392             {
393                 subst = start;
394                 len = p - start + 1;
395             }
396             if (len > size - 1) len = size - 1;
397             if (buffer) memcpy( buffer + total, subst, len * sizeof(WCHAR) );
398             total += len;
399             size -= len;
400             start = p + 1;
401         }
402     }
403
404     if (start != p) /* unfinished string, copy it */
405     {
406         len = p - start;
407         if (len > size - 1) len = size - 1;
408         if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
409         total += len;
410     }
411     if (buffer && size) buffer[total] = 0;
412     return total;
413 }
414
415
416 /* do string substitutions on the specified text */
417 /* the buffer is assumed to be large enough */
418 /* returns necessary length not including terminating null */
419 unsigned int PARSER_string_substA( struct inf_file *file, const WCHAR *text, char *buffer,
420                                    unsigned int size )
421 {
422     WCHAR buffW[MAX_STRING_LEN+1];
423     DWORD ret;
424
425     unsigned int len = PARSER_string_substW( file, text, buffW, sizeof(buffW)/sizeof(WCHAR) );
426     if (!buffer) RtlUnicodeToMultiByteSize( &ret, buffW, len * sizeof(WCHAR) );
427     else
428     {
429         RtlUnicodeToMultiByteN( buffer, size-1, &ret, buffW, len * sizeof(WCHAR) );
430         buffer[ret] = 0;
431     }
432     return ret;
433 }
434
435
436 /* push some string data into the strings buffer */
437 static WCHAR *push_string( struct inf_file *file, const WCHAR *string )
438 {
439     WCHAR *ret = file->string_pos;
440     strcpyW( ret, string );
441     file->string_pos += strlenW( ret ) + 1;
442     return ret;
443 }
444
445
446 /* push the current state on the parser stack */
447 inline static void push_state( struct parser *parser, enum parser_state state )
448 {
449     assert( parser->stack_pos < sizeof(parser->stack)/sizeof(parser->stack[0]) );
450     parser->stack[parser->stack_pos++] = state;
451 }
452
453
454 /* pop the current state */
455 inline static void pop_state( struct parser *parser )
456 {
457     assert( parser->stack_pos );
458     parser->state = parser->stack[--parser->stack_pos];
459 }
460
461
462 /* set the parser state and return the previous one */
463 inline static enum parser_state set_state( struct parser *parser, enum parser_state state )
464 {
465     enum parser_state ret = parser->state;
466     parser->state = state;
467     return ret;
468 }
469
470
471 /* check if the pointer points to an end of file */
472 inline static int is_eof( struct parser *parser, const WCHAR *ptr )
473 {
474     return (ptr >= parser->end || *ptr == CONTROL_Z);
475 }
476
477
478 /* check if the pointer points to an end of line */
479 inline static int is_eol( struct parser *parser, const WCHAR *ptr )
480 {
481     return (ptr >= parser->end || *ptr == CONTROL_Z || *ptr == '\n');
482 }
483
484
485 /* push data from current token start up to pos into the current token */
486 static int push_token( struct parser *parser, const WCHAR *pos )
487 {
488     int len = pos - parser->start;
489     const WCHAR *src = parser->start;
490     WCHAR *dst = parser->token + parser->token_len;
491
492     if (len > MAX_FIELD_LEN - parser->token_len) len = MAX_FIELD_LEN - parser->token_len;
493
494     parser->token_len += len;
495     for ( ; len > 0; len--, dst++, src++) *dst = *src ? *src : ' ';
496     *dst = 0;
497     parser->start = pos;
498     return 0;
499 }
500
501
502 /* add a section with the current token as name */
503 static int add_section_from_token( struct parser *parser )
504 {
505     int section_index;
506
507     if (parser->token_len > MAX_SECTION_NAME_LEN)
508     {
509         parser->error = ERROR_SECTION_NAME_TOO_LONG;
510         return -1;
511     }
512     if ((section_index = find_section( parser->file, parser->token )) == -1)
513     {
514         /* need to create a new one */
515         const WCHAR *name = push_string( parser->file, parser->token );
516         if ((section_index = add_section( parser->file, name )) == -1)
517         {
518             parser->error = ERROR_NOT_ENOUGH_MEMORY;
519             return -1;
520         }
521     }
522     parser->token_len = 0;
523     parser->cur_section = section_index;
524     return section_index;
525 }
526
527
528 /* add a field containing the current token to the current line */
529 static struct field *add_field_from_token( struct parser *parser, int is_key )
530 {
531     struct field *field;
532     WCHAR *text;
533
534     if (!parser->line)  /* need to start a new line */
535     {
536         if (parser->cur_section == -1)  /* got a line before the first section */
537         {
538             parser->error = ERROR_EXPECTED_SECTION_NAME;
539             return NULL;
540         }
541         if (!(parser->line = add_line( parser->file, parser->cur_section ))) goto error;
542     }
543     else assert(!is_key);
544
545     text = push_string( parser->file, parser->token );
546     if ((field = add_field( parser->file, text )))
547     {
548         if (!is_key) parser->line->nb_fields++;
549         else
550         {
551             /* replace first field by key field */
552             parser->line->key_field = parser->line->first_field;
553             parser->line->first_field++;
554         }
555         parser->token_len = 0;
556         return field;
557     }
558  error:
559     parser->error = ERROR_NOT_ENOUGH_MEMORY;
560     return NULL;
561 }
562
563
564 /* close the current line and prepare for parsing a new one */
565 static void close_current_line( struct parser *parser )
566 {
567     struct line *cur_line = parser->line;
568
569     if (cur_line)
570     {
571         /* if line has a single field and no key, the field is the key too */
572         if (cur_line->nb_fields == 1 && cur_line->key_field == -1)
573             cur_line->key_field = cur_line->first_field;
574     }
575     parser->line = NULL;
576 }
577
578
579 /* handler for parser LINE_START state */
580 static const WCHAR *line_start_state( struct parser *parser, const WCHAR *pos )
581 {
582     const WCHAR *p;
583
584     for (p = pos; !is_eof( parser, p ); p++)
585     {
586         switch(*p)
587         {
588         case '\n':
589             parser->line_pos++;
590             close_current_line( parser );
591             break;
592         case ';':
593             push_state( parser, LINE_START );
594             set_state( parser, COMMENT );
595             return p + 1;
596         case '[':
597             parser->start = p + 1;
598             set_state( parser, SECTION_NAME );
599             return p + 1;
600         default:
601             if (!isspaceW(*p))
602             {
603                 parser->start = p;
604                 set_state( parser, KEY_NAME );
605                 return p;
606             }
607             break;
608         }
609     }
610     close_current_line( parser );
611     return NULL;
612 }
613
614
615 /* handler for parser SECTION_NAME state */
616 static const WCHAR *section_name_state( struct parser *parser, const WCHAR *pos )
617 {
618     const WCHAR *p;
619
620     for (p = pos; !is_eol( parser, p ); p++)
621     {
622         if (*p == ']')
623         {
624             push_token( parser, p );
625             if (add_section_from_token( parser ) == -1) return NULL;
626             push_state( parser, LINE_START );
627             set_state( parser, COMMENT );  /* ignore everything else on the line */
628             return p + 1;
629         }
630     }
631     parser->error = ERROR_BAD_SECTION_NAME_LINE; /* unfinished section name */
632     return NULL;
633 }
634
635
636 /* handler for parser KEY_NAME state */
637 static const WCHAR *key_name_state( struct parser *parser, const WCHAR *pos )
638 {
639     const WCHAR *p, *token_end = parser->start;
640
641     for (p = pos; !is_eol( parser, p ); p++)
642     {
643         if (*p == ',') break;
644         switch(*p)
645         {
646
647          case '=':
648             push_token( parser, token_end );
649             if (!add_field_from_token( parser, 1 )) return NULL;
650             parser->start = p + 1;
651             push_state( parser, VALUE_NAME );
652             set_state( parser, LEADING_SPACES );
653             return p + 1;
654         case ';':
655             push_token( parser, token_end );
656             if (!add_field_from_token( parser, 0 )) return NULL;
657             push_state( parser, LINE_START );
658             set_state( parser, COMMENT );
659             return p + 1;
660         case '"':
661             push_token( parser, p );
662             parser->start = p + 1;
663             push_state( parser, KEY_NAME );
664             set_state( parser, QUOTES );
665             return p + 1;
666         case '\\':
667             push_token( parser, token_end );
668             parser->start = p;
669             push_state( parser, KEY_NAME );
670             set_state( parser, EOL_BACKSLASH );
671             return p;
672         default:
673             if (!isspaceW(*p)) token_end = p + 1;
674             else
675             {
676                 push_token( parser, p );
677                 push_state( parser, KEY_NAME );
678                 set_state( parser, TRAILING_SPACES );
679                 return p;
680             }
681             break;
682         }
683     }
684     push_token( parser, token_end );
685     set_state( parser, VALUE_NAME );
686     return p;
687 }
688
689
690 /* handler for parser VALUE_NAME state */
691 static const WCHAR *value_name_state( struct parser *parser, const WCHAR *pos )
692 {
693     const WCHAR *p, *token_end = parser->start;
694
695     for (p = pos; !is_eol( parser, p ); p++)
696     {
697         switch(*p)
698         {
699         case ';':
700             push_token( parser, token_end );
701             if (!add_field_from_token( parser, 0 )) return NULL;
702             push_state( parser, LINE_START );
703             set_state( parser, COMMENT );
704             return p + 1;
705         case ',':
706             push_token( parser, token_end );
707             if (!add_field_from_token( parser, 0 )) return NULL;
708             parser->start = p + 1;
709             push_state( parser, VALUE_NAME );
710             set_state( parser, LEADING_SPACES );
711             return p + 1;
712         case '"':
713             push_token( parser, p );
714             parser->start = p + 1;
715             push_state( parser, VALUE_NAME );
716             set_state( parser, QUOTES );
717             return p + 1;
718         case '\\':
719             push_token( parser, token_end );
720             parser->start = p;
721             push_state( parser, VALUE_NAME );
722             set_state( parser, EOL_BACKSLASH );
723             return p;
724         default:
725             if (!isspaceW(*p)) token_end = p + 1;
726             else
727             {
728                 push_token( parser, p );
729                 push_state( parser, VALUE_NAME );
730                 set_state( parser, TRAILING_SPACES );
731                 return p;
732             }
733             break;
734         }
735     }
736     push_token( parser, token_end );
737     if (!add_field_from_token( parser, 0 )) return NULL;
738     set_state( parser, LINE_START );
739     return p;
740 }
741
742
743 /* handler for parser EOL_BACKSLASH state */
744 static const WCHAR *eol_backslash_state( struct parser *parser, const WCHAR *pos )
745 {
746     const WCHAR *p;
747
748     for (p = pos; !is_eof( parser, p ); p++)
749     {
750         switch(*p)
751         {
752         case '\n':
753             parser->line_pos++;
754             parser->start = p + 1;
755             set_state( parser, LEADING_SPACES );
756             return p + 1;
757         case '\\':
758             continue;
759         case ';':
760             push_state( parser, EOL_BACKSLASH );
761             set_state( parser, COMMENT );
762             return p + 1;
763         default:
764             if (isspaceW(*p)) continue;
765             push_token( parser, p );
766             pop_state( parser );
767             return p;
768         }
769     }
770     parser->start = p;
771     pop_state( parser );
772     return p;
773 }
774
775
776 /* handler for parser QUOTES state */
777 static const WCHAR *quotes_state( struct parser *parser, const WCHAR *pos )
778 {
779     const WCHAR *p, *token_end = parser->start;
780
781     for (p = pos; !is_eol( parser, p ); p++)
782     {
783         if (*p == '"')
784         {
785             if (p+1 < parser->end && p[1] == '"')  /* double quotes */
786             {
787                 push_token( parser, p + 1 );
788                 parser->start = token_end = p + 2;
789                 p++;
790             }
791             else  /* end of quotes */
792             {
793                 push_token( parser, p );
794                 parser->start = p + 1;
795                 pop_state( parser );
796                 return p + 1;
797             }
798         }
799     }
800     push_token( parser, p );
801     pop_state( parser );
802     return p;
803 }
804
805
806 /* handler for parser LEADING_SPACES state */
807 static const WCHAR *leading_spaces_state( struct parser *parser, const WCHAR *pos )
808 {
809     const WCHAR *p;
810
811     for (p = pos; !is_eol( parser, p ); p++)
812     {
813         if (*p == '\\')
814         {
815             parser->start = p;
816             set_state( parser, EOL_BACKSLASH );
817             return p;
818         }
819         if (!isspaceW(*p)) break;
820     }
821     parser->start = p;
822     pop_state( parser );
823     return p;
824 }
825
826
827 /* handler for parser TRAILING_SPACES state */
828 static const WCHAR *trailing_spaces_state( struct parser *parser, const WCHAR *pos )
829 {
830     const WCHAR *p;
831
832     for (p = pos; !is_eol( parser, p ); p++)
833     {
834         if (*p == '\\')
835         {
836             set_state( parser, EOL_BACKSLASH );
837             return p;
838         }
839         if (!isspaceW(*p)) break;
840     }
841     pop_state( parser );
842     return p;
843 }
844
845
846 /* handler for parser COMMENT state */
847 static const WCHAR *comment_state( struct parser *parser, const WCHAR *pos )
848 {
849     const WCHAR *p = pos;
850
851     while (!is_eol( parser, p )) p++;
852     pop_state( parser );
853     return p;
854 }
855
856
857 /* parse a complete buffer */
858 static DWORD parse_buffer( struct inf_file *file, const WCHAR *buffer, const WCHAR *end,
859                            UINT *error_line )
860 {
861     static const WCHAR Strings[] = {'S','t','r','i','n','g','s',0};
862
863     struct parser parser;
864     const WCHAR *pos = buffer;
865
866     parser.start       = buffer;
867     parser.end         = end;
868     parser.file        = file;
869     parser.line        = NULL;
870     parser.state       = LINE_START;
871     parser.stack_pos   = 0;
872     parser.cur_section = -1;
873     parser.line_pos    = 1;
874     parser.error       = 0;
875     parser.token_len   = 0;
876
877     /* parser main loop */
878     while (pos) pos = (parser_funcs[parser.state])( &parser, pos );
879
880     /* trim excess buffer space */
881     if (file->alloc_sections > file->nb_sections)
882     {
883         file->sections = HeapReAlloc( GetProcessHeap(), 0, file->sections,
884                                       file->nb_sections * sizeof(file->sections[0]) );
885         file->alloc_sections = file->nb_sections;
886     }
887     if (file->alloc_fields > file->nb_fields)
888     {
889         file->fields = HeapReAlloc( GetProcessHeap(), 0, file->fields,
890                                     file->nb_fields * sizeof(file->fields[0]) );
891         file->alloc_fields = file->nb_fields;
892     }
893     file->strings = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, file->strings,
894                                  (file->string_pos - file->strings) * sizeof(WCHAR) );
895
896     if (parser.error)
897     {
898         if (error_line) *error_line = parser.line_pos;
899         return parser.error;
900     }
901
902     /* find the [strings] section */
903     file->strings_section = find_section( file, Strings );
904     return 0;
905 }
906
907
908 /* append a child INF file to its parent list, in a thread-safe manner */
909 static void append_inf_file( struct inf_file *parent, struct inf_file *child )
910 {
911     struct inf_file **ppnext = &parent->next;
912     child->next = NULL;
913
914     for (;;)
915     {
916         struct inf_file *next = InterlockedCompareExchangePointer( (void **)ppnext, child, NULL );
917         if (!next) return;
918         ppnext = &next->next;
919     }
920 }
921
922
923 /***********************************************************************
924  *            parse_file
925  *
926  * parse an INF file.
927  */
928 static struct inf_file *parse_file( HANDLE handle, const WCHAR *class, UINT *error_line )
929 {
930     void *buffer;
931     DWORD err = 0;
932     struct inf_file *file;
933
934     DWORD size = GetFileSize( handle, NULL );
935     HANDLE mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, size, NULL );
936     if (!mapping) return NULL;
937     buffer = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, size );
938     NtClose( mapping );
939     if (!buffer) return NULL;
940
941     if (class) FIXME( "class %s not supported yet\n", debugstr_w(class) );
942
943     if (!(file = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*file) )))
944     {
945         err = ERROR_NOT_ENOUGH_MEMORY;
946         goto done;
947     }
948
949     /* we won't need more strings space than the size of the file,
950      * so we can preallocate it here
951      */
952     if (!(file->strings = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )))
953     {
954         err = ERROR_NOT_ENOUGH_MEMORY;
955         goto done;
956     }
957     file->string_pos = file->strings;
958     file->strings_section = -1;
959
960     if (!RtlIsTextUnicode( buffer, size, NULL ))
961     {
962         WCHAR *new_buff = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
963         if (new_buff)
964         {
965             DWORD len = MultiByteToWideChar( CP_ACP, 0, buffer, size, new_buff, size );
966             err = parse_buffer( file, new_buff, new_buff + len, error_line );
967             HeapFree( GetProcessHeap(), 0, new_buff );
968         }
969     }
970     else
971     {
972         WCHAR *new_buff = (WCHAR *)buffer;
973         /* UCS-16 files should start with the Unicode BOM; we should skip it */
974         if (*new_buff == 0xfeff)
975             new_buff++;
976         err = parse_buffer( file, new_buff, (WCHAR *)((char *)buffer + size), error_line );
977     }
978
979     if (!err)  /* now check signature */
980     {
981         int version_index = find_section( file, Version );
982         if (version_index != -1)
983         {
984             struct line *line = find_line( file, version_index, Signature );
985             if (line && line->nb_fields > 0)
986             {
987                 struct field *field = file->fields + line->first_field;
988                 if (!strcmpiW( field->text, Chicago )) goto done;
989                 if (!strcmpiW( field->text, WindowsNT )) goto done;
990                 if (!strcmpiW( field->text, Windows95 )) goto done;
991             }
992         }
993         if (error_line) *error_line = 0;
994         err = ERROR_WRONG_INF_STYLE;
995     }
996
997  done:
998     UnmapViewOfFile( buffer );
999     if (err)
1000     {
1001         HeapFree( GetProcessHeap(), 0, file );
1002         SetLastError( err );
1003         file = NULL;
1004     }
1005     return file;
1006 }
1007
1008
1009 /***********************************************************************
1010  *            PARSER_get_inf_filename
1011  *
1012  * Retrieve the filename of an inf file.
1013  */
1014 const WCHAR *PARSER_get_inf_filename( HINF hinf )
1015 {
1016     struct inf_file *file = hinf;
1017     return file->filename;
1018 }
1019
1020
1021 /***********************************************************************
1022  *            PARSER_get_src_root
1023  *
1024  * Retrieve the source directory of an inf file.
1025  */
1026 WCHAR *PARSER_get_src_root( HINF hinf )
1027 {
1028     unsigned int len;
1029     const WCHAR *dir = get_inf_dir( hinf, &len );
1030     WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
1031     if (ret)
1032     {
1033         memcpy( ret, dir, len * sizeof(WCHAR) );
1034         ret[len] = 0;
1035     }
1036     return ret;
1037 }
1038
1039
1040 /***********************************************************************
1041  *            PARSER_get_dest_dir
1042  *
1043  * retrieve a destination dir of the form "dirid,relative_path" in the given entry.
1044  * returned buffer must be freed by caller.
1045  */
1046 WCHAR *PARSER_get_dest_dir( INFCONTEXT *context )
1047 {
1048     const WCHAR *dir;
1049     WCHAR *ptr, *ret;
1050     INT dirid;
1051     unsigned int len1;
1052     DWORD len2;
1053
1054     if (!SetupGetIntField( context, 1, &dirid )) return NULL;
1055     if (!(dir = get_dirid_subst( context->Inf, dirid, &len1 ))) return NULL;
1056     if (!SetupGetStringFieldW( context, 2, NULL, 0, &len2 )) len2 = 0;
1057     if (!(ret = HeapAlloc( GetProcessHeap(), 0, (len1+len2+1) * sizeof(WCHAR) ))) return NULL;
1058     memcpy( ret, dir, len1 * sizeof(WCHAR) );
1059     ptr = ret + len1;
1060     if (len2 && ptr > ret && ptr[-1] != '\\') *ptr++ = '\\';
1061     if (!SetupGetStringFieldW( context, 2, ptr, len2, NULL )) *ptr = 0;
1062     return ret;
1063 }
1064
1065
1066 /***********************************************************************
1067  *            SetupOpenInfFileA   (SETUPAPI.@)
1068  */
1069 HINF WINAPI SetupOpenInfFileA( PCSTR name, PCSTR class, DWORD style, UINT *error )
1070 {
1071     UNICODE_STRING nameW, classW;
1072     HINF ret = (HINF)INVALID_HANDLE_VALUE;
1073
1074     classW.Buffer = NULL;
1075     if (class && !RtlCreateUnicodeStringFromAsciiz( &classW, class ))
1076     {
1077         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1078         return ret;
1079     }
1080     if (RtlCreateUnicodeStringFromAsciiz( &nameW, name ))
1081     {
1082         ret = SetupOpenInfFileW( nameW.Buffer, classW.Buffer, style, error );
1083         RtlFreeUnicodeString( &nameW );
1084     }
1085     RtlFreeUnicodeString( &classW );
1086     return ret;
1087 }
1088
1089
1090 /***********************************************************************
1091  *            SetupOpenInfFileW   (SETUPAPI.@)
1092  */
1093 HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *error )
1094 {
1095     struct inf_file *file = NULL;
1096     HANDLE handle;
1097     WCHAR *path, *p;
1098     UINT len;
1099
1100     if (strchrW( name, '\\' ) || strchrW( name, '/' ))
1101     {
1102         if (!(len = GetFullPathNameW( name, 0, NULL, NULL ))) return (HINF)INVALID_HANDLE_VALUE;
1103         if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1104         {
1105             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1106             return (HINF)INVALID_HANDLE_VALUE;
1107         }
1108         GetFullPathNameW( name, len, path, NULL );
1109         handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1110     }
1111     else  /* try Windows directory */
1112     {
1113         static const WCHAR Inf[]      = {'\\','i','n','f','\\',0};
1114         static const WCHAR System32[] = {'\\','s','y','s','t','e','m','3','2','\\',0};
1115
1116         len = GetWindowsDirectoryW( NULL, 0 ) + strlenW(name) + 12;
1117         if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1118         {
1119             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1120             return (HINF)INVALID_HANDLE_VALUE;
1121         }
1122         GetWindowsDirectoryW( path, len );
1123         p = path + strlenW(path);
1124         strcpyW( p, Inf );
1125         strcatW( p, name );
1126         handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1127         if (handle == INVALID_HANDLE_VALUE)
1128         {
1129             strcpyW( p, System32 );
1130             strcatW( p, name );
1131             handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1132         }
1133     }
1134
1135     if (handle != INVALID_HANDLE_VALUE)
1136     {
1137         file = parse_file( handle, class, error );
1138         CloseHandle( handle );
1139     }
1140     if (!file)
1141     {
1142         HeapFree( GetProcessHeap(), 0, path );
1143         return (HINF)INVALID_HANDLE_VALUE;
1144     }
1145     TRACE( "%s -> %p\n", debugstr_w(path), file );
1146     file->filename = path;
1147     SetLastError( 0 );
1148     return (HINF)file;
1149 }
1150
1151
1152 /***********************************************************************
1153  *            SetupOpenAppendInfFileA    (SETUPAPI.@)
1154  */
1155 BOOL WINAPI SetupOpenAppendInfFileA( PCSTR name, HINF parent_hinf, UINT *error )
1156 {
1157     HINF child_hinf;
1158
1159     if (!name) return SetupOpenAppendInfFileW( NULL, parent_hinf, error );
1160     child_hinf = SetupOpenInfFileA( name, NULL, INF_STYLE_WIN4, error );
1161     if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE;
1162     append_inf_file( parent_hinf, child_hinf );
1163     TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_a(name), child_hinf );
1164     return TRUE;
1165 }
1166
1167
1168 /***********************************************************************
1169  *            SetupOpenAppendInfFileW    (SETUPAPI.@)
1170  */
1171 BOOL WINAPI SetupOpenAppendInfFileW( PCWSTR name, HINF parent_hinf, UINT *error )
1172 {
1173     HINF child_hinf;
1174
1175     if (!name)
1176     {
1177         INFCONTEXT context;
1178         WCHAR filename[MAX_PATH];
1179         int idx = 1;
1180
1181         if (!SetupFindFirstLineW( parent_hinf, Version, LayoutFile, &context )) return FALSE;
1182         while (SetupGetStringFieldW( &context, idx++, filename,
1183                                      sizeof(filename)/sizeof(WCHAR), NULL ))
1184         {
1185             child_hinf = SetupOpenInfFileW( filename, NULL, INF_STYLE_WIN4, error );
1186             if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE;
1187             append_inf_file( parent_hinf, child_hinf );
1188             TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(filename), child_hinf );
1189         }
1190         return TRUE;
1191     }
1192     child_hinf = SetupOpenInfFileW( name, NULL, INF_STYLE_WIN4, error );
1193     if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE;
1194     append_inf_file( parent_hinf, child_hinf );
1195     TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(name), child_hinf );
1196     return TRUE;
1197 }
1198
1199
1200 /***********************************************************************
1201  *            SetupOpenMasterInf   (SETUPAPI.@)
1202  */
1203 HINF WINAPI SetupOpenMasterInf( VOID )
1204 {
1205     static const WCHAR Layout[] = {'\\','i','n','f','\\', 'l', 'a', 'y', 'o', 'u', 't', '.', 'i', 'n', 'f', 0};
1206     WCHAR Buffer[MAX_PATH];
1207
1208     GetWindowsDirectoryW( Buffer, MAX_PATH );
1209     strcatW( Buffer, Layout );
1210     return SetupOpenInfFileW( Buffer, NULL, INF_STYLE_WIN4, NULL);
1211 }
1212
1213
1214
1215 /***********************************************************************
1216  *            SetupCloseInfFile   (SETUPAPI.@)
1217  */
1218 void WINAPI SetupCloseInfFile( HINF hinf )
1219 {
1220     struct inf_file *file = hinf;
1221     unsigned int i;
1222
1223     for (i = 0; i < file->nb_sections; i++) HeapFree( GetProcessHeap(), 0, file->sections[i] );
1224     HeapFree( GetProcessHeap(), 0, file->filename );
1225     HeapFree( GetProcessHeap(), 0, file->sections );
1226     HeapFree( GetProcessHeap(), 0, file->fields );
1227     HeapFree( GetProcessHeap(), 0, file->strings );
1228     HeapFree( GetProcessHeap(), 0, file );
1229 }
1230
1231
1232 /***********************************************************************
1233  *            SetupGetLineCountA   (SETUPAPI.@)
1234  */
1235 LONG WINAPI SetupGetLineCountA( HINF hinf, PCSTR name )
1236 {
1237     UNICODE_STRING sectionW;
1238     LONG ret = -1;
1239
1240     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, name ))
1241         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1242     else
1243     {
1244         ret = SetupGetLineCountW( hinf, sectionW.Buffer );
1245         RtlFreeUnicodeString( &sectionW );
1246     }
1247     return ret;
1248 }
1249
1250
1251 /***********************************************************************
1252  *            SetupGetLineCountW   (SETUPAPI.@)
1253  */
1254 LONG WINAPI SetupGetLineCountW( HINF hinf, PCWSTR section )
1255 {
1256     struct inf_file *file = hinf;
1257     int section_index;
1258     LONG ret = -1;
1259
1260     for (file = hinf; file; file = file->next)
1261     {
1262         if ((section_index = find_section( file, section )) == -1) continue;
1263         if (ret == -1) ret = 0;
1264         ret += file->sections[section_index]->nb_lines;
1265     }
1266     TRACE( "(%p,%s) returning %ld\n", hinf, debugstr_w(section), ret );
1267     SetLastError( (ret == -1) ? ERROR_SECTION_NOT_FOUND : 0 );
1268     return ret;
1269 }
1270
1271
1272 /***********************************************************************
1273  *            SetupGetLineByIndexA   (SETUPAPI.@)
1274  */
1275 BOOL WINAPI SetupGetLineByIndexA( HINF hinf, PCSTR section, DWORD index, INFCONTEXT *context )
1276 {
1277     UNICODE_STRING sectionW;
1278     BOOL ret = FALSE;
1279
1280     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1281         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1282     else
1283     {
1284         ret = SetupGetLineByIndexW( hinf, sectionW.Buffer, index, context );
1285         RtlFreeUnicodeString( &sectionW );
1286     }
1287     return ret;
1288 }
1289
1290
1291 /***********************************************************************
1292  *            SetupGetLineByIndexW   (SETUPAPI.@)
1293  */
1294 BOOL WINAPI SetupGetLineByIndexW( HINF hinf, PCWSTR section, DWORD index, INFCONTEXT *context )
1295 {
1296     struct inf_file *file = hinf;
1297     int section_index;
1298
1299     SetLastError( ERROR_SECTION_NOT_FOUND );
1300     for (file = hinf; file; file = file->next)
1301     {
1302         if ((section_index = find_section( file, section )) == -1) continue;
1303         SetLastError( ERROR_LINE_NOT_FOUND );
1304         if (index < file->sections[section_index]->nb_lines)
1305         {
1306             context->Inf        = hinf;
1307             context->CurrentInf = file;
1308             context->Section    = section_index;
1309             context->Line       = index;
1310             SetLastError( 0 );
1311             TRACE( "(%p,%s): returning %d/%ld\n",
1312                    hinf, debugstr_w(section), section_index, index );
1313             return TRUE;
1314         }
1315         index -= file->sections[section_index]->nb_lines;
1316     }
1317     TRACE( "(%p,%s) not found\n", hinf, debugstr_w(section) );
1318     return FALSE;
1319 }
1320
1321
1322 /***********************************************************************
1323  *            SetupFindFirstLineA   (SETUPAPI.@)
1324  */
1325 BOOL WINAPI SetupFindFirstLineA( HINF hinf, PCSTR section, PCSTR key, INFCONTEXT *context )
1326 {
1327     UNICODE_STRING sectionW, keyW;
1328     BOOL ret = FALSE;
1329
1330     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1331     {
1332         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1333         return FALSE;
1334     }
1335
1336     if (!key) ret = SetupFindFirstLineW( hinf, sectionW.Buffer, NULL, context );
1337     else
1338     {
1339         if (RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
1340         {
1341             ret = SetupFindFirstLineW( hinf, sectionW.Buffer, keyW.Buffer, context );
1342             RtlFreeUnicodeString( &keyW );
1343         }
1344         else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1345     }
1346     RtlFreeUnicodeString( &sectionW );
1347     return ret;
1348 }
1349
1350
1351 /***********************************************************************
1352  *            SetupFindFirstLineW   (SETUPAPI.@)
1353  */
1354 BOOL WINAPI SetupFindFirstLineW( HINF hinf, PCWSTR section, PCWSTR key, INFCONTEXT *context )
1355 {
1356     struct inf_file *file;
1357     int section_index;
1358
1359     SetLastError( ERROR_SECTION_NOT_FOUND );
1360     for (file = hinf; file; file = file->next)
1361     {
1362         if ((section_index = find_section( file, section )) == -1) continue;
1363         if (key)
1364         {
1365             INFCONTEXT ctx;
1366             ctx.Inf        = hinf;
1367             ctx.CurrentInf = file;
1368             ctx.Section    = section_index;
1369             ctx.Line       = -1;
1370             return SetupFindNextMatchLineW( &ctx, key, context );
1371         }
1372         SetLastError( ERROR_LINE_NOT_FOUND );  /* found at least one section */
1373         if (file->sections[section_index]->nb_lines)
1374         {
1375             context->Inf        = hinf;
1376             context->CurrentInf = file;
1377             context->Section    = section_index;
1378             context->Line       = 0;
1379             SetLastError( 0 );
1380             TRACE( "(%p,%s,%s): returning %d/0\n",
1381                    hinf, debugstr_w(section), debugstr_w(key), section_index );
1382             return TRUE;
1383         }
1384     }
1385     TRACE( "(%p,%s,%s): not found\n", hinf, debugstr_w(section), debugstr_w(key) );
1386     return FALSE;
1387 }
1388
1389
1390 /***********************************************************************
1391  *            SetupFindNextLine   (SETUPAPI.@)
1392  */
1393 BOOL WINAPI SetupFindNextLine( PINFCONTEXT context_in, PINFCONTEXT context_out )
1394 {
1395     struct inf_file *file = context_in->CurrentInf;
1396     struct section *section;
1397
1398     if (context_in->Section >= file->nb_sections) goto error;
1399
1400     section = file->sections[context_in->Section];
1401     if (context_in->Line+1 < section->nb_lines)
1402     {
1403         if (context_out != context_in) *context_out = *context_in;
1404         context_out->Line++;
1405         SetLastError( 0 );
1406         return TRUE;
1407     }
1408
1409     /* now search the appended files */
1410
1411     for (file = file->next; file; file = file->next)
1412     {
1413         int section_index = find_section( file, section->name );
1414         if (section_index == -1) continue;
1415         if (file->sections[section_index]->nb_lines)
1416         {
1417             context_out->Inf        = context_in->Inf;
1418             context_out->CurrentInf = file;
1419             context_out->Section    = section_index;
1420             context_out->Line       = 0;
1421             SetLastError( 0 );
1422             return TRUE;
1423         }
1424     }
1425  error:
1426     SetLastError( ERROR_LINE_NOT_FOUND );
1427     return FALSE;
1428 }
1429
1430
1431 /***********************************************************************
1432  *            SetupFindNextMatchLineA   (SETUPAPI.@)
1433  */
1434 BOOL WINAPI SetupFindNextMatchLineA( PINFCONTEXT context_in, PCSTR key,
1435                                      PINFCONTEXT context_out )
1436 {
1437     UNICODE_STRING keyW;
1438     BOOL ret = FALSE;
1439
1440     if (!key) return SetupFindNextLine( context_in, context_out );
1441
1442     if (!RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
1443         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1444     else
1445     {
1446         ret = SetupFindNextMatchLineW( context_in, keyW.Buffer, context_out );
1447         RtlFreeUnicodeString( &keyW );
1448     }
1449     return ret;
1450 }
1451
1452
1453 /***********************************************************************
1454  *            SetupFindNextMatchLineW   (SETUPAPI.@)
1455  */
1456 BOOL WINAPI SetupFindNextMatchLineW( PINFCONTEXT context_in, PCWSTR key,
1457                                      PINFCONTEXT context_out )
1458 {
1459     struct inf_file *file = context_in->CurrentInf;
1460     struct section *section;
1461     struct line *line;
1462     unsigned int i;
1463
1464     if (!key) return SetupFindNextLine( context_in, context_out );
1465
1466     if (context_in->Section >= file->nb_sections) goto error;
1467
1468     section = file->sections[context_in->Section];
1469
1470     for (i = context_in->Line+1, line = &section->lines[i]; i < section->nb_lines; i++, line++)
1471     {
1472         if (line->key_field == -1) continue;
1473         if (!strcmpiW( key, file->fields[line->key_field].text ))
1474         {
1475             if (context_out != context_in) *context_out = *context_in;
1476             context_out->Line = i;
1477             SetLastError( 0 );
1478             TRACE( "(%p,%s,%s): returning %d\n",
1479                    file, debugstr_w(section->name), debugstr_w(key), i );
1480             return TRUE;
1481         }
1482     }
1483
1484     /* now search the appended files */
1485
1486     for (file = file->next; file; file = file->next)
1487     {
1488         int section_index = find_section( file, section->name );
1489         if (section_index == -1) continue;
1490         section = file->sections[section_index];
1491         for (i = 0, line = section->lines; i < section->nb_lines; i++, line++)
1492         {
1493             if (line->key_field == -1) continue;
1494             if (!strcmpiW( key, file->fields[line->key_field].text ))
1495             {
1496                 context_out->Inf        = context_in->Inf;
1497                 context_out->CurrentInf = file;
1498                 context_out->Section    = section_index;
1499                 context_out->Line       = i;
1500                 SetLastError( 0 );
1501                 TRACE( "(%p,%s,%s): returning %d/%d\n",
1502                        file, debugstr_w(section->name), debugstr_w(key), section_index, i );
1503                 return TRUE;
1504             }
1505         }
1506     }
1507     TRACE( "(%p,%s,%s): not found\n",
1508            context_in->CurrentInf, debugstr_w(section->name), debugstr_w(key) );
1509  error:
1510     SetLastError( ERROR_LINE_NOT_FOUND );
1511     return FALSE;
1512 }
1513
1514
1515 /***********************************************************************
1516  *              SetupGetLineTextW    (SETUPAPI.@)
1517  */
1518 BOOL WINAPI SetupGetLineTextW( PINFCONTEXT context, HINF hinf, PCWSTR section_name,
1519                                PCWSTR key_name, PWSTR buffer, DWORD size, PDWORD required )
1520 {
1521     struct inf_file *file;
1522     struct line *line;
1523     struct field *field;
1524     int i;
1525     DWORD total = 0;
1526
1527     if (!context)
1528     {
1529         INFCONTEXT new_context;
1530         if (!SetupFindFirstLineW( hinf, section_name, key_name, &new_context )) return FALSE;
1531         file = new_context.CurrentInf;
1532         line = get_line( file, new_context.Section, new_context.Line );
1533     }
1534     else
1535     {
1536         file = context->CurrentInf;
1537         if (!(line = get_line( file, context->Section, context->Line )))
1538         {
1539             SetLastError( ERROR_LINE_NOT_FOUND );
1540             return FALSE;
1541         }
1542     }
1543
1544     for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1545         total += PARSER_string_substW( file, field->text, NULL, 0 ) + 1;
1546
1547     if (required) *required = total;
1548     if (buffer)
1549     {
1550         if (total > size)
1551         {
1552             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1553             return FALSE;
1554         }
1555         for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1556         {
1557             unsigned int len = PARSER_string_substW( file, field->text, buffer, size );
1558             if (i+1 < line->nb_fields) buffer[len] = ',';
1559             buffer += len + 1;
1560         }
1561     }
1562     return TRUE;
1563 }
1564
1565
1566 /***********************************************************************
1567  *              SetupGetLineTextA    (SETUPAPI.@)
1568  */
1569 BOOL WINAPI SetupGetLineTextA( PINFCONTEXT context, HINF hinf, PCSTR section_name,
1570                                PCSTR key_name, PSTR buffer, DWORD size, PDWORD required )
1571 {
1572     struct inf_file *file;
1573     struct line *line;
1574     struct field *field;
1575     int i;
1576     DWORD total = 0;
1577
1578     if (!context)
1579     {
1580         INFCONTEXT new_context;
1581         if (!SetupFindFirstLineA( hinf, section_name, key_name, &new_context )) return FALSE;
1582         file = new_context.CurrentInf;
1583         line = get_line( file, new_context.Section, new_context.Line );
1584     }
1585     else
1586     {
1587         file = context->CurrentInf;
1588         if (!(line = get_line( file, context->Section, context->Line )))
1589         {
1590             SetLastError( ERROR_LINE_NOT_FOUND );
1591             return FALSE;
1592         }
1593     }
1594
1595     for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1596         total += PARSER_string_substA( file, field->text, NULL, 0 ) + 1;
1597
1598     if (required) *required = total;
1599     if (buffer)
1600     {
1601         if (total > size)
1602         {
1603             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1604             return FALSE;
1605         }
1606         for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1607         {
1608             unsigned int len = PARSER_string_substA( file, field->text, buffer, size );
1609             if (i+1 < line->nb_fields) buffer[len] = ',';
1610             buffer += len + 1;
1611         }
1612     }
1613     return TRUE;
1614 }
1615
1616
1617 /***********************************************************************
1618  *              SetupGetFieldCount    (SETUPAPI.@)
1619  */
1620 DWORD WINAPI SetupGetFieldCount( PINFCONTEXT context )
1621 {
1622     struct inf_file *file = context->CurrentInf;
1623     struct line *line = get_line( file, context->Section, context->Line );
1624
1625     if (!line) return 0;
1626     return line->nb_fields;
1627 }
1628
1629
1630 /***********************************************************************
1631  *              SetupGetStringFieldA    (SETUPAPI.@)
1632  */
1633 BOOL WINAPI SetupGetStringFieldA( PINFCONTEXT context, DWORD index, PSTR buffer,
1634                                   DWORD size, PDWORD required )
1635 {
1636     struct inf_file *file = context->CurrentInf;
1637     struct field *field = get_field( file, context->Section, context->Line, index );
1638     unsigned int len;
1639
1640     SetLastError(0);
1641     if (!field) return FALSE;
1642     len = PARSER_string_substA( file, field->text, NULL, 0 );
1643     if (required) *required = len + 1;
1644     if (buffer)
1645     {
1646         if (size <= len)
1647         {
1648             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1649             return FALSE;
1650         }
1651         PARSER_string_substA( file, field->text, buffer, size );
1652
1653         TRACE( "context %p/%p/%d/%d index %ld returning %s\n",
1654                context->Inf, context->CurrentInf, context->Section, context->Line,
1655                index, debugstr_a(buffer) );
1656     }
1657     return TRUE;
1658 }
1659
1660
1661 /***********************************************************************
1662  *              SetupGetStringFieldW    (SETUPAPI.@)
1663  */
1664 BOOL WINAPI SetupGetStringFieldW( PINFCONTEXT context, DWORD index, PWSTR buffer,
1665                                   DWORD size, PDWORD required )
1666 {
1667     struct inf_file *file = context->CurrentInf;
1668     struct field *field = get_field( file, context->Section, context->Line, index );
1669     unsigned int len;
1670
1671     SetLastError(0);
1672     if (!field) return FALSE;
1673     len = PARSER_string_substW( file, field->text, NULL, 0 );
1674     if (required) *required = len + 1;
1675     if (buffer)
1676     {
1677         if (size <= len)
1678         {
1679             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1680             return FALSE;
1681         }
1682         PARSER_string_substW( file, field->text, buffer, size );
1683
1684         TRACE( "context %p/%p/%d/%d index %ld returning %s\n",
1685                context->Inf, context->CurrentInf, context->Section, context->Line,
1686                index, debugstr_w(buffer) );
1687     }
1688     return TRUE;
1689 }
1690
1691
1692 /***********************************************************************
1693  *              SetupGetIntField    (SETUPAPI.@)
1694  */
1695 BOOL WINAPI SetupGetIntField( PINFCONTEXT context, DWORD index, PINT result )
1696 {
1697     char localbuff[20];
1698     char *end, *buffer = localbuff;
1699     DWORD required;
1700     INT res;
1701     BOOL ret = FALSE;
1702
1703     if (!SetupGetStringFieldA( context, index, localbuff, sizeof(localbuff), &required ))
1704     {
1705         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
1706         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required ))) return FALSE;
1707         if (!SetupGetStringFieldA( context, index, buffer, required, NULL )) goto done;
1708     }
1709     res = strtol( buffer, &end, 0 );
1710     if (end != buffer && !*end)
1711     {
1712         *result = res;
1713         ret = TRUE;
1714     }
1715     else SetLastError( ERROR_INVALID_DATA );
1716
1717  done:
1718     if (buffer != localbuff) HeapFree( GetProcessHeap(), 0, buffer );
1719     return ret;
1720 }
1721
1722
1723 /***********************************************************************
1724  *              SetupGetBinaryField    (SETUPAPI.@)
1725  */
1726 BOOL WINAPI SetupGetBinaryField( PINFCONTEXT context, DWORD index, BYTE *buffer,
1727                                  DWORD size, LPDWORD required )
1728 {
1729     struct inf_file *file = context->CurrentInf;
1730     struct line *line = get_line( file, context->Section, context->Line );
1731     struct field *field;
1732     int i;
1733
1734     if (!line)
1735     {
1736         SetLastError( ERROR_LINE_NOT_FOUND );
1737         return FALSE;
1738     }
1739     if (!index || index > line->nb_fields)
1740     {
1741         SetLastError( ERROR_INVALID_PARAMETER );
1742         return FALSE;
1743     }
1744     index--;  /* fields start at 0 */
1745     if (required) *required = line->nb_fields - index;
1746     if (!buffer) return TRUE;
1747     if (size < line->nb_fields - index)
1748     {
1749         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1750         return FALSE;
1751     }
1752     field = &file->fields[line->first_field + index];
1753     for (i = index; i < line->nb_fields; i++, field++)
1754     {
1755         const WCHAR *p;
1756         DWORD value = 0;
1757         for (p = field->text; *p && isxdigitW(*p); p++)
1758         {
1759             if ((value <<= 4) > 255)
1760             {
1761                 SetLastError( ERROR_INVALID_DATA );
1762                 return FALSE;
1763             }
1764             if (*p <= '9') value |= (*p - '0');
1765             else value |= (tolowerW(*p) - 'a' + 10);
1766         }
1767         buffer[i - index] = value;
1768     }
1769     if (TRACE_ON(setupapi))
1770     {
1771         TRACE( "%p/%p/%d/%d index %ld returning",
1772                context->Inf, context->CurrentInf, context->Section, context->Line, index );
1773         for (i = index; i < line->nb_fields; i++) TRACE( " %02x", buffer[i - index] );
1774         TRACE( "\n" );
1775     }
1776     return TRUE;
1777 }
1778
1779
1780 /***********************************************************************
1781  *              SetupGetMultiSzFieldA    (SETUPAPI.@)
1782  */
1783 BOOL WINAPI SetupGetMultiSzFieldA( PINFCONTEXT context, DWORD index, PSTR buffer,
1784                                    DWORD size, LPDWORD required )
1785 {
1786     struct inf_file *file = context->CurrentInf;
1787     struct line *line = get_line( file, context->Section, context->Line );
1788     struct field *field;
1789     unsigned int len;
1790     int i;
1791     DWORD total = 1;
1792
1793     if (!line)
1794     {
1795         SetLastError( ERROR_LINE_NOT_FOUND );
1796         return FALSE;
1797     }
1798     if (!index || index > line->nb_fields)
1799     {
1800         SetLastError( ERROR_INVALID_PARAMETER );
1801         return FALSE;
1802     }
1803     index--;  /* fields start at 0 */
1804     field = &file->fields[line->first_field + index];
1805     for (i = index; i < line->nb_fields; i++, field++)
1806     {
1807         if (!(len = PARSER_string_substA( file, field->text, NULL, 0 ))) break;
1808         total += len + 1;
1809     }
1810
1811     if (required) *required = total;
1812     if (!buffer) return TRUE;
1813     if (total > size)
1814     {
1815         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1816         return FALSE;
1817     }
1818     field = &file->fields[line->first_field + index];
1819     for (i = index; i < line->nb_fields; i++, field++)
1820     {
1821         if (!(len = PARSER_string_substA( file, field->text, buffer, size ))) break;
1822         buffer += len + 1;
1823     }
1824     *buffer = 0;  /* add final null */
1825     return TRUE;
1826 }
1827
1828
1829 /***********************************************************************
1830  *              SetupGetMultiSzFieldW    (SETUPAPI.@)
1831  */
1832 BOOL WINAPI SetupGetMultiSzFieldW( PINFCONTEXT context, DWORD index, PWSTR buffer,
1833                                    DWORD size, LPDWORD required )
1834 {
1835     struct inf_file *file = context->CurrentInf;
1836     struct line *line = get_line( file, context->Section, context->Line );
1837     struct field *field;
1838     unsigned int len;
1839     int i;
1840     DWORD total = 1;
1841
1842     if (!line)
1843     {
1844         SetLastError( ERROR_LINE_NOT_FOUND );
1845         return FALSE;
1846     }
1847     if (!index || index > line->nb_fields)
1848     {
1849         SetLastError( ERROR_INVALID_PARAMETER );
1850         return FALSE;
1851     }
1852     index--;  /* fields start at 0 */
1853     field = &file->fields[line->first_field + index];
1854     for (i = index; i < line->nb_fields; i++, field++)
1855     {
1856         if (!(len = PARSER_string_substW( file, field->text, NULL, 0 ))) break;
1857         total += len + 1;
1858     }
1859
1860     if (required) *required = total;
1861     if (!buffer) return TRUE;
1862     if (total > size)
1863     {
1864         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1865         return FALSE;
1866     }
1867     field = &file->fields[line->first_field + index];
1868     for (i = index; i < line->nb_fields; i++, field++)
1869     {
1870         if (!(len = PARSER_string_substW( file, field->text, buffer, size ))) break;
1871         buffer += len + 1;
1872     }
1873     *buffer = 0;  /* add final null */
1874     return TRUE;
1875 }