#include "setupapi_private.h"
#include <ndk/obfuncs.h>

Include dependency graph for parser.c:

Classes
struct	field

struct	line

struct	section

struct	inf_file

struct	parser

Macros
#define	CONTROL_Z '\x1a'

#define	MAX_SECTION_NAME_LEN 255

#define	MAX_FIELD_LEN 511 /* larger fields get silently truncated */

#define	MAX_STRING_LEN (MAX_INF_STRING_LENGTH+1)

Typedefs
typedef const WCHAR (	parser_state_func) (struct parser parser, const WCHAR pos)

Enumerations
enum	parser_state { HEADER, PARSE_WIN31_LINE, LINE_START, KEY_NAME, DELETE_KEY, DEFAULT_VALUE_NAME, QUOTED_VALUE_NAME, DATA_START, DELETE_VALUE, DATA_TYPE, STRING_DATA, DWORD_DATA, HEX_DATA, EOL_BACKSLASH, HEX_MULTILINE, UNKNOWN_DATA, SET_VALUE, NB_PARSER_STATES, LINE_START, SECTION_NAME, KEY_NAME, VALUE_NAME, EOL_BACKSLASH, QUOTES, LEADING_SPACES, TRAILING_SPACES, COMMENT, NB_PARSER_STATES, LINE_START, SECTION_NAME, KEY_NAME, VALUE_NAME, EOL_BACKSLASH, QUOTES, LEADING_SPACES, TRAILING_SPACES, COMMENT, NB_PARSER_STATES, LINE_START, SECTION_NAME, KEY_NAME, VALUE_NAME, EOL_BACKSLASH, QUOTES, LEADING_SPACES, TRAILING_SPACES, COMMENT, NB_PARSER_STATES }

Functions
static const WCHAR *	line_start_state (struct parser parser, const WCHAR pos)

static const WCHAR *	section_name_state (struct parser parser, const WCHAR pos)

static const WCHAR *	key_name_state (struct parser parser, const WCHAR pos)

static const WCHAR *	value_name_state (struct parser parser, const WCHAR pos)

static const WCHAR *	eol_backslash_state (struct parser parser, const WCHAR pos)

static const WCHAR *	quotes_state (struct parser parser, const WCHAR pos)

static const WCHAR *	leading_spaces_state (struct parser parser, const WCHAR pos)

static const WCHAR *	trailing_spaces_state (struct parser parser, const WCHAR pos)

static const WCHAR *	comment_state (struct parser parser, const WCHAR pos)

static void *	grow_array (void array, unsigned int count, size_t elem)

static const WCHAR *	get_inf_dir (const struct inf_file file, unsigned int len)

static int	find_section (const struct inf_file file, const WCHAR name)

static struct line *	find_line (struct inf_file file, int section_index, const WCHAR name)

static int	add_section (struct inf_file file, const WCHAR name)

static struct line *	add_line (struct inf_file *file, int section_index)

static struct line *	get_line (struct inf_file *file, unsigned int section_index, unsigned int line_index)

static struct field *	get_field (struct inf_file *file, int section_index, int line_index, int field_index)

static struct field *	add_field (struct inf_file file, const WCHAR text)

static const WCHAR *	get_dirid_subst (const struct inf_file file, int dirid, unsigned int len)

static const WCHAR *	get_string_subst (const struct inf_file file, const WCHAR str, unsigned int *len, BOOL no_trailing_slash)

static unsigned int	PARSER_string_substW (const struct inf_file file, const WCHAR text, WCHAR *buffer, unsigned int size)

static unsigned int	PARSER_string_substA (const struct inf_file file, const WCHAR text, char *buffer, unsigned int size)

static WCHAR *	push_string (struct inf_file file, const WCHAR string)

static void	push_state (struct parser *parser, enum parser_state state)

static void	pop_state (struct parser *parser)

static enum parser_state	set_state (struct parser *parser, enum parser_state state)

static BOOL	is_eof (const struct parser parser, const WCHAR ptr)

static BOOL	is_eol (const struct parser parser, const WCHAR ptr)

static int	push_token (struct parser parser, const WCHAR pos)

static int	add_section_from_token (struct parser *parser)

static struct field *	add_field_from_token (struct parser *parser, BOOL is_key)

static void	close_current_line (struct parser *parser)

static void	free_inf_file (struct inf_file *file)

static DWORD	parse_buffer (struct inf_file file, const WCHAR buffer, const WCHAR end, UINT error_line)

static void	append_inf_file (struct inf_file parent, struct inf_file child)

static struct inf_file *	parse_file (HANDLE handle, UINT *error_line, DWORD style)

const WCHAR *	PARSER_get_inf_filename (HINF hinf)

WCHAR *	PARSER_get_src_root (HINF hinf)

WCHAR *	PARSER_get_dest_dir (INFCONTEXT *context)

HINF WINAPI	SetupOpenInfFileA (PCSTR name, PCSTR class, DWORD style, UINT *error)

static BOOL	PARSER_GetInfClassW (IN HINF hInf, OUT LPGUID ClassGuid, OUT PWSTR ClassName, IN DWORD ClassNameSize, OUT PDWORD RequiredSize OPTIONAL)

HINF WINAPI	SetupOpenInfFileW (PCWSTR name, PCWSTR class, DWORD style, UINT *error)

BOOL WINAPI	SetupOpenAppendInfFileA (PCSTR name, HINF parent_hinf, UINT *error)

BOOL WINAPI	SetupOpenAppendInfFileW (PCWSTR name, HINF parent_hinf, UINT *error)

HINF WINAPI	SetupOpenMasterInf (VOID)

void WINAPI	SetupCloseInfFile (HINF hinf)

BOOL WINAPI	SetupEnumInfSectionsA (HINF hinf, UINT index, PSTR buffer, DWORD size, DWORD *need)

BOOL WINAPI	SetupEnumInfSectionsW (HINF hinf, UINT index, PWSTR buffer, DWORD size, DWORD *need)

LONG WINAPI	SetupGetLineCountA (HINF hinf, PCSTR name)

LONG WINAPI	SetupGetLineCountW (HINF hinf, PCWSTR section)

BOOL WINAPI	SetupGetLineByIndexA (HINF hinf, PCSTR section, DWORD index, INFCONTEXT *context)

BOOL WINAPI	SetupGetLineByIndexW (HINF hinf, PCWSTR section, DWORD index, INFCONTEXT *context)

BOOL WINAPI	SetupFindFirstLineA (HINF hinf, PCSTR section, PCSTR key, INFCONTEXT *context)

BOOL WINAPI	SetupFindFirstLineW (HINF hinf, PCWSTR section, PCWSTR key, INFCONTEXT *context)

BOOL WINAPI	SetupFindNextLine (PINFCONTEXT context_in, PINFCONTEXT context_out)

BOOL WINAPI	SetupFindNextMatchLineA (PINFCONTEXT context_in, PCSTR key, PINFCONTEXT context_out)

BOOL WINAPI	SetupFindNextMatchLineW (PINFCONTEXT context_in, PCWSTR key, PINFCONTEXT context_out)

BOOL WINAPI	SetupGetLineTextW (PINFCONTEXT context, HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR buffer, DWORD size, PDWORD required)

BOOL WINAPI	SetupGetLineTextA (PINFCONTEXT context, HINF hinf, PCSTR section_name, PCSTR key_name, PSTR buffer, DWORD size, PDWORD required)

DWORD WINAPI	SetupGetFieldCount (PINFCONTEXT context)

BOOL WINAPI	SetupGetStringFieldA (PINFCONTEXT context, DWORD index, PSTR buffer, DWORD size, PDWORD required)

BOOL WINAPI	SetupGetStringFieldW (PINFCONTEXT context, DWORD index, PWSTR buffer, DWORD size, PDWORD required)

BOOL WINAPI	SetupGetIntField (PINFCONTEXT context, DWORD index, PINT result)

BOOL WINAPI	SetupGetBinaryField (PINFCONTEXT context, DWORD index, BYTE *buffer, DWORD size, LPDWORD required)

BOOL WINAPI	SetupGetMultiSzFieldA (PINFCONTEXT context, DWORD index, PSTR buffer, DWORD size, LPDWORD required)

BOOL WINAPI	SetupGetMultiSzFieldW (PINFCONTEXT context, DWORD index, PWSTR buffer, DWORD size, LPDWORD required)

LPCWSTR WINAPI	pSetupGetField (PINFCONTEXT context, DWORD index)

BOOL WINAPI	SetupGetInfFileListW (IN PCWSTR DirectoryPath OPTIONAL, IN DWORD InfStyle, IN OUT PWSTR ReturnBuffer OPTIONAL, IN DWORD ReturnBufferSize OPTIONAL, OUT PDWORD RequiredSize OPTIONAL)

BOOL WINAPI	SetupGetInfFileListA (IN PCSTR DirectoryPath OPTIONAL, IN DWORD InfStyle, IN OUT PSTR ReturnBuffer OPTIONAL, IN DWORD ReturnBufferSize OPTIONAL, OUT PDWORD RequiredSize OPTIONAL)

BOOL WINAPI	SetupDiGetINFClassW (IN PCWSTR InfName, OUT LPGUID ClassGuid, OUT PWSTR ClassName, IN DWORD ClassNameSize, OUT PDWORD RequiredSize OPTIONAL)

BOOL WINAPI	SetupDiGetINFClassA (IN PCSTR InfName, OUT LPGUID ClassGuid, OUT PSTR ClassName, IN DWORD ClassNameSize, OUT PDWORD RequiredSize OPTIONAL)

BOOL	EnumerateSectionsStartingWith (IN HINF hInf, IN LPCWSTR pStr, IN FIND_CALLBACK Callback, IN PVOID Context)

Variables
static const WCHAR	BackSlash [] = {'\\',0}

static const WCHAR	Class [] = {'C','l','a','s','s',0}

static const WCHAR	ClassGUID [] = {'C','l','a','s','s','G','U','I','D',0}

static const WCHAR	InfDirectory [] = {'i','n','f','\\',0}

static const WCHAR	InfFileSpecification [] = {'*','.','i','n','f',0}

static const parser_state_func	parser_funcs [NB_PARSER_STATES]

static const WCHAR	Version [] = {'V','e','r','s','i','o','n',0}

static const WCHAR	Signature [] = {'S','i','g','n','a','t','u','r','e',0}

static const WCHAR	Chicago [] = {'$','C','h','i','c','a','g','o','$',0}

static const WCHAR	WindowsNT [] = {'$','W','i','n','d','o','w','s',' ','N','T','$',0}

static const WCHAR	Windows95 [] = {'$','W','i','n','d','o','w','s',' ','9','5','$',0}

static const WCHAR	LayoutFile [] = {'L','a','y','o','u','t','F','i','l','e',0}

Macro Definition Documentation

◆ CONTROL_Z

#define CONTROL_Z '\x1a'

Definition at line 35 of file parser.c.

◆ MAX_FIELD_LEN

#define MAX_FIELD_LEN 511 /* larger fields get silently truncated */

Definition at line 37 of file parser.c.

◆ MAX_SECTION_NAME_LEN

#define MAX_SECTION_NAME_LEN 255

Definition at line 36 of file parser.c.

◆ MAX_STRING_LEN

#define MAX_STRING_LEN (MAX_INF_STRING_LENGTH+1)

Definition at line 39 of file parser.c.

Typedef Documentation

◆ parser_state_func

typedef const WCHAR*(* parser_state_func) (struct parser *parser, const WCHAR *pos)

Definition at line 112 of file parser.c.

Enumeration Type Documentation

◆ parser_state

enum parser_state

Enumerator
HEADER
PARSE_WIN31_LINE
LINE_START
KEY_NAME
DELETE_KEY
DEFAULT_VALUE_NAME
QUOTED_VALUE_NAME
DATA_START
DELETE_VALUE
DATA_TYPE
STRING_DATA
DWORD_DATA
HEX_DATA
EOL_BACKSLASH
HEX_MULTILINE
UNKNOWN_DATA
SET_VALUE
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES

Definition at line 80 of file parser.c.

 {
     LINE_START,      /* at beginning of a line */
     SECTION_NAME,    /* parsing a section name */
     KEY_NAME,        /* parsing a key name */
     VALUE_NAME,      /* parsing a value name */
     EOL_BACKSLASH,   /* backslash at end of line */
     QUOTES,          /* inside quotes */
     LEADING_SPACES,  /* leading spaces */
     TRAILING_SPACES, /* trailing spaces */
     COMMENT,         /* inside a comment */
     NB_PARSER_STATES
 };

Function Documentation

◆ add_field()

static struct field* add_field	(	struct inf_file *	file,
		const WCHAR *	text
	)

static

Definition at line 280 of file parser.c.

 {
     struct field *field;
 
     if (file->nb_fields >= file->alloc_fields)
     {
         if (!(file->fields = grow_array( file->fields, &file->alloc_fields,
                                          sizeof(file->fields[0]) ))) return NULL;
     }
     field = &file->fields[file->nb_fields++];
     field->text = text;
     return field;
 }

Referenced by add_field_from_token().

◆ add_field_from_token()

static struct field* add_field_from_token	(	struct parser *	parser,
		BOOL	is_key
	)

static

Definition at line 566 of file parser.c.

 {
     struct field *field;
     WCHAR *text;
 
     if (!parser->line)  /* need to start a new line */
     {
         if (parser->cur_section == -1)  /* got a line before the first section */
         {
             parser->error = ERROR_EXPECTED_SECTION_NAME;
             return NULL;
         }
         if (!(parser->line = add_line( parser->file, parser->cur_section ))) goto error;
     }
     else ASSERT(!is_key);
 
     text = push_string( parser->file, parser->token );
     if ((field = add_field( parser->file, text )))
     {
         if (!is_key) parser->line->nb_fields++;
         else
         {
             /* replace first field by key field */
             parser->line->key_field = parser->line->first_field;
             parser->line->first_field++;
         }
         parser->token_len = 0;
         return field;
     }
  error:
     parser->error = ERROR_NOT_ENOUGH_MEMORY;
     return NULL;
 }

Referenced by key_name_state(), and value_name_state().

◆ add_line()

static struct line* add_line	(	struct inf_file *	file,
		int	section_index
	)

static

Definition at line 225 of file parser.c.

 {
     struct section *section;
     struct line *line;
 
     ASSERT( section_index >= 0 && section_index < file->nb_sections );
 
     section = file->sections[section_index];
     if (section->nb_lines == section->alloc_lines)  /* need to grow the section */
     {
         int size = sizeof(*section) - sizeof(section->lines) + 2*section->alloc_lines*sizeof(*line);
         if (!(section = HeapReAlloc( GetProcessHeap(), 0, section, size ))) return NULL;
         section->alloc_lines *= 2;
         file->sections[section_index] = section;
     }
     line = &section->lines[section->nb_lines++];
     line->first_field = file->nb_fields;
     line->nb_fields   = 0;
     line->key_field   = -1;
     return line;
 }

Referenced by add_field_from_token().

◆ add_section()

static int add_section	(	struct inf_file *	file,
		const WCHAR *	name
	)

static

Definition at line 206 of file parser.c.

 {
     struct section *section;
 
     if (file->nb_sections >= file->alloc_sections)
     {
         if (!(file->sections = grow_array( file->sections, &file->alloc_sections,
                                            sizeof(file->sections[0]) ))) return -1;
     }
     if (!(section = HeapAlloc( GetProcessHeap(), 0, sizeof(*section) ))) return -1;
     section->name        = name;
     section->nb_lines    = 0;
     section->alloc_lines = sizeof(section->lines)/sizeof(section->lines[0]);
     file->sections[file->nb_sections] = section;
     return file->nb_sections++;
 }

Referenced by add_section_from_token(), and hhp_reader::hhp_reader().

◆ add_section_from_token()

static int add_section_from_token ( struct parser * parser )

static

Definition at line 540 of file parser.c.

 {
     int section_index;
 
     if (parser->token_len > MAX_SECTION_NAME_LEN)
     {
         parser->error = ERROR_SECTION_NAME_TOO_LONG;
         return -1;
     }
     if ((section_index = find_section( parser->file, parser->token )) == -1)
     {
         /* need to create a new one */
         const WCHAR *name = push_string( parser->file, parser->token );
         if ((section_index = add_section( parser->file, name )) == -1)
         {
             parser->error = ERROR_NOT_ENOUGH_MEMORY;
             return -1;
         }
     }
     parser->token_len = 0;
     parser->cur_section = section_index;
     return section_index;
 }

Referenced by section_name_state().

◆ append_inf_file()

static void append_inf_file	(	struct inf_file *	parent,
		struct inf_file *	child
	)

static

Definition at line 970 of file parser.c.

 {
     struct inf_file **ppnext = &parent->next;
     child->next = NULL;
 
     for (;;)
     {
         struct inf_file *next = InterlockedCompareExchangePointer( (void **)ppnext, child, NULL );
         if (!next) return;
         ppnext = &next->next;
     }
 }

Referenced by SetupOpenAppendInfFileA(), and SetupOpenAppendInfFileW().

◆ close_current_line()

static void close_current_line ( struct parser * parser )

static

Definition at line 602 of file parser.c.

 {
     struct line *cur_line = parser->line;
 
     if (cur_line)
     {
         /* if line has a single field and no key, the field is the key too */
         if (cur_line->nb_fields == 1 && cur_line->key_field == -1)
             cur_line->key_field = cur_line->first_field;
     }
     parser->line = NULL;
 }

Referenced by line_start_state().

◆ comment_state()

static const WCHAR * comment_state	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 887 of file parser.c.

 {
     const WCHAR *p = pos;
 
     while (!is_eol( parser, p )) p++;
     pop_state( parser );
     return p;
 }

◆ EnumerateSectionsStartingWith()

BOOL EnumerateSectionsStartingWith	(	IN HINF	hInf,
		IN LPCWSTR	pStr,
		IN FIND_CALLBACK	Callback,
		IN PVOID	Context
	)

Definition at line 2387 of file parser.c.

 {
     struct inf_file *file = (struct inf_file *)hInf;
     size_t len = strlenW(pStr);
     unsigned int i;
 
     for (i = 0; i < file->nb_sections; i++)
     {
         if (strncmpiW(pStr, file->sections[i]->name, len) == 0)
         {
             if (!Callback(file->sections[i]->name, Context))
                 return FALSE;
         }
     }
     return TRUE;
 }

Referenced by SetupDiGetActualSectionToInstallExW().

◆ eol_backslash_state()

static const WCHAR * eol_backslash_state	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 784 of file parser.c.

 {
     const WCHAR *p;
 
     for (p = pos; !is_eof( parser, p ); p++)
     {
         switch(*p)
         {
         case '\n':
             parser->line_pos++;
             parser->start = p + 1;
             set_state( parser, LEADING_SPACES );
             return p + 1;
         case '\\':
             continue;
         case ';':
             push_state( parser, EOL_BACKSLASH );
             set_state( parser, COMMENT );
             return p + 1;
         default:
             if (isspaceW(*p)) continue;
             push_token( parser, p );
             pop_state( parser );
             return p;
         }
     }
     parser->start = p;
     pop_state( parser );
     return p;
 }

◆ find_line()

static struct line* find_line	(	struct inf_file *	file,
		int	section_index,
		const WCHAR *	name
	)

static

Definition at line 188 of file parser.c.

 {
     struct section *section;
     struct line *line;
     unsigned int i;
 
     if (section_index < 0 || section_index >= file->nb_sections) return NULL;
     section = file->sections[section_index];
     for (i = 0, line = section->lines; i < section->nb_lines; i++, line++)
     {
         if (line->key_field == -1) continue;
         if (!strcmpiW( name, file->fields[line->key_field].text )) return line;
     }
     return NULL;
 }

Referenced by parse_file().

◆ find_section()

static int find_section	(	const struct inf_file *	file,
		const WCHAR *	name
	)

static

Definition at line 177 of file parser.c.

 {
     unsigned int i;
 
     for (i = 0; i < file->nb_sections; i++)
         if (!strcmpiW( name, file->sections[i]->name )) return i;
     return -1;
 }

Referenced by add_section_from_token(), parse_buffer(), parse_file(), SetupFindFirstLineW(), SetupFindNextLine(), SetupFindNextMatchLineW(), SetupGetLineByIndexW(), and SetupGetLineCountW().

◆ free_inf_file()

static void free_inf_file ( struct inf_file * file )

static

Definition at line 897 of file parser.c.

 {
     unsigned int i;
 
     for (i = 0; i < file->nb_sections; i++) HeapFree( GetProcessHeap(), 0, file->sections[i] );
     HeapFree( GetProcessHeap(), 0, file->filename );
     HeapFree( GetProcessHeap(), 0, file->sections );
     HeapFree( GetProcessHeap(), 0, file->fields );
     HeapFree( GetProcessHeap(), 0, file->strings );
     HeapFree( GetProcessHeap(), 0, file );
 }

Referenced by parse_file(), and SetupCloseInfFile().

◆ get_dirid_subst()

static const WCHAR* get_dirid_subst	(	const struct inf_file *	file,
		int	dirid,
		unsigned int *	len
	)

static

Definition at line 296 of file parser.c.

 {
     const WCHAR *ret;
 
     if (dirid == DIRID_SRCPATH) return get_inf_dir( file, len );
     ret = DIRID_get_string( dirid );
     if (ret) *len = strlenW(ret);
     return ret;
 }

Referenced by get_string_subst(), and PARSER_get_dest_dir().

◆ get_field()

static struct field* get_field	(	struct inf_file *	file,
		int	section_index,
		int	line_index,
		int	field_index
	)

static

Definition at line 262 of file parser.c.

 {
     struct line *line = get_line( file, section_index, line_index );
 
     if (!line) return NULL;
     if (!field_index)  /* get the key */
     {
         if (line->key_field == -1) return NULL;
         return &file->fields[line->key_field];
     }
     field_index--;
     if (field_index >= line->nb_fields) return NULL;
     return &file->fields[line->first_field + field_index];
 }

Referenced by pSetupGetField(), SetupGetStringFieldA(), and SetupGetStringFieldW().

◆ get_inf_dir()

static const WCHAR* get_inf_dir	(	const struct inf_file *	file,
		unsigned int *	len
	)

static

Definition at line 168 of file parser.c.

 {
     const WCHAR *p = strrchrW( file->filename, '\\' );
     *len = p ? (p + 1 - file->filename) : 0;
     return file->filename;
 }

Referenced by get_dirid_subst(), and PARSER_get_src_root().

◆ get_line()

static struct line* get_line	(	struct inf_file *	file,
		unsigned int	section_index,
		unsigned int	line_index
	)

inlinestatic

Definition at line 249 of file parser.c.

 {
     struct section *section;
 
     if (section_index >= file->nb_sections) return NULL;
     section = file->sections[section_index];
     if (line_index >= section->nb_lines) return NULL;
     return &section->lines[line_index];
 }

Referenced by get_field(), SetupGetBinaryField(), SetupGetFieldCount(), SetupGetLineTextA(), SetupGetLineTextW(), SetupGetMultiSzFieldA(), and SetupGetMultiSzFieldW().

◆ get_string_subst()

static const WCHAR* get_string_subst	(	const struct inf_file *	file,
		const WCHAR *	str,
		unsigned int *	len,
		BOOL	no_trailing_slash
	)

static

Definition at line 309 of file parser.c.

 {
     static const WCHAR percent = '%';
 
     struct section *strings_section;
     struct line *line;
     struct field *field;
     unsigned int i, j;
     int dirid;
     WCHAR *dirid_str, *end;
     const WCHAR *ret = NULL;
     WCHAR StringLangId[13] = {'S','t','r','i','n','g','s','.',0};
     TCHAR Lang[5];
 
     if (!*len)  /* empty string (%%) is replaced by single percent */
     {
         *len = 1;
         return &percent;
     }
     if (file->strings_section == -1) goto not_found;
     strings_section = file->sections[file->strings_section];
     for (j = 0, line = strings_section->lines; j < strings_section->nb_lines; j++, line++)
     {
         if (line->key_field == -1) continue;
         if (strncmpiW( str, file->fields[line->key_field].text, *len )) continue;
         if (!file->fields[line->key_field].text[*len]) break;
     }
     if (j == strings_section->nb_lines || !line->nb_fields) goto not_found;
     field = &file->fields[line->first_field];
     GetLocaleInfo(LOCALE_SYSTEM_DEFAULT, LOCALE_ILANGUAGE, Lang, sizeof(Lang)/sizeof(TCHAR)); // get the current system locale for translated strings
 
     strcpyW(StringLangId + 8, Lang + 2);
     // now you have e.g. Strings.07 for german neutral translations
     for (i = 0; i < file->nb_sections; i++) // search in all sections
     {
         if (!strcmpiW(file->sections[i]->name,StringLangId)) // if the section is a Strings.* section
         {
             strings_section = file->sections[i]; // select this section for further use
             for (j = 0, line = strings_section->lines; j < strings_section->nb_lines; j++, line++) // process all lines in this section
             {
                 if (line->key_field == -1) continue; // if no key then skip
                 if (strncmpiW( str, file->fields[line->key_field].text, *len )) continue; // if wrong key name, then skip
                 if (!file->fields[line->key_field].text[*len]) // if value exist
                 {
                     field = &file->fields[line->first_field]; // then extract value and
                     break; // no more search necessary
                 }
             }
         }
     }
 
     strcpyW(StringLangId + 8, Lang); // append the Language identifier from GetLocaleInfo
     // now you have e.g. Strings.0407 for german translations
     for (i = 0; i < file->nb_sections; i++) // search in all sections
     {
         if (!strcmpiW(file->sections[i]->name,StringLangId)) // if the section is a Strings.* section
         {
             strings_section = file->sections[i]; // select this section for further use
             for (j = 0, line = strings_section->lines; j < strings_section->nb_lines; j++, line++) // process all lines in this section
             {
                 if (line->key_field == -1) continue; // if no key then skip
                 if (strncmpiW( str, file->fields[line->key_field].text, *len )) continue; // if wrong key name, then skip
                 if (!file->fields[line->key_field].text[*len]) // if value exist
                 {
                     field = &file->fields[line->first_field]; // then extract value and
                     break; // no more search necessary
                 }
             }
         }
     }
     *len = strlenW( field->text ); // set length
     ret = field->text; // return the english or translated string
     return ret;
 
 
  not_found:  /* check for integer id */
     if ((dirid_str = HeapAlloc( GetProcessHeap(), 0, (*len+1) * sizeof(WCHAR) )))
     {
         memcpy( dirid_str, str, *len * sizeof(WCHAR) );
         dirid_str[*len] = 0;
         dirid = strtolW( dirid_str, &end, 10 );
         if (!*end) ret = get_dirid_subst( file, dirid, len );
         if (no_trailing_slash && ret && *len && ret[*len - 1] == '\\') *len -= 1;
         HeapFree( GetProcessHeap(), 0, dirid_str );
         return ret;
     }
     return NULL;
 }

Referenced by PARSER_string_substW().

◆ grow_array()

static void* grow_array	(	void *	array,
		unsigned int *	count,
		size_t	elem
	)

static

Definition at line 148 of file parser.c.

 {
     void *new_array;
     unsigned int new_count = *count + *count / 2;
     if (new_count < 32) new_count = 32;
 
     if (array)
     new_array = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, array, new_count * elem );
     else
     new_array = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * elem );
 
     if (new_array)
         *count = new_count;
     else
         HeapFree( GetProcessHeap(), 0, array );
     return new_array;
 }

Referenced by add_field(), and add_section().

◆ is_eof()

static BOOL is_eof	(	const struct parser *	parser,
		const WCHAR *	ptr
	)

inlinestatic

Definition at line 509 of file parser.c.

 {
     return (ptr >= parser->end || *ptr == CONTROL_Z);
 }

Referenced by eol_backslash_state(), and line_start_state().

◆ is_eol()

static BOOL is_eol	(	const struct parser *	parser,
		const WCHAR *	ptr
	)

inlinestatic

Definition at line 516 of file parser.c.

 {
     return (ptr >= parser->end || *ptr == CONTROL_Z || *ptr == '\n');
 }

Referenced by comment_state(), key_name_state(), leading_spaces_state(), quotes_state(), section_name_state(), trailing_spaces_state(), and value_name_state().

◆ key_name_state()

static const WCHAR * key_name_state	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 677 of file parser.c.

 {
     const WCHAR *p, *token_end = parser->start;
 
     for (p = pos; !is_eol( parser, p ); p++)
     {
         if (*p == ',') break;
         switch(*p)
         {
 
          case '=':
             push_token( parser, token_end );
             if (!add_field_from_token( parser, TRUE )) return NULL;
             parser->start = p + 1;
             push_state( parser, VALUE_NAME );
             set_state( parser, LEADING_SPACES );
             return p + 1;
         case ';':
             push_token( parser, token_end );
             if (!add_field_from_token( parser, FALSE )) return NULL;
             push_state( parser, LINE_START );
             set_state( parser, COMMENT );
             return p + 1;
         case '"':
             push_token( parser, p );
             parser->start = p + 1;
             push_state( parser, KEY_NAME );
             set_state( parser, QUOTES );
             return p + 1;
         case '\\':
             push_token( parser, token_end );
             parser->start = p;
             push_state( parser, KEY_NAME );
             set_state( parser, EOL_BACKSLASH );
             return p;
         default:
             if (!isspaceW(*p)) token_end = p + 1;
             else
             {
                 push_token( parser, p );
                 push_state( parser, KEY_NAME );
                 set_state( parser, TRAILING_SPACES );
                 return p;
             }
             break;
         }
     }
     push_token( parser, token_end );
     set_state( parser, VALUE_NAME );
     return p;
 }

◆ leading_spaces_state()

static const WCHAR * leading_spaces_state	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 847 of file parser.c.

 {
     const WCHAR *p;
 
     for (p = pos; !is_eol( parser, p ); p++)
     {
         if (*p == '\\')
         {
             parser->start = p;
             set_state( parser, EOL_BACKSLASH );
             return p;
         }
         if (!isspaceW(*p)) break;
     }
     parser->start = p;
     pop_state( parser );
     return p;
 }

◆ line_start_state()

static const WCHAR * line_start_state	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 617 of file parser.c.

 {
     const WCHAR *p;
 
     for (p = pos; !is_eof( parser, p ); p++)
     {
         switch(*p)
         {
         case '\n':
             parser->line_pos++;
             close_current_line( parser );
             break;
         case ';':
             push_state( parser, LINE_START );
             set_state( parser, COMMENT );
             return p + 1;
         case '[':
             parser->start = p + 1;
             set_state( parser, SECTION_NAME );
             return p + 1;
         default:
             if (isspaceW(*p)) break;
             if (parser->cur_section != -1)
             {
                 parser->start = p;
                 set_state( parser, KEY_NAME );
                 return p;
             }
             if (!parser->broken_line)
                 parser->broken_line = parser->line_pos;
             break;
         }
     }
     close_current_line( parser );
     return NULL;
 }

◆ parse_buffer()

static DWORD parse_buffer	(	struct inf_file *	file,
		const WCHAR *	buffer,
		const WCHAR *	end,
		UINT *	error_line
	)

static

Definition at line 911 of file parser.c.

 {
     static const WCHAR Strings[] = {'S','t','r','i','n','g','s',0};
 
     struct parser parser;
     const WCHAR *pos = buffer;
 
     parser.start       = buffer;
     parser.end         = end;
     parser.file        = file;
     parser.line        = NULL;
     parser.state       = LINE_START;
     parser.stack_pos   = 0;
     parser.cur_section = -1;
     parser.line_pos    = 1;
     parser.broken_line = 0;
     parser.error       = 0;
     parser.token_len   = 0;
 
     /* parser main loop */
     while (pos) pos = (parser_funcs[parser.state])( &parser, pos );
 
     /* trim excess buffer space */
     if (file->alloc_sections > file->nb_sections)
     {
         file->sections = HeapReAlloc( GetProcessHeap(), 0, file->sections,
                                       file->nb_sections * sizeof(file->sections[0]) );
         file->alloc_sections = file->nb_sections;
     }
     if (file->alloc_fields > file->nb_fields)
     {
         file->fields = HeapReAlloc( GetProcessHeap(), 0, file->fields,
                                     file->nb_fields * sizeof(file->fields[0]) );
         file->alloc_fields = file->nb_fields;
     }
     file->strings = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, file->strings,
                                  (file->string_pos - file->strings) * sizeof(WCHAR) );
 
     if (parser.error)
     {
         if (error_line) *error_line = parser.line_pos;
         return parser.error;
     }
 
     /* find the [strings] section */
     file->strings_section = find_section( file, Strings );
 
     if (file->strings_section == -1 && parser.broken_line)
     {
         if (error_line) *error_line = parser.broken_line;
         return ERROR_EXPECTED_SECTION_NAME;
     }
 
     return 0;
 }

Referenced by parse_file().

◆ parse_file()

static struct inf_file* parse_file	(	HANDLE	handle,
		UINT *	error_line,
		DWORD	style
	)

static

Definition at line 989 of file parser.c.

 {
     void *buffer;
     DWORD err = 0;
     struct inf_file *file;
 
     DWORD size = GetFileSize( handle, NULL );
     HANDLE mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, size, NULL );
     if (!mapping) return NULL;
     buffer = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, size );
     NtClose( mapping );
     if (!buffer) return NULL;
 
     if (!(file = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*file) )))
     {
         err = ERROR_NOT_ENOUGH_MEMORY;
         goto done;
     }
 
     /* we won't need more strings space than the size of the file,
      * so we can preallocate it here
      */
     if (!(file->strings = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )))
     {
         err = ERROR_NOT_ENOUGH_MEMORY;
         goto done;
     }
     file->string_pos = file->strings;
     file->strings_section = -1;
 
     if (!RtlIsTextUnicode( buffer, size, NULL ))
     {
         static const BYTE utf8_bom[3] = { 0xef, 0xbb, 0xbf };
         WCHAR *new_buff;
         UINT codepage = CP_ACP;
         UINT offset = 0;
 
         if (size > sizeof(utf8_bom) && !memcmp( buffer, utf8_bom, sizeof(utf8_bom) ))
         {
             codepage = CP_UTF8;
             offset = sizeof(utf8_bom);
         }
 
         if ((new_buff = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )))
         {
             DWORD len = MultiByteToWideChar( codepage, 0, (char *)buffer + offset,
                                              size - offset, new_buff, size );
             err = parse_buffer( file, new_buff, new_buff + len, error_line );
             HeapFree( GetProcessHeap(), 0, new_buff );
         }
     }
     else
     {
         WCHAR *new_buff = buffer;
         /* UCS-16 files should start with the Unicode BOM; we should skip it */
         if (*new_buff == 0xfeff)
             new_buff++;
         err = parse_buffer( file, new_buff, (WCHAR *)((char *)buffer + size), error_line );
     }
 
     if (!err)  /* now check signature */
     {
         int version_index = find_section( file, Version );
         if (version_index != -1)
         {
             struct line *line = find_line( file, version_index, Signature );
             if (line && line->nb_fields > 0)
             {
                 struct field *field = file->fields + line->first_field;
                 if (!strcmpiW( field->text, Chicago )) goto done;
                 if (!strcmpiW( field->text, WindowsNT )) goto done;
                 if (!strcmpiW( field->text, Windows95 )) goto done;
             }
         }
         if (error_line) *error_line = 0;
         if (style & INF_STYLE_WIN4) err = ERROR_WRONG_INF_STYLE;
     }
 
  done:
     UnmapViewOfFile( buffer );
     if (err)
     {
         if (file) free_inf_file( file );
         SetLastError( err );
         file = NULL;
     }
     return file;
 }

Referenced by SetupOpenInfFileW().

◆ PARSER_get_dest_dir()

WCHAR* PARSER_get_dest_dir ( INFCONTEXT * context )

Definition at line 1116 of file parser.c.

 {
     const WCHAR *dir;
     WCHAR *ptr, *ret;
     INT dirid;
     unsigned int len1;
     DWORD len2;
 
     if (!SetupGetIntField( context, 1, &dirid )) return NULL;
     if (!(dir = get_dirid_subst( context->Inf, dirid, &len1 ))) return NULL;
     if (!SetupGetStringFieldW( context, 2, NULL, 0, &len2 )) len2 = 0;
     if (!(ret = HeapAlloc( GetProcessHeap(), 0, (len1+len2+1) * sizeof(WCHAR) ))) return NULL;
     memcpy( ret, dir, len1 * sizeof(WCHAR) );
     ptr = ret + len1;
     if (len2 && ptr > ret && ptr[-1] != '\\') *ptr++ = '\\';
     if (!SetupGetStringFieldW( context, 2, ptr, len2, NULL )) *ptr = 0;
     return ret;
 }

Referenced by get_destination_dir(), register_dlls_callback(), and SetupGetTargetPathW().

◆ PARSER_get_inf_filename()

const WCHAR* PARSER_get_inf_filename ( HINF hinf )

Definition at line 1084 of file parser.c.

 {
     struct inf_file *file = hinf;
     return file->filename;
 }

Referenced by fill_inf_info().

◆ PARSER_get_src_root()

WCHAR* PARSER_get_src_root ( HINF hinf )

Definition at line 1096 of file parser.c.

 {
     unsigned int len;
     const WCHAR *dir = get_inf_dir( hinf, &len );
     WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
     if (ret)
     {
         memcpy( ret, dir, len * sizeof(WCHAR) );
         ret[len] = 0;
     }
     return ret;
 }

Referenced by get_src_file_info().

◆ PARSER_GetInfClassW()

static BOOL PARSER_GetInfClassW	(	IN HINF	hInf,
		OUT LPGUID	ClassGuid,
		OUT PWSTR	ClassName,
		IN DWORD	ClassNameSize,
		OUT PDWORD RequiredSize	OPTIONAL
	)

static

Definition at line 1161 of file parser.c.

 {
     DWORD requiredSize;
     WCHAR guidW[MAX_GUID_STRING_LEN + 1];
     BOOL ret = FALSE;
 
     /* Read class Guid */
     if (!SetupGetLineTextW(NULL, hInf, Version, ClassGUID, guidW, sizeof(guidW), NULL))
         goto cleanup;
     guidW[37] = '\0'; /* Replace the } by a NULL character */
     if (UuidFromStringW(&guidW[1], ClassGuid) != RPC_S_OK)
         goto cleanup;
 
     /* Read class name */
     ret = SetupGetLineTextW(NULL, hInf, Version, Class, ClassName, ClassNameSize, &requiredSize);
     if (ret && ClassName == NULL && ClassNameSize == 0)
     {
         if (RequiredSize)
             *RequiredSize = requiredSize;
         SetLastError(ERROR_INSUFFICIENT_BUFFER);
         ret = FALSE;
         goto cleanup;
     }
     if (!ret)
     {
         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
         {
             if (RequiredSize)
                 *RequiredSize = requiredSize;
             goto cleanup;
         }
         else if (!SetupDiClassNameFromGuidW(ClassGuid, ClassName, ClassNameSize, &requiredSize))
         {
             if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
             {
                 if (RequiredSize)
                     *RequiredSize = requiredSize;
                 goto cleanup;
             }
             /* Return a NULL class name */
             if (RequiredSize)
                 *RequiredSize = 1;
             if (ClassNameSize < 1)
             {
                 SetLastError(ERROR_INSUFFICIENT_BUFFER);
                 goto cleanup;
             }
             memcpy(ClassGuid, &GUID_NULL, sizeof(GUID));
             *ClassName = UNICODE_NULL;
         }
     }
 
     ret = TRUE;
 
 cleanup:
     TRACE("Returning %d\n", ret);
     return ret;
 }

Referenced by SetupDiGetINFClassW(), and SetupOpenInfFileW().

◆ PARSER_string_substA()

static unsigned int PARSER_string_substA	(	const struct inf_file *	file,
		const WCHAR *	text,
		char *	buffer,
		unsigned int	size
	)

static

Definition at line 456 of file parser.c.

 {
     WCHAR buffW[MAX_STRING_LEN+1];
     DWORD ret;
 
     unsigned int len = PARSER_string_substW( file, text, buffW, sizeof(buffW)/sizeof(WCHAR) );
     if (!buffer) RtlUnicodeToMultiByteSize( &ret, buffW, len * sizeof(WCHAR) );
     else
     {
         RtlUnicodeToMultiByteN( buffer, size-1, &ret, buffW, len * sizeof(WCHAR) );
         buffer[ret] = 0;
     }
     return ret;
 }

Referenced by SetupGetLineTextA(), SetupGetMultiSzFieldA(), and SetupGetStringFieldA().

◆ PARSER_string_substW()

static unsigned int PARSER_string_substW	(	const struct inf_file *	file,
		const WCHAR *	text,
		WCHAR *	buffer,
		unsigned int	size
	)

static

Definition at line 403 of file parser.c.

 {
     const WCHAR *start, *subst, *p;
     unsigned int len, total = 0;
     BOOL inside = FALSE;
 
     if (!buffer) size = MAX_STRING_LEN + 1;
     for (p = start = text; *p; p++)
     {
         if (*p != '%') continue;
         inside = !inside;
         if (inside)  /* start of a %xx% string */
         {
             len = p - start;
             if (len > size - 1) len = size - 1;
             if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
             total += len;
             size -= len;
             start = p;
         }
         else /* end of the %xx% string, find substitution */
         {
             len = p - start - 1;
             subst = get_string_subst( file, start + 1, &len, p[1] == '\\' );
             if (!subst)
             {
                 subst = start;
                 len = p - start + 1;
             }
             if (len > size - 1) len = size - 1;
             if (buffer) memcpy( buffer + total, subst, len * sizeof(WCHAR) );
             total += len;
             size -= len;
             start = p + 1;
         }
     }
 
     if (start != p) /* unfinished string, copy it */
     {
         len = p - start;
         if (len > size - 1) len = size - 1;
         if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
         total += len;
     }
     if (buffer && size) buffer[total] = 0;
     return total;
 }

Referenced by PARSER_string_substA(), SetupGetLineTextW(), SetupGetMultiSzFieldW(), and SetupGetStringFieldW().

◆ pop_state()

static void pop_state ( struct parser * parser )

inlinestatic

Definition at line 492 of file parser.c.

 {
     ASSERT( parser->stack_pos );
     parser->state = parser->stack[--parser->stack_pos];
 }

Referenced by comment_state(), eol_backslash_state(), leading_spaces_state(), quotes_state(), and trailing_spaces_state().

◆ pSetupGetField()

LPCWSTR WINAPI pSetupGetField	(	PINFCONTEXT	context,
		DWORD	index
	)

Definition at line 2122 of file parser.c.

 {
     struct inf_file *file = context->CurrentInf;
     struct field *field = get_field( file, context->Section, context->Line, index );
 
     if (!field)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return NULL;
     }
     return field->text;
 }

◆ push_state()

static void push_state	(	struct parser *	parser,
		enum parser_state	state
	)

inlinestatic

Definition at line 484 of file parser.c.

 {
     ASSERT( parser->stack_pos < sizeof(parser->stack)/sizeof(parser->stack[0]) );
     parser->stack[parser->stack_pos++] = state;
 }

Referenced by eol_backslash_state(), key_name_state(), line_start_state(), section_name_state(), and value_name_state().

◆ push_string()

static WCHAR* push_string	(	struct inf_file *	file,
		const WCHAR *	string
	)

static

Definition at line 474 of file parser.c.

 {
     WCHAR *ret = file->string_pos;
     strcpyW( ret, string );
     file->string_pos += strlenW( ret ) + 1;
     return ret;
 }

Referenced by add_field_from_token(), and add_section_from_token().

◆ push_token()

static int push_token	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 523 of file parser.c.

 {
     int len = pos - parser->start;
     const WCHAR *src = parser->start;
     WCHAR *dst = parser->token + parser->token_len;
 
     if (len > MAX_FIELD_LEN - parser->token_len) len = MAX_FIELD_LEN - parser->token_len;
 
     parser->token_len += len;
     for ( ; len > 0; len--, dst++, src++) *dst = *src ? *src : ' ';
     *dst = 0;
     parser->start = pos;
     return 0;
 }

Referenced by eol_backslash_state(), key_name_state(), quotes_state(), section_name_state(), and value_name_state().

◆ quotes_state()

static const WCHAR * quotes_state	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 817 of file parser.c.

 {
     const WCHAR *p;
 
     for (p = pos; !is_eol( parser, p ); p++)
     {
         if (*p == '"')
         {
             if (p+1 < parser->end && p[1] == '"')  /* double quotes */
             {
                 push_token( parser, p + 1 );
                 parser->start = p + 2;
                 p++;
             }
             else  /* end of quotes */
             {
                 push_token( parser, p );
                 parser->start = p + 1;
                 pop_state( parser );
                 return p + 1;
             }
         }
     }
     push_token( parser, p );
     pop_state( parser );
     return p;
 }

◆ section_name_state()

static const WCHAR * section_name_state	(	struct parser *	parser,
		const WCHAR *	pos
	)

static

Definition at line 656 of file parser.c.

 {
     const WCHAR *p;
 
     for (p = pos; !is_eol( parser, p ); p++)
     {
         if (*p == ']')
         {
             push_token( parser, p );
             if (add_section_from_token( parser ) == -1) return NULL;
             push_state( parser, LINE_START );
             set_state( parser, COMMENT );  /* ignore everything else on the line */
             return p + 1;
         }
     }
     parser->error = ERROR_BAD_SECTION_NAME_LINE; /* unfinished section name */
     return NULL;
 }

◆ set_state()

static enum parser_state set_state	(	struct parser *	parser,
		enum parser_state	state
	)

inlinestatic

Definition at line 500 of file parser.c.

 {
     enum parser_state ret = parser->state;
     parser->state = state;
     return ret;
 }

Referenced by eol_backslash_state(), key_name_state(), leading_spaces_state(), line_start_state(), section_name_state(), trailing_spaces_state(), and value_name_state().

◆ SetupCloseInfFile()

void WINAPI SetupCloseInfFile ( HINF hinf )

Definition at line 1393 of file parser.c.

 {
     struct inf_file *file = hinf;
 
     if (!hinf || (hinf == INVALID_HANDLE_VALUE)) return;
 
     free_inf_file( file );
 }

Referenced by SetupDiGetINFClassW(), SetupGetInfFileListW(), SetupOpenInfFileW(), and test_invalid_files().

◆ SetupDiGetINFClassA()

BOOL WINAPI SetupDiGetINFClassA	(	IN PCSTR	InfName,
		OUT LPGUID	ClassGuid,
		OUT PSTR	ClassName,
		IN DWORD	ClassNameSize,
		OUT PDWORD RequiredSize	OPTIONAL
	)

Definition at line 2347 of file parser.c.

 {
     PWSTR InfNameW = NULL;
     PWSTR ClassNameW = NULL;
     BOOL ret = FALSE;
 
     TRACE("%s %p %p %ld %p\n", debugstr_a(InfName), ClassGuid,
         ClassName, ClassNameSize, RequiredSize);
 
     if (InfName != NULL)
     {
         InfNameW = pSetupMultiByteToUnicode(InfName, CP_ACP);
         if (InfNameW == NULL) goto Cleanup;
     }
 
     if (ClassName != NULL && ClassNameSize != 0)
     {
         ClassNameW = MyMalloc(ClassNameSize * sizeof(WCHAR));
         if (ClassNameW == NULL) goto Cleanup;
     }
 
     ret = SetupDiGetINFClassW(InfNameW, ClassGuid, ClassNameW, ClassNameSize, RequiredSize);
 
     if (ret && ClassNameW != NULL)
     {
         ret = WideCharToMultiByte(CP_ACP, 0, ClassNameW, -1, ClassName, ClassNameSize, NULL, NULL) != 0;
     }
 
 Cleanup:
     MyFree(InfNameW);
     MyFree(ClassNameW);
 
     return ret;
 }

Referenced by test_get_inf_class().

◆ SetupDiGetINFClassW()

BOOL WINAPI SetupDiGetINFClassW	(	IN PCWSTR	InfName,
		OUT LPGUID	ClassGuid,
		OUT PWSTR	ClassName,
		IN DWORD	ClassNameSize,
		OUT PDWORD RequiredSize	OPTIONAL
	)

Definition at line 2316 of file parser.c.

 {
     HINF hInf = INVALID_HANDLE_VALUE;
     BOOL ret = FALSE;
 
     TRACE("%s %p %p %ld %p\n", debugstr_w(InfName), ClassGuid,
         ClassName, ClassNameSize, RequiredSize);
 
     /* Open .inf file */
     hInf = SetupOpenInfFileW(InfName, NULL, INF_STYLE_WIN4, NULL);
     if (hInf == INVALID_HANDLE_VALUE)
         goto cleanup;
 
     ret = PARSER_GetInfClassW(hInf, ClassGuid, ClassName, ClassNameSize, RequiredSize);
 
 cleanup:
     if (hInf != INVALID_HANDLE_VALUE)
        SetupCloseInfFile(hInf);
 
     TRACE("Returning %d\n", ret);
     return ret;
 }

Referenced by SetupDiGetINFClassA(), and SetupDiInstallDevice().

◆ SetupEnumInfSectionsA()

BOOL WINAPI SetupEnumInfSectionsA	(	HINF	hinf,
		UINT	index,
		PSTR	buffer,
		DWORD	size,
		DWORD *	need
	)

Definition at line 1406 of file parser.c.

 {
     struct inf_file *file = hinf;
 
     for (file = hinf; file; file = file->next)
     {
         if (index < file->nb_sections)
         {
             DWORD len = WideCharToMultiByte( CP_ACP, 0, file->sections[index]->name, -1,
                                              NULL, 0, NULL, NULL );
             if (need) *need = len;
             if (!buffer)
             {
                 if (!size) return TRUE;
                 SetLastError( ERROR_INVALID_USER_BUFFER );
                 return FALSE;
             }
             if (len > size)
             {
                 SetLastError( ERROR_INSUFFICIENT_BUFFER );
                 return FALSE;
             }
             WideCharToMultiByte( CP_ACP, 0, file->sections[index]->name, -1, buffer, size, NULL, NULL );
             return TRUE;
         }
         index -= file->nb_sections;
     }
     SetLastError( ERROR_NO_MORE_ITEMS );
     return FALSE;
 }

◆ SetupEnumInfSectionsW()

BOOL WINAPI SetupEnumInfSectionsW	(	HINF	hinf,
		UINT	index,
		PWSTR	buffer,
		DWORD	size,
		DWORD *	need
	)

Definition at line 1441 of file parser.c.

 {
     struct inf_file *file = hinf;
 
     for (file = hinf; file; file = file->next)
     {
         if (index < file->nb_sections)
         {
             DWORD len = strlenW( file->sections[index]->name ) + 1;
             if (need) *need = len;
             if (!buffer)
             {
                 if (!size) return TRUE;
                 SetLastError( ERROR_INVALID_USER_BUFFER );
                 return FALSE;
             }
             if (len > size)
             {
                 SetLastError( ERROR_INSUFFICIENT_BUFFER );
                 return FALSE;
             }
             memcpy( buffer, file->sections[index]->name, len * sizeof(WCHAR) );
             return TRUE;
         }
         index -= file->nb_sections;
     }
     SetLastError( ERROR_NO_MORE_ITEMS );
     return FALSE;
 }

◆ SetupFindFirstLineA()

BOOL WINAPI SetupFindFirstLineA	(	HINF	hinf,
		PCSTR	section,
		PCSTR	key,
		INFCONTEXT *	context
	)

Definition at line 1564 of file parser.c.

 {
     UNICODE_STRING sectionW, keyW;
     BOOL ret = FALSE;
 
     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
     {
         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
         return FALSE;
     }
 
     if (!key) ret = SetupFindFirstLineW( hinf, sectionW.Buffer, NULL, context );
     else
     {
         if (RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
         {
             ret = SetupFindFirstLineW( hinf, sectionW.Buffer, keyW.Buffer, context );
             RtlFreeUnicodeString( &keyW );
         }
         else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
     }
     RtlFreeUnicodeString( &sectionW );
     return ret;
 }

Referenced by SetupGetLineTextA().

◆ SetupFindFirstLineW()

BOOL WINAPI SetupFindFirstLineW	(	HINF	hinf,
		PCWSTR	section,
		PCWSTR	key,
		INFCONTEXT *	context
	)

Definition at line 1593 of file parser.c.

 {
     struct inf_file *file;
     int section_index;
 
     for (file = hinf; file; file = file->next)
     {
         if ((section_index = find_section( file, section )) == -1) continue;
         if (key)
         {
             INFCONTEXT ctx;
             ctx.Inf        = hinf;
             ctx.CurrentInf = file;
             ctx.Section    = section_index;
             ctx.Line       = -1;
             return SetupFindNextMatchLineW( &ctx, key, context );
         }
         if (file->sections[section_index]->nb_lines)
         {
             context->Inf        = hinf;
             context->CurrentInf = file;
             context->Section    = section_index;
             context->Line       = 0;
             SetLastError( 0 );
             TRACE( "(%p,%s,%s): returning %d/0\n",
                    hinf, debugstr_w(section), debugstr_w(key), section_index );
             return TRUE;
         }
     }
     TRACE( "(%p,%s,%s): not found\n", hinf, debugstr_w(section), debugstr_w(key) );
     SetLastError( ERROR_LINE_NOT_FOUND );
     return FALSE;
 }

Referenced by SetupFindFirstLineA(), SetupGetLineTextW(), and SetupOpenAppendInfFileW().

◆ SetupFindNextLine()

BOOL WINAPI SetupFindNextLine	(	PINFCONTEXT	context_in,
		PINFCONTEXT	context_out
	)

Definition at line 1631 of file parser.c.

 {
     struct inf_file *file = context_in->CurrentInf;
     struct section *section;
 
     if (context_in->Section >= file->nb_sections) goto error;
 
     section = file->sections[context_in->Section];
     if (context_in->Line+1 < section->nb_lines)
     {
         if (context_out != context_in) *context_out = *context_in;
         context_out->Line++;
         SetLastError( 0 );
         return TRUE;
     }
 
     /* now search the appended files */
 
     for (file = file->next; file; file = file->next)
     {
         int section_index = find_section( file, section->name );
         if (section_index == -1) continue;
         if (file->sections[section_index]->nb_lines)
         {
             context_out->Inf        = context_in->Inf;
             context_out->CurrentInf = file;
             context_out->Section    = section_index;
             context_out->Line       = 0;
             SetLastError( 0 );
             return TRUE;
         }
     }
  error:
     SetLastError( ERROR_LINE_NOT_FOUND );
     return FALSE;
 }

Referenced by SetupFindNextMatchLineA(), and SetupFindNextMatchLineW().

◆ SetupFindNextMatchLineA()

BOOL WINAPI SetupFindNextMatchLineA	(	PINFCONTEXT	context_in,
		PCSTR	key,
		PINFCONTEXT	context_out
	)

Definition at line 1672 of file parser.c.

 {
     UNICODE_STRING keyW;
     BOOL ret = FALSE;
 
     if (!key) return SetupFindNextLine( context_in, context_out );
 
     if (!RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
     else
     {
         ret = SetupFindNextMatchLineW( context_in, keyW.Buffer, context_out );
         RtlFreeUnicodeString( &keyW );
     }
     return ret;
 }

◆ SetupFindNextMatchLineW()

BOOL WINAPI SetupFindNextMatchLineW	(	PINFCONTEXT	context_in,
		PCWSTR	key,
		PINFCONTEXT	context_out
	)

Definition at line 1694 of file parser.c.

 {
     struct inf_file *file = context_in->CurrentInf;
     struct section *section;
     struct line *line;
     unsigned int i;
 
     if (!key) return SetupFindNextLine( context_in, context_out );
 
     if (context_in->Section >= file->nb_sections) goto error;
 
     section = file->sections[context_in->Section];
 
     for (i = context_in->Line+1, line = &section->lines[i]; i < section->nb_lines; i++, line++)
     {
         if (line->key_field == -1) continue;
         if (!strcmpiW( key, file->fields[line->key_field].text ))
         {
             if (context_out != context_in) *context_out = *context_in;
             context_out->Line = i;
             SetLastError( 0 );
             TRACE( "(%p,%s,%s): returning %d\n",
                    file, debugstr_w(section->name), debugstr_w(key), i );
             return TRUE;
         }
     }
 
     /* now search the appended files */
 
     for (file = file->next; file; file = file->next)
     {
         int section_index = find_section( file, section->name );
         if (section_index == -1) continue;
         section = file->sections[section_index];
         for (i = 0, line = section->lines; i < section->nb_lines; i++, line++)
         {
             if (line->key_field == -1) continue;
             if (!strcmpiW( key, file->fields[line->key_field].text ))
             {
                 context_out->Inf        = context_in->Inf;
                 context_out->CurrentInf = file;
                 context_out->Section    = section_index;
                 context_out->Line       = i;
                 SetLastError( 0 );
                 TRACE( "(%p,%s,%s): returning %d/%d\n",
                        file, debugstr_w(section->name), debugstr_w(key), section_index, i );
                 return TRUE;
             }
         }
     }
     TRACE( "(%p,%s,%s): not found\n",
            context_in->CurrentInf, debugstr_w(section->name), debugstr_w(key) );
  error:
     SetLastError( ERROR_LINE_NOT_FOUND );
     return FALSE;
 }

Referenced by iterate_section_fields(), SetupDiInstallDeviceInterfaces(), SetupFindFirstLineW(), SetupFindNextMatchLineA(), and SetupInstallServicesFromInfSectionExW().

◆ SetupGetBinaryField()

BOOL WINAPI SetupGetBinaryField	(	PINFCONTEXT	context,
		DWORD	index,
		BYTE *	buffer,
		DWORD	size,
		LPDWORD	required
	)

Definition at line 1969 of file parser.c.

 {
     struct inf_file *file = context->CurrentInf;
     struct line *line = get_line( file, context->Section, context->Line );
     struct field *field;
     int i;
 
     if (!line)
     {
         SetLastError( ERROR_LINE_NOT_FOUND );
         return FALSE;
     }
     if (!index || index > line->nb_fields)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
     index--;  /* fields start at 0 */
     if (required) *required = line->nb_fields - index;
     if (!buffer) return TRUE;
     if (size < line->nb_fields - index)
     {
         SetLastError( ERROR_INSUFFICIENT_BUFFER );
         return FALSE;
     }
     field = &file->fields[line->first_field + index];
     for (i = index; i < line->nb_fields; i++, field++)
     {
         const WCHAR *p;
         DWORD value = 0;
         for (p = field->text; *p && isxdigitW(*p); p++)
         {
             if ((value <<= 4) > 255)
             {
                 SetLastError( ERROR_INVALID_DATA );
                 return FALSE;
             }
             if (*p <= '9') value |= (*p - '0');
             else value |= (tolowerW(*p) - 'a' + 10);
         }
         buffer[i - index] = value;
     }
     if (TRACE_ON(setupapi))
     {
         TRACE( "%p/%p/%d/%d index %d returning:\n",
                context->Inf, context->CurrentInf, context->Section, context->Line, index );
         for (i = index; i < line->nb_fields; i++) TRACE( " %02x\n", buffer[i - index] );
     }
     return TRUE;
 }

◆ SetupGetFieldCount()

DWORD WINAPI SetupGetFieldCount ( PINFCONTEXT context )

Definition at line 1858 of file parser.c.

 {
     struct inf_file *file = context->CurrentInf;
     struct line *line = get_line( file, context->Section, context->Line );
 
     if (!line) return 0;
     return line->nb_fields;
 }

◆ SetupGetInfFileListA()

BOOL WINAPI SetupGetInfFileListA	(	IN PCSTR DirectoryPath	OPTIONAL,
		IN DWORD	InfStyle,
		IN OUT PSTR ReturnBuffer	OPTIONAL,
		IN DWORD ReturnBufferSize	OPTIONAL,
		OUT PDWORD RequiredSize	OPTIONAL
	)

Definition at line 2272 of file parser.c.

 {
     PWSTR DirectoryPathW = NULL;
     PWSTR ReturnBufferW = NULL;
     BOOL ret = FALSE;
 
     TRACE("%s %lx %p %ld %p\n", debugstr_a(DirectoryPath), InfStyle,
         ReturnBuffer, ReturnBufferSize, RequiredSize);
 
     if (DirectoryPath != NULL)
     {
         DirectoryPathW = pSetupMultiByteToUnicode(DirectoryPath, CP_ACP);
         if (DirectoryPathW == NULL) goto Cleanup;
     }
 
     if (ReturnBuffer != NULL && ReturnBufferSize != 0)
     {
         ReturnBufferW = MyMalloc(ReturnBufferSize * sizeof(WCHAR));
         if (ReturnBufferW == NULL) goto Cleanup;
     }
 
     ret = SetupGetInfFileListW(DirectoryPathW, InfStyle, ReturnBufferW, ReturnBufferSize, RequiredSize);
 
     if (ret && ReturnBufferW != NULL)
     {
         ret = WideCharToMultiByte(CP_ACP, 0, ReturnBufferW, -1, ReturnBuffer, ReturnBufferSize, NULL, NULL) != 0;
     }
 
 Cleanup:
     MyFree(DirectoryPathW);
     MyFree(ReturnBufferW);
 
     return ret;
 }

Referenced by test_inffilelistA().

◆ SetupGetInfFileListW()

BOOL WINAPI SetupGetInfFileListW	(	IN PCWSTR DirectoryPath	OPTIONAL,
		IN DWORD	InfStyle,
		IN OUT PWSTR ReturnBuffer	OPTIONAL,
		IN DWORD ReturnBufferSize	OPTIONAL,
		OUT PDWORD RequiredSize	OPTIONAL
	)

Definition at line 2139 of file parser.c.

 {
     HANDLE hSearch;
     LPWSTR pFullFileName = NULL;
     LPWSTR pFileName; /* Pointer into pFullFileName buffer */
     LPWSTR pBuffer = ReturnBuffer;
     WIN32_FIND_DATAW wfdFileInfo;
     size_t len;
     DWORD requiredSize = 0;
     BOOL ret = FALSE;
 
     TRACE("%s %lx %p %ld %p\n", debugstr_w(DirectoryPath), InfStyle,
         ReturnBuffer, ReturnBufferSize, RequiredSize);
 
     if (InfStyle & ~(INF_STYLE_OLDNT | INF_STYLE_WIN4))
     {
         TRACE("Unknown flags: 0x%08lx\n", InfStyle & ~(INF_STYLE_OLDNT  | INF_STYLE_WIN4));
         SetLastError(ERROR_INVALID_PARAMETER);
         goto cleanup;
     }
     else if (ReturnBufferSize == 0 && ReturnBuffer != NULL)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         goto cleanup;
     }
     else if (ReturnBufferSize > 0 && ReturnBuffer == NULL)
     {
         SetLastError(ERROR_INVALID_PARAMETER);
         goto cleanup;
     }
 
     /* Allocate memory for file filter */
     if (DirectoryPath != NULL)
         /* "DirectoryPath\" form */
         len = strlenW(DirectoryPath) + 1 + 1;
     else
         /* "%SYSTEMROOT%\Inf\" form */
         len = MAX_PATH + 1 + strlenW(InfDirectory) + 1;
     len += MAX_PATH; /* To contain file name or "*.inf" string */
     pFullFileName = MyMalloc(len * sizeof(WCHAR));
     if (pFullFileName == NULL)
     {
         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
         goto cleanup;
     }
 
     /* Fill file filter buffer */
     if (DirectoryPath)
     {
         strcpyW(pFullFileName, DirectoryPath);
         if (*pFullFileName && pFullFileName[strlenW(pFullFileName) - 1] != '\\')
             strcatW(pFullFileName, BackSlash);
     }
     else
     {
         len = GetSystemWindowsDirectoryW(pFullFileName, MAX_PATH);
         if (len == 0 || len > MAX_PATH)
             goto cleanup;
         if (pFullFileName[strlenW(pFullFileName) - 1] != '\\')
             strcatW(pFullFileName, BackSlash);
         strcatW(pFullFileName, InfDirectory);
     }
     pFileName = &pFullFileName[strlenW(pFullFileName)];
 
     /* Search for the first file */
     strcpyW(pFileName, InfFileSpecification);
     hSearch = FindFirstFileW(pFullFileName, &wfdFileInfo);
     if (hSearch == INVALID_HANDLE_VALUE)
     {
         TRACE("No file returned by %s\n", debugstr_w(pFullFileName));
         goto cleanup;
     }
 
     do
     {
         HINF hInf;
 
         strcpyW(pFileName, wfdFileInfo.cFileName);
         hInf = SetupOpenInfFileW(
             pFullFileName,
             NULL, /* Inf class */
             InfStyle,
             NULL /* Error line */);
         if (hInf == INVALID_HANDLE_VALUE)
         {
             if (GetLastError() == ERROR_CLASS_MISMATCH)
             {
                 /* InfStyle was not correct. Skip this file */
                 continue;
             }
             TRACE("Invalid .inf file %s\n", debugstr_w(pFullFileName));
             continue;
         }
 
         len = strlenW(wfdFileInfo.cFileName) + 1;
         requiredSize += (DWORD)len;
         if (requiredSize <= ReturnBufferSize)
         {
             strcpyW(pBuffer, wfdFileInfo.cFileName);
             pBuffer = &pBuffer[len];
         }
         SetupCloseInfFile(hInf);
     } while (FindNextFileW(hSearch, &wfdFileInfo));
     FindClose(hSearch);
 
     requiredSize += 1; /* Final NULL char */
     if (requiredSize <= ReturnBufferSize)
     {
         *pBuffer = '\0';
         ret = TRUE;
     }
     else
     {
         SetLastError(ERROR_INSUFFICIENT_BUFFER);
         ret = FALSE;
     }
     if (RequiredSize)
         *RequiredSize = requiredSize;
 
 cleanup:
     MyFree(pFullFileName);
     return ret;
 }

Referenced by SetupDiBuildDriverInfoList(), SetupGetInfFileListA(), and test_inffilelist().

◆ SetupGetIntField()

BOOL WINAPI SetupGetIntField	(	PINFCONTEXT	context,
		DWORD	index,
		PINT	result
	)

Definition at line 1933 of file parser.c.

 {
     char localbuff[20];
     char *end, *buffer = localbuff;
     DWORD required;
     INT res;
     BOOL ret;
 
     if (!(ret = SetupGetStringFieldA( context, index, localbuff, sizeof(localbuff), &required )))
     {
         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required ))) return FALSE;
         if (!(ret = SetupGetStringFieldA( context, index, buffer, required, NULL ))) goto done;
     }
     /* The call to SetupGetStringFieldA succeeded. If buffer is empty we have an optional field */
     if (!*buffer) *result = 0;
     else
     {
         res = strtol( buffer, &end, 0 );
         if (end != buffer && !*end) *result = res;
         else
         {
             SetLastError( ERROR_INVALID_DATA );
             ret = FALSE;
         }
     }
 
  done:
     if (buffer != localbuff) HeapFree( GetProcessHeap(), 0, buffer );
     return ret;
 }

Referenced by PARSER_get_dest_dir().

◆ SetupGetLineByIndexA()

BOOL WINAPI SetupGetLineByIndexA	(	HINF	hinf,
		PCSTR	section,
		DWORD	index,
		INFCONTEXT *	context
	)

Definition at line 1515 of file parser.c.

 {
     UNICODE_STRING sectionW;
     BOOL ret = FALSE;
 
     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
     else
     {
         ret = SetupGetLineByIndexW( hinf, sectionW.Buffer, index, context );
         RtlFreeUnicodeString( &sectionW );
     }
     return ret;
 }

◆ SetupGetLineByIndexW()

BOOL WINAPI SetupGetLineByIndexW	(	HINF	hinf,
		PCWSTR	section,
		DWORD	index,
		INFCONTEXT *	context
	)

Definition at line 1534 of file parser.c.

 {
     struct inf_file *file = hinf;
     int section_index;
 
     for (file = hinf; file; file = file->next)
     {
         if ((section_index = find_section( file, section )) == -1) continue;
         if (index < file->sections[section_index]->nb_lines)
         {
             context->Inf        = hinf;
             context->CurrentInf = file;
             context->Section    = section_index;
             context->Line       = index;
             SetLastError( 0 );
             TRACE( "(%p,%s): returning %d/%d\n",
                    hinf, debugstr_w(section), section_index, index );
             return TRUE;
         }
         index -= file->sections[section_index]->nb_lines;
     }
     TRACE( "(%p,%s) not found\n", hinf, debugstr_w(section) );
     SetLastError( ERROR_LINE_NOT_FOUND );
     return FALSE;
 }

Referenced by SetupGetLineByIndexA().

◆ SetupGetLineCountA()

LONG WINAPI SetupGetLineCountA	(	HINF	hinf,
		PCSTR	name
	)

Definition at line 1475 of file parser.c.

 {
     UNICODE_STRING sectionW;
     LONG ret = -1;
 
     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, name ))
         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
     else
     {
         ret = SetupGetLineCountW( hinf, sectionW.Buffer );
         RtlFreeUnicodeString( &sectionW );
     }
     return ret;
 }

◆ SetupGetLineCountW()

LONG WINAPI SetupGetLineCountW	(	HINF	hinf,
		PCWSTR	section
	)

Definition at line 1494 of file parser.c.

 {
     struct inf_file *file = hinf;
     int section_index;
     LONG ret = -1;
 
     for (file = hinf; file; file = file->next)
     {
         if ((section_index = find_section( file, section )) == -1) continue;
         if (ret == -1) ret = 0;
         ret += file->sections[section_index]->nb_lines;
     }
     TRACE( "(%p,%s) returning %d\n", hinf, debugstr_w(section), ret );
     SetLastError( (ret == -1) ? ERROR_SECTION_NOT_FOUND : 0 );
     return ret;
 }

Referenced by SetupGetLineCountA(), and StartComponentRegistration().

◆ SetupGetLineTextA()

BOOL WINAPI SetupGetLineTextA	(	PINFCONTEXT	context,
		HINF	hinf,
		PCSTR	section_name,
		PCSTR	key_name,
		PSTR	buffer,
		DWORD	size,
		PDWORD	required
	)

Definition at line 1807 of file parser.c.

 {
     struct inf_file *file;
     struct line *line;
     struct field *field;
     int i;
     DWORD total = 0;
 
     if (!context)
     {
         INFCONTEXT new_context;
         if (!SetupFindFirstLineA( hinf, section_name, key_name, &new_context )) return FALSE;
         file = new_context.CurrentInf;
         line = get_line( file, new_context.Section, new_context.Line );
     }
     else
     {
         file = context->CurrentInf;
         if (!(line = get_line( file, context->Section, context->Line )))
         {
             SetLastError( ERROR_LINE_NOT_FOUND );
             return FALSE;
         }
     }
 
     for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
         total += PARSER_string_substA( file, field->text, NULL, 0 ) + 1;
 
     if (required) *required = total;
     if (buffer)
     {
         if (total > size)
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
         for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
         {
             unsigned int len = PARSER_string_substA( file, field->text, buffer, size );
             if (i+1 < line->nb_fields) buffer[len] = ',';
             buffer += len + 1;
         }
     }
     return TRUE;
 }

Referenced by get_line_text().

◆ SetupGetLineTextW()

BOOL WINAPI SetupGetLineTextW	(	PINFCONTEXT	context,
		HINF	hinf,
		PCWSTR	section_name,
		PCWSTR	key_name,
		PWSTR	buffer,
		DWORD	size,
		PDWORD	required
	)

Definition at line 1756 of file parser.c.

 {
     struct inf_file *file;
     struct line *line;
     struct field *field;
     int i;
     DWORD total = 0;
 
     if (!context)
     {
         INFCONTEXT new_context;
         if (!SetupFindFirstLineW( hinf, section_name, key_name, &new_context )) return FALSE;
         file = new_context.CurrentInf;
         line = get_line( file, new_context.Section, new_context.Line );
     }
     else
     {
         file = context->CurrentInf;
         if (!(line = get_line( file, context->Section, context->Line )))
         {
             SetLastError( ERROR_LINE_NOT_FOUND );
             return FALSE;
         }
     }
 
     for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
         total += PARSER_string_substW( file, field->text, NULL, 0 ) + 1;
 
     if (required) *required = total;
     if (buffer)
     {
         if (total > size)
         {
             SetLastError( ERROR_INSUFFICIENT_BUFFER );
             return FALSE;
         }
         for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
         {
             unsigned int len = PARSER_string_substW( file, field->text, buffer, size );
             if (i+1 < line->nb_fields) buffer[len] = ',';
             buffer += len + 1;
         }
     }
     return TRUE;
 }

Referenced by del_dirs_callback(), GetLineText(), GetVersionInformationFromInfFile(), PARSER_GetInfClassW(), per_user_install_callback(), registry_callback(), run_setup_commands_callback(), set_ldids(), SETUP_CreateClassKey(), SetupQueryInfOriginalFileInformationW(), SetupQueueCopySectionW(), TranslateInfStringExW(), and TranslateInfStringW().

◆ SetupGetMultiSzFieldA()

BOOL WINAPI SetupGetMultiSzFieldA	(	PINFCONTEXT	context,
		DWORD	index,
		PSTR	buffer,
		DWORD	size,
		LPDWORD	required
	)

Definition at line 2025 of file parser.c.

 {
     struct inf_file *file = context->CurrentInf;
     struct line *line = get_line( file, context->Section, context->Line );
     struct field *field;
     unsigned int len;
     int i;
     DWORD total = 1;
 
     if (!line)
     {
         SetLastError( ERROR_LINE_NOT_FOUND );
         return FALSE;
     }
     if (!index || index > line->nb_fields)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
     index--;  /* fields start at 0 */
     field = &file->fields[line->first_field + index];
     for (i = index; i < line->nb_fields; i++, field++)
     {
         if (!(len = PARSER_string_substA( file, field->text, NULL, 0 ))) break;
         total += len + 1;
     }
 
     if (required) *required = total;
     if (!buffer) return TRUE;
     if (total > size)
     {
         SetLastError( ERROR_INSUFFICIENT_BUFFER );
         return FALSE;
     }
     field = &file->fields[line->first_field + index];
     for (i = index; i < line->nb_fields; i++, field++)
     {
         if (!(len = PARSER_string_substA( file, field->text, buffer, size ))) break;
         buffer += len + 1;
     }
     *buffer = 0;  /* add final null */
     return TRUE;
 }

◆ SetupGetMultiSzFieldW()

BOOL WINAPI SetupGetMultiSzFieldW	(	PINFCONTEXT	context,
		DWORD	index,
		PWSTR	buffer,
		DWORD	size,
		LPDWORD	required
	)

Definition at line 2074 of file parser.c.

 {
     struct inf_file *file = context->CurrentInf;
     struct line *line = get_line( file, context->Section, context->Line );
     struct field *field;
     unsigned int len;
     int i;
     DWORD total = 1;
 
     if (!line)
     {
         SetLastError( ERROR_LINE_NOT_FOUND );
         return FALSE;
     }
     if (!index || index > line->nb_fields)
     {
         SetLastError( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
     index--;  /* fields start at 0 */
     field = &file->fields[line->first_field + index];
     for (i = index; i < line->nb_fields; i++, field++)
     {
         if (!(len = PARSER_string_substW( file, field->text, NULL, 0 ))) break;
         total += len + 1;
     }
 
     if (required) *required = total;
     

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CONTROL_Z

◆ MAX_FIELD_LEN

◆ MAX_SECTION_NAME_LEN

◆ MAX_STRING_LEN

Typedef Documentation

◆ parser_state_func

Enumeration Type Documentation

◆ parser_state

Function Documentation

◆ add_field()

◆ add_field_from_token()

◆ add_line()

◆ add_section()

◆ add_section_from_token()

◆ append_inf_file()

◆ close_current_line()

◆ comment_state()

◆ EnumerateSectionsStartingWith()

◆ eol_backslash_state()

◆ find_line()

◆ find_section()

◆ free_inf_file()

◆ get_dirid_subst()

◆ get_field()

◆ get_inf_dir()

◆ get_line()

◆ get_string_subst()

◆ grow_array()

◆ is_eof()

◆ is_eol()

◆ key_name_state()

◆ leading_spaces_state()

◆ line_start_state()

◆ parse_buffer()

◆ parse_file()

◆ PARSER_get_dest_dir()

◆ PARSER_get_inf_filename()

◆ PARSER_get_src_root()

◆ PARSER_GetInfClassW()

◆ PARSER_string_substA()

◆ PARSER_string_substW()

◆ pop_state()

◆ pSetupGetField()

◆ push_state()

◆ push_string()

◆ push_token()

◆ quotes_state()

◆ section_name_state()

◆ set_state()

◆ SetupCloseInfFile()

◆ SetupDiGetINFClassA()

◆ SetupDiGetINFClassW()

◆ SetupEnumInfSectionsA()

◆ SetupEnumInfSectionsW()

◆ SetupFindFirstLineA()

◆ SetupFindFirstLineW()

◆ SetupFindNextLine()

◆ SetupFindNextMatchLineA()

◆ SetupFindNextMatchLineW()

◆ SetupGetBinaryField()

◆ SetupGetFieldCount()

◆ SetupGetInfFileListA()

◆ SetupGetInfFileListW()

◆ SetupGetIntField()

◆ SetupGetLineByIndexA()

◆ SetupGetLineByIndexW()

◆ SetupGetLineCountA()

◆ SetupGetLineCountW()

◆ SetupGetLineTextA()

◆ SetupGetLineTextW()

◆ SetupGetMultiSzFieldA()

◆ SetupGetMultiSzFieldW()