parser.c File Reference

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

Include dependency graph for parser.c:

Go to the source code of this file.

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 , 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
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().

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 2400 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];
}

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;
}

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 2129 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 1400 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(), test_close_inf_file(), test_enum_sections(), test_GLE(), test_invalid_files(), test_key_names(), test_pSetupGetField(), test_section_names(), and test_SetupGetIntField().

SetupDiGetINFClassA()

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

Definition at line 2360 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 2323 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);
 
    if (!InfName || !ClassGuid || !ClassName || ClassNameSize == 0)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* 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 InstallSoftwareBusPnpEnumerator(), SetupDiGetINFClassA(), and SetupDiInstallDevice().

SetupEnumInfSectionsA()

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

Definition at line 1413 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 1448 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 1571 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(), test_GLE(), test_key_names(), test_pSetupGetField(), and test_SetupGetIntField().

SetupFindFirstLineW()

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

Definition at line 1600 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 1638 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 1679 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;
}

Referenced by test_GLE().

SetupFindNextMatchLineW()

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

Definition at line 1701 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 1976 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 1865 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;
}

Referenced by test_key_names().

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 2279 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 2146 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 1940 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(), and test_SetupGetIntField().

SetupGetLineByIndexA()

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

Definition at line 1522 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;
}

Referenced by test_GLE().

SetupGetLineByIndexW()

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

Definition at line 1541 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 1482 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;
}

Referenced by test_GLE(), and test_section_names().

SetupGetLineCountW()

LONG WINAPI SetupGetLineCountW	(	HINF	hinf,
		PCWSTR	section
	)

Definition at line 1501 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 CountShortcuts(), RegisterComponents(), RegisterDlls(), and SetupGetLineCountA().

SetupGetLineTextA()

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

Definition at line 1814 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(), and test_GLE().

SetupGetLineTextW()

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

Definition at line 1763 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 2032 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 2081 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;
    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_substW( file, field->text, buffer, size ))) break;
        buffer += len + 1;
    }
    *buffer = 0;  /* add final null */
    return TRUE;
}

SetupGetStringFieldA()

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

Definition at line 1878 of file parser.c.

{
    struct inf_file *file = context->CurrentInf;
    struct field *field = get_field( file, context->Section, context->Line, index );
    unsigned int len;
 
    SetLastError(0);
    if (!field) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
    len = PARSER_string_substA( file, field->text, NULL, 0 );
    if (required) *required = len + 1;
    if (buffer)
    {
        if (size <= len)
        {
            SetLastError( ERROR_INSUFFICIENT_BUFFER );
            return FALSE;
        }
        PARSER_string_substA( file, field->text, buffer, size );
 
        TRACE( "context %p/%p/%d/%d index %d returning %s\n",
               context->Inf, context->CurrentInf, context->Section, context->Line,
               index, debugstr_a(buffer) );
    }
    return TRUE;
}

Referenced by get_string_field(), and SetupGetIntField().

SetupGetStringFieldW()

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

Definition at line 1909 of file parser.c.

{
    struct inf_file *file = context->CurrentInf;
    struct field *field = get_field( file, context->Section, context->Line, index );
    unsigned int len;
 
    SetLastError(0);
    if (!field) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
    len = PARSER_string_substW( file, field->text, NULL, 0 );
    if (required) *required = len + 1;
    if (buffer)
    {
        if (size <= len)
        {
            SetLastError( ERROR_INSUFFICIENT_BUFFER );
            return FALSE;
        }
        PARSER_string_substW( file, field->text, buffer, size );
 
        TRACE( "context %p/%p/%d/%d index %d returning %s\n",
               context->Inf, context->CurrentInf, context->Section, context->Line,
               index, debugstr_w(buffer) );
    }
    return TRUE;
}

Referenced by PARSER_get_dest_dir(), and SetupOpenAppendInfFileW().

SetupOpenAppendInfFileA()

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

Definition at line 1337 of file parser.c.

{
    HINF child_hinf;
 
    if (!name) return SetupOpenAppendInfFileW( NULL, parent_hinf, error );
    child_hinf = SetupOpenInfFileA( name, NULL, INF_STYLE_WIN4, error );
    if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
    append_inf_file( parent_hinf, child_hinf );
    TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_a(name), child_hinf );
    return TRUE;
}

SetupOpenAppendInfFileW()

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

Definition at line 1353 of file parser.c.

{
    HINF child_hinf;
 
    if (!name)
    {
        INFCONTEXT context;
        WCHAR filename[MAX_PATH];
        int idx = 1;
 
        if (!SetupFindFirstLineW( parent_hinf, Version, LayoutFile, &context )) return FALSE;
        while (SetupGetStringFieldW( &context, idx++, filename,
                                     sizeof(filename)/sizeof(WCHAR), NULL ))
        {
            child_hinf = SetupOpenInfFileW( filename, NULL, INF_STYLE_WIN4, error );
            if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
            append_inf_file( parent_hinf, child_hinf );
            TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(filename), child_hinf );
        }
        return TRUE;
    }
    child_hinf = SetupOpenInfFileW( name, NULL, INF_STYLE_WIN4, error );
    if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
    append_inf_file( parent_hinf, child_hinf );
    TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(name), child_hinf );
    return TRUE;
}

Referenced by include_callback(), SetupDiInstallClassExW(), and SetupOpenAppendInfFileA().

SetupOpenInfFileA()

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

Definition at line 1139 of file parser.c.

{
    UNICODE_STRING nameW, classW;
    HINF ret = INVALID_HANDLE_VALUE;
 
    classW.Buffer = NULL;
    if (class && !RtlCreateUnicodeStringFromAsciiz( &classW, class ))
    {
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return ret;
    }
    if (RtlCreateUnicodeStringFromAsciiz( &nameW, name ))
    {
        ret = SetupOpenInfFileW( nameW.Buffer, classW.Buffer, style, error );
        RtlFreeUnicodeString( &nameW );
    }
    RtlFreeUnicodeString( &classW );
    return ret;
}

Referenced by inf_open_file_content(), SetupOpenAppendInfFileA(), test_file_contents(), test_install_from(), test_install_svc_from(), test_original_file_name(), test_SetupDiInstallClassExA(), test_SetupGetInfInformation(), test_SetupGetSourceFileLocation(), test_SetupGetSourceInfo(), test_SetupGetTargetPath(), test_SetupInstallServicesFromInfSectionExA(), and test_SetupInstallServicesFromInfSectionExW().

SetupOpenInfFileW()

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

Definition at line 1229 of file parser.c.

{
    struct inf_file *file = NULL;
    HANDLE handle;
    WCHAR *path, *p;
    UINT len;
 
    TRACE("%s %s %lx %p\n", debugstr_w(name), debugstr_w(class), style, error);
 
#ifdef __REACTOS__
    if (style & ~(INF_STYLE_OLDNT | INF_STYLE_WIN4))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return (HINF)INVALID_HANDLE_VALUE;
    }
    if (!name)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return (HINF)INVALID_HANDLE_VALUE;
    }
#endif // __REACTOS__
 
    if (strchrW( name, '\\' ) || strchrW( name, '/' ))
    {
        if (!(len = GetFullPathNameW( name, 0, NULL, NULL ))) return INVALID_HANDLE_VALUE;
        if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
        {
            SetLastError( ERROR_NOT_ENOUGH_MEMORY );
            return INVALID_HANDLE_VALUE;
        }
        GetFullPathNameW( name, len, path, NULL );
        handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
    }
    else  /* try Windows directory */
    {
        static const WCHAR Inf[]      = {'\\','i','n','f','\\',0};
        static const WCHAR System32[] = {'\\','s','y','s','t','e','m','3','2','\\',0};
 
        len = GetWindowsDirectoryW( NULL, 0 ) + strlenW(name) + 12;
        if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
        {
            SetLastError( ERROR_NOT_ENOUGH_MEMORY );
            return INVALID_HANDLE_VALUE;
        }
        GetWindowsDirectoryW( path, len );
        p = path + strlenW(path);
        strcpyW( p, Inf );
        strcatW( p, name );
        handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
        if (handle == INVALID_HANDLE_VALUE)
        {
            strcpyW( p, System32 );
            strcatW( p, name );
            handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
        }
    }
 
    if (handle != INVALID_HANDLE_VALUE)
    {
        file = parse_file( handle, error, style);
        CloseHandle( handle );
    }
    if (!file)
    {
        HeapFree( GetProcessHeap(), 0, path );
        return INVALID_HANDLE_VALUE;
    }
    TRACE( "%s -> %p\n", debugstr_w(path), file );
    file->filename = path;
 
    if (class)
    {
        GUID ClassGuid;
        LPWSTR ClassName = HeapAlloc(GetProcessHeap(), 0, (strlenW(class) + 1) * sizeof(WCHAR));
        if (!ClassName)
        {
            /* Not enough memory */
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            SetupCloseInfFile((HINF)file);
            return INVALID_HANDLE_VALUE;
        }
        else if (!PARSER_GetInfClassW((HINF)file, &ClassGuid, ClassName, strlenW(class) + 1, NULL))
        {
            /* Unable to get class name in .inf file */
            HeapFree(GetProcessHeap(), 0, ClassName);
            SetLastError(ERROR_CLASS_MISMATCH);
            SetupCloseInfFile((HINF)file);
            return INVALID_HANDLE_VALUE;
        }
        else if (strcmpW(class, ClassName) != 0)
        {
            /* Provided name name is not the expected one */
            HeapFree(GetProcessHeap(), 0, ClassName);
            SetLastError(ERROR_CLASS_MISMATCH);
            SetupCloseInfFile((HINF)file);
            return INVALID_HANDLE_VALUE;
        }
        HeapFree(GetProcessHeap(), 0, ClassName);
    }
 
    SetLastError( 0 );
    return file;
}

Referenced by AddNewKbLayoutsByLcid(), CheckInfFile(), CommonInstall(), CreateInfFileDetails(), GetDefaultLayoutForLocale(), HandleSetupCommand(), InitCodePagesList(), install_init(), InstallDeviceData(), InstallHinfSectionW(), InstallInfSections(), InstallSecurity(), InstallSoftwareDeviceInterfaceInf(), InstallStartMenuItems(), InstallSysSetupInfComponents(), LoadOSList(), MMSYS_InstallDevice(), NetClassInstaller(), OpenINFEngineW(), OpenSetupInf(), ProcessSetupInf(), SaveFontSubstitutionSettings(), search_for_inf(), SetupDiGetINFClassW(), SetupDiInstallClassExW(), SetupGetInfFileListW(), SetupGetInfInformationW(), SetupOpenAppendInfFileW(), SetupOpenInfFileA(), SetupOpenInfFileExW(), SetupOpenMasterInf(), SetupQueryInfOriginalFileInformationW(), StartNetworkServices(), and TranslateInfStringW().

SetupOpenMasterInf()

HINF WINAPI SetupOpenMasterInf

(

VOID

)

Definition at line 1385 of file parser.c.

{
    static const WCHAR Layout[] = {'\\','i','n','f','\\', 'l', 'a', 'y', 'o', 'u', 't', '.', 'i', 'n', 'f', 0};
    WCHAR Buffer[MAX_PATH];
 
    GetWindowsDirectoryW( Buffer, MAX_PATH );
    strcatW( Buffer, Layout );
    return SetupOpenInfFileW( Buffer, NULL, INF_STYLE_WIN4, NULL);
}

trailing_spaces_state()

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

static

Definition at line 868 of file parser.c.

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

value_name_state()

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

static

Definition at line 731 of file parser.c.

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

Variable Documentation

BackSlash

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

static

Definition at line 29 of file parser.c.

Referenced by SetupGetInfFileListW().

Chicago

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

static

Definition at line 142 of file parser.c.

Referenced by parse_file().

Class

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

static

Definition at line 30 of file parser.c.

ClassGUID

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

static

Definition at line 31 of file parser.c.

Referenced by PARSER_GetInfClassW().

InfDirectory

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

static

Definition at line 32 of file parser.c.

Referenced by SetupGetInfFileListW().

InfFileSpecification

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

static

Definition at line 33 of file parser.c.

Referenced by SetupGetInfFileListW().

LayoutFile

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

static

Definition at line 145 of file parser.c.

Referenced by SetupOpenAppendInfFileW().

parser_funcs

const parser_state_func parser_funcs[NB_PARSER_STATES]

static

Initial value:

=
{
    line_start_state,      
    section_name_state,    
    key_name_state,        
    value_name_state,      
    eol_backslash_state,   
    quotes_state,          
    leading_spaces_state,  
    trailing_spaces_state, 
    comment_state          
}

Definition at line 125 of file parser.c.

Referenced by parse_buffer().

Signature

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

static

Definition at line 141 of file parser.c.

Referenced by _Struct_size_bytes_(), AcpiGetTable(), AcpiGetTableHeader(), AcpiTbFindTable(), AcpiTbPrintTableHeader(), AcpiTbVerifyTempTable(), AddBootStoreEntry(), AddDiskToList(), AddReactOSArcDiskInfo(), ata_send_ioctl(), BlUtlGetAcpiTable(), CreateFreeLoaderIniForReactOSAndBootSector(), CreateFreeLoaderReactOSEntries(), CreateNTOSEntry(), CRYPT_AsnDecodeCertSignedContent(), DiskFlushDispatch(), DiskInfoExceptionCheck(), DiskIoctlGetMediaTypesEx(), DiskIoctlIsWritable(), DiskIoctlReassignBlocks(), DiskIoctlReassignBlocksEx(), DiskIoctlVerifyThread(), DiskModeSelect(), DiskPerformSmartCommand(), DiskShutdownFlush(), DrvEvaluateGtmObject(), EnumerateInstallations(), EnumerateReactOSEntries(), EvalCreateParametersList(), FreeLdrEnumerateBootEntries(), FstubWriteBootSectorEFI(), GetDiskBySignature(), GetHarddiskInformation(), HalAcpiGetTable(), HalpAcpiGetCachedTable(), HalpAcpiGetTable(), HalpAcpiGetTableFromBios(), ILCreateNetConnectItem(), InstallMbrBootCode(), IoGetBootDiskInformation(), IopCreateArcNamesDisk(), IopCreateLogFile(), IopVerifyDiskSignature(), IoReadDiskSignature(), main(), NtLdrEnumerateBootEntries(), parse_file(), PcInitializeBootDevices(), pInitializeStorageRequestBlock(), RemoveDatablock(), ResetBus(), test_EnumBuffer(), test_Functions(), test_GetBuffer(), test_pack_IMAGE_NT_HEADERS32(), test_pack_IMAGE_NT_HEADERS64(), test_pack_IMAGE_SEPARATE_DEBUG_HEADER(), test_pack_USER_MARSHAL_CB(), UefiInitializeBootDevices(), UpdateBootIni(), and UpdateFreeLoaderIni().

Version

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

static

Definition at line 140 of file parser.c.

Windows95

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

static

Definition at line 144 of file parser.c.

Referenced by parse_file().

WindowsNT

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

static

Definition at line 143 of file parser.c.

Referenced by parse_file().