[mupen64plus-pandora.git] / source / mupen64plus-input-sdl / src / autoconfig.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus-input-sdl - autoconfig.c                                  *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   Copyright (C) 2009-2013 Richard Goedeken                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <string.h>

#include "m64p_types.h"
#include "m64p_config.h"
#include "osal_preproc.h"
#include "autoconfig.h"
#include "plugin.h"

/* local definitions */
#define INI_FILE_NAME "InputAutoCfg.ini"
typedef struct {
    m64p_handle pSrc;
    m64p_handle pDst;
} SCopySection;

/* local functions */
static char *StripSpace(char *pIn)
{
    char *pEnd = pIn + strlen(pIn) - 1;

    while (*pIn == ' ' || *pIn == '\t' || *pIn == '\r' || *pIn == '\n')
        pIn++;

    while (pIn <= pEnd && (*pEnd == ' ' || *pEnd == '\t' || *pEnd == '\r' || *pEnd == '\n'))
        *pEnd-- = 0;

    return pIn;
}

static void CopyParamCallback(void * context, const char *ParamName, m64p_type ParamType)
{
    SCopySection *pCpyContext = (SCopySection *) context;
    int paramInt;
    float paramFloat;
    char paramString[1024];

    // handle the parameter copy depending upon type
    switch (ParamType)
    {
        case M64TYPE_INT:
        case M64TYPE_BOOL:
            if (ConfigGetParameter(pCpyContext->pSrc, ParamName, ParamType, &paramInt, sizeof(int)) == M64ERR_SUCCESS)
                ConfigSetParameter(pCpyContext->pDst, ParamName, ParamType, &paramInt);
            break;
        case M64TYPE_FLOAT:
            if (ConfigGetParameter(pCpyContext->pSrc, ParamName, ParamType, &paramFloat, sizeof(float)) == M64ERR_SUCCESS)
                ConfigSetParameter(pCpyContext->pDst, ParamName, ParamType, &paramFloat);
            break;
        case M64TYPE_STRING:
            if (ConfigGetParameter(pCpyContext->pSrc, ParamName, ParamType, paramString, 1024) == M64ERR_SUCCESS)
                ConfigSetParameter(pCpyContext->pDst, ParamName, ParamType, paramString);
            break;
        default:
            // this should never happen
            DebugMessage(M64MSG_ERROR, "Unknown source parameter type %i in copy callback", (int) ParamType);
            return;
    }
}

/* global functions */
int auto_copy_inputconfig(const char *pccSourceSectionName, const char *pccDestSectionName, const char *sdlJoyName)
{
    SCopySection cpyContext;

    if (ConfigOpenSection(pccSourceSectionName, &cpyContext.pSrc) != M64ERR_SUCCESS)
    {
        DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: Couldn't open source config section '%s' for copying", pccSourceSectionName);
        return 0;
    }

    if (ConfigOpenSection(pccDestSectionName, &cpyContext.pDst) != M64ERR_SUCCESS)
    {
        DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: Couldn't open destination config section '%s' for copying", pccDestSectionName);
        return 0;
    }

    // set the 'name' parameter
    if (sdlJoyName != NULL)
    {
        if (ConfigSetParameter(cpyContext.pDst, "name", M64TYPE_STRING, sdlJoyName) != M64ERR_SUCCESS)
        {
            DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: Couldn't set 'name' parameter to '%s' in section '%s'", sdlJoyName, pccDestSectionName);
            return 0;
        }
    }

    // the copy gets done by the callback function
    if (ConfigListParameters(cpyContext.pSrc, (void *) &cpyContext, CopyParamCallback) != M64ERR_SUCCESS)
    {
        DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: parameter list copy failed");
        return 0;
    }

    return 1;
}

int auto_set_defaults(int iDeviceIdx, const char *joySDLName)
{
    FILE *pfIn;
    m64p_handle pConfig = NULL;
    const char *CfgFilePath = ConfigGetSharedDataFilepath(INI_FILE_NAME);
    enum { E_NAME_SEARCH, E_NAME_FOUND, E_PARAM_READ } eParseState;
    char *pchIni, *pchNextLine, *pchCurLine;
    long iniLength;
    int ControllersFound = 0;

    /* if we couldn't get a name (no joystick plugged in to given port), then return with a failure */
    if (joySDLName == NULL)
        return 0;
    /* if we couldn't find the shared data file, dump an error and return */
    if (CfgFilePath == NULL || strlen(CfgFilePath) < 1)
    {
        DebugMessage(M64MSG_ERROR, "Couldn't find config file '%s'", INI_FILE_NAME);
        return 0;
    }

    /* read the input auto-config .ini file */
    pfIn = fopen(CfgFilePath, "rb");
    if (pfIn == NULL)
    {
        DebugMessage(M64MSG_ERROR, "Couldn't open config file '%s'", CfgFilePath);
        return 0;
    }
    fseek(pfIn, 0L, SEEK_END);
    iniLength = ftell(pfIn);
    fseek(pfIn, 0L, SEEK_SET);
    pchIni = (char *) malloc(iniLength + 1);
    if (pchIni == NULL)
    {
        DebugMessage(M64MSG_ERROR, "Couldn't allocate %li bytes for config file '%s'", iniLength, CfgFilePath);
        fclose(pfIn);
        return 0;
    }
    if (fread(pchIni, 1, iniLength, pfIn) != iniLength)
    {
        DebugMessage(M64MSG_ERROR, "File read failed for %li bytes of config file '%s'", iniLength, CfgFilePath);
        free(pchIni);
        fclose(pfIn);
        return 0;
    }
    fclose(pfIn);
    pchIni[iniLength] = 0;

    /* parse the INI file, line by line */
    pchNextLine = pchIni;
    eParseState = E_NAME_SEARCH;
    while (pchNextLine != NULL && *pchNextLine != 0)
    {
        char *pivot = NULL;
        /* set up character pointers */
        pchCurLine = pchNextLine;
        pchNextLine = strchr(pchNextLine, '\n');
        if (pchNextLine != NULL)
            *pchNextLine++ = 0;
        pchCurLine = StripSpace(pchCurLine);

        /* handle blank/comment lines */
        if (strlen(pchCurLine) < 1 || *pchCurLine == ';' || *pchCurLine == '#')
            continue;

        /* handle section (joystick name in ini file) */
        if (*pchCurLine == '[' && pchCurLine[strlen(pchCurLine)-1] == ']')
        {
            char Word[64];
            char *wordPtr;
            int  joyFound = 1;

            if (eParseState == E_PARAM_READ)
            {
                /* we've finished parsing all parameters for the discovered input device */
                free(pchIni);
                return ControllersFound;
            }
            else if (eParseState == E_NAME_FOUND)
            {
                /* this is an equivalent device name to the one we're looking for (and found); keep looking for parameters */
                continue;
            }
            /* we need to look through the device name word by word to see if it matches the joySDLName that we're looking for */ 
            pchCurLine[strlen(pchCurLine)-1] = 0;
            wordPtr = StripSpace(pchCurLine + 1);
            /* first, if there is a preceding system name in this .ini device name, and the system matches, then strip out */
#if defined(__unix__)
            if (strncmp(wordPtr, "Unix:", 5) == 0)
                wordPtr = StripSpace(wordPtr + 5);
#endif
#if defined(__linux__)
            if (strncmp(wordPtr, "Linux:", 6) == 0)
                wordPtr = StripSpace(wordPtr + 6);
#endif
#if defined(__APPLE__)
            if (strncmp(wordPtr, "OSX:", 4) == 0)
                wordPtr = StripSpace(wordPtr + 4);
#endif
#if defined(WIN32)
            if (strncmp(wordPtr, "Win32:", 6) == 0)
                wordPtr = StripSpace(wordPtr + 6);
#endif
            /* search in the .ini device name for all the words in the joystick name.  If any are missing, then this is not the right joystick model */
            while (wordPtr != NULL && strlen(wordPtr) > 0)
            {
                char *nextSpace = strchr(wordPtr, ' ');
                if (nextSpace == NULL)
                {
                    strncpy(Word, wordPtr, 63);
                    Word[63] = 0;
                    wordPtr = NULL;
                }
                else
                {
                    int length = (int) (nextSpace - wordPtr);
                    if (length > 63) length = 63;
                    strncpy(Word, wordPtr, length);
                    Word[length] = 0;
                    wordPtr = nextSpace + 1;
                }
                if (strcasestr(joySDLName, Word) == NULL)
                    joyFound = 0;
            }
            /* if we found the right joystick, then open up the core config section to store parameters and set the 'device' param */
            if (joyFound)
            {
                char SectionName[32];
                sprintf(SectionName, "AutoConfig%i", ControllersFound);
                if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS)
                {
                    DebugMessage(M64MSG_ERROR, "auto_set_defaults(): Couldn't open config section '%s'", SectionName);
                    free(pchIni);
                    return 0;
                }
                eParseState = E_NAME_FOUND;
                ControllersFound++;
                ConfigSetParameter(pConfig, "device", M64TYPE_INT, &iDeviceIdx);
            }
            continue;
        }

        /* handle parameters */
        pivot = strchr(pchCurLine, '=');
        if (pivot != NULL)
        {
            /* if we haven't found the correct section yet, just skip this */
            if (eParseState == E_NAME_SEARCH)
                continue;
            eParseState = E_PARAM_READ;
            /* otherwise, store this parameter in the current active joystick config */
            *pivot++ = 0;
            pchCurLine = StripSpace(pchCurLine);
            pivot = StripSpace(pivot);
            if (strcasecmp(pchCurLine, "plugin") == 0 || strcasecmp(pchCurLine, "device") == 0)
            {
                int iVal = atoi(pivot);
                ConfigSetParameter(pConfig, pchCurLine, M64TYPE_INT, &iVal);
            }
            else if (strcasecmp(pchCurLine, "plugged") == 0 || strcasecmp(pchCurLine, "mouse") == 0)
            {
                int bVal = (strcasecmp(pivot, "true") == 0);
                ConfigSetParameter(pConfig, pchCurLine, M64TYPE_BOOL, &bVal);
            }
            else
            {
                ConfigSetParameter(pConfig, pchCurLine, M64TYPE_STRING, pivot);
            }
            continue;
        }

        /* handle keywords */
        if (pchCurLine[strlen(pchCurLine)-1] == ':')
        {
            /* if we haven't found the correct section yet, just skip this */
            if (eParseState == E_NAME_SEARCH)
                continue;
            /* otherwise parse the keyword */
            if (strcmp(pchCurLine, "__NextController:") == 0)
            {
                char SectionName[32];
                /* if there are no more N64 controller spaces left, then exit */
                if (ControllersFound == 4)
                {
                    free(pchIni);
                    return ControllersFound;
                }
                /* otherwise go to the next N64 controller */
                sprintf(SectionName, "AutoConfig%i", ControllersFound);
                if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS)
                {
                    DebugMessage(M64MSG_ERROR, "auto_set_defaults(): Couldn't open config section '%s'", SectionName);
                    free(pchIni);
                    return ControllersFound;
                }
                ControllersFound++;
                ConfigSetParameter(pConfig, "device", M64TYPE_INT, &iDeviceIdx);
            }
            else
            {
                DebugMessage(M64MSG_ERROR, "Unknown keyword '%s' in %s", pchCurLine, INI_FILE_NAME);
            }
            continue;
        }

        /* unhandled line in .ini file */
        DebugMessage(M64MSG_ERROR, "Invalid line in %s: '%s'", INI_FILE_NAME, pchCurLine);
    }

    if (eParseState == E_PARAM_READ)
    {
        /* we've finished parsing all parameters for the discovered input device, which is the last in the .ini file */
        free(pchIni);
        return ControllersFound;
    }

    free(pchIni);
    return 0;
}
Commit	Line	Data
48d52ab5	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus-input-sdl - autoconfig.c *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2009-2013 Richard Goedeken *
	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	* This program is distributed in the hope that it will be useful, *
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	14	* GNU General Public License for more details. *
	15	* *
	16	* You should have received a copy of the GNU General Public License *
	17	* along with this program; if not, write to the *
	18	* Free Software Foundation, Inc., *
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	20	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	21
	22	#include <string.h>
	23
	24	#include "m64p_types.h"
	25	#include "m64p_config.h"
	26	#include "osal_preproc.h"
	27	#include "autoconfig.h"
	28	#include "plugin.h"
	29
	30	/* local definitions */
	31	#define INI_FILE_NAME "InputAutoCfg.ini"
	32	typedef struct {
	33	m64p_handle pSrc;
	34	m64p_handle pDst;
	35	} SCopySection;
	36
	37	/* local functions */
	38	static char StripSpace(char pIn)
	39	{
	40	char *pEnd = pIn + strlen(pIn) - 1;
	41
	42	while (pIn == ' ' \|\| pIn == '\t' \|\| pIn == '\r' \|\| pIn == '\n')
	43	pIn++;
	44
	45	while (pIn <= pEnd && (pEnd == ' ' \|\| pEnd == '\t' \|\| pEnd == '\r' \|\| pEnd == '\n'))
	46	*pEnd-- = 0;
	47
	48	return pIn;
	49	}
	50
	51	static void CopyParamCallback(void * context, const char *ParamName, m64p_type ParamType)
	52	{
	53	SCopySection pCpyContext = (SCopySection ) context;
	54	int paramInt;
	55	float paramFloat;
	56	char paramString[1024];
	57
	58	// handle the parameter copy depending upon type
	59	switch (ParamType)
	60	{
	61	case M64TYPE_INT:
	62	case M64TYPE_BOOL:
	63	if (ConfigGetParameter(pCpyContext->pSrc, ParamName, ParamType, &paramInt, sizeof(int)) == M64ERR_SUCCESS)
	64	ConfigSetParameter(pCpyContext->pDst, ParamName, ParamType, &paramInt);
65	break;
66	case M64TYPE_FLOAT:
67	if (ConfigGetParameter(pCpyContext->pSrc, ParamName, ParamType, &paramFloat, sizeof(float)) == M64ERR_SUCCESS)
68	ConfigSetParameter(pCpyContext->pDst, ParamName, ParamType, &paramFloat);
69	break;
70	case M64TYPE_STRING:
71	if (ConfigGetParameter(pCpyContext->pSrc, ParamName, ParamType, paramString, 1024) == M64ERR_SUCCESS)
72	ConfigSetParameter(pCpyContext->pDst, ParamName, ParamType, paramString);
73	break;
74	default:
75	// this should never happen
76	DebugMessage(M64MSG_ERROR, "Unknown source parameter type %i in copy callback", (int) ParamType);
77	return;
78	}
79	}
80
81	/* global functions */
82	int auto_copy_inputconfig(const char pccSourceSectionName, const char pccDestSectionName, const char *sdlJoyName)
83	{
84	SCopySection cpyContext;
85
86	if (ConfigOpenSection(pccSourceSectionName, &cpyContext.pSrc) != M64ERR_SUCCESS)
87	{
88	DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: Couldn't open source config section '%s' for copying", pccSourceSectionName);
89	return 0;
90	}
91
92	if (ConfigOpenSection(pccDestSectionName, &cpyContext.pDst) != M64ERR_SUCCESS)
93	{
94	DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: Couldn't open destination config section '%s' for copying", pccDestSectionName);
95	return 0;
96	}
97
98	// set the 'name' parameter
99	if (sdlJoyName != NULL)
100	{
101	if (ConfigSetParameter(cpyContext.pDst, "name", M64TYPE_STRING, sdlJoyName) != M64ERR_SUCCESS)
102	{
103	DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: Couldn't set 'name' parameter to '%s' in section '%s'", sdlJoyName, pccDestSectionName);
104	return 0;
105	}
106	}
107
108	// the copy gets done by the callback function
109	if (ConfigListParameters(cpyContext.pSrc, (void *) &cpyContext, CopyParamCallback) != M64ERR_SUCCESS)
110	{
111	DebugMessage(M64MSG_ERROR, "auto_copy_inputconfig: parameter list copy failed");
112	return 0;
113	}
114
115	return 1;
116	}
117
118	int auto_set_defaults(int iDeviceIdx, const char *joySDLName)
119	{
120	FILE *pfIn;
121	m64p_handle pConfig = NULL;
122	const char *CfgFilePath = ConfigGetSharedDataFilepath(INI_FILE_NAME);
123	enum { E_NAME_SEARCH, E_NAME_FOUND, E_PARAM_READ } eParseState;
124	char pchIni, pchNextLine, *pchCurLine;
125	long iniLength;
126	int ControllersFound = 0;
127
128	/* if we couldn't get a name (no joystick plugged in to given port), then return with a failure */
129	if (joySDLName == NULL)
130	return 0;
131	/* if we couldn't find the shared data file, dump an error and return */
132	if (CfgFilePath == NULL \|\| strlen(CfgFilePath) < 1)
133	{
134	DebugMessage(M64MSG_ERROR, "Couldn't find config file '%s'", INI_FILE_NAME);
135	return 0;
136	}
137
138	/* read the input auto-config .ini file */
139	pfIn = fopen(CfgFilePath, "rb");
140	if (pfIn == NULL)
141	{
142	DebugMessage(M64MSG_ERROR, "Couldn't open config file '%s'", CfgFilePath);
143	return 0;
144	}
145	fseek(pfIn, 0L, SEEK_END);
146	iniLength = ftell(pfIn);
147	fseek(pfIn, 0L, SEEK_SET);
148	pchIni = (char *) malloc(iniLength + 1);
149	if (pchIni == NULL)
150	{
151	DebugMessage(M64MSG_ERROR, "Couldn't allocate %li bytes for config file '%s'", iniLength, CfgFilePath);
152	fclose(pfIn);
153	return 0;
154	}
155	if (fread(pchIni, 1, iniLength, pfIn) != iniLength)
156	{
157	DebugMessage(M64MSG_ERROR, "File read failed for %li bytes of config file '%s'", iniLength, CfgFilePath);
158	free(pchIni);
159	fclose(pfIn);
160	return 0;
161	}
162	fclose(pfIn);
163	pchIni[iniLength] = 0;
164
165	/* parse the INI file, line by line */
166	pchNextLine = pchIni;
167	eParseState = E_NAME_SEARCH;
168	while (pchNextLine != NULL && *pchNextLine != 0)
169	{
170	char *pivot = NULL;
171	/* set up character pointers */
172	pchCurLine = pchNextLine;
173	pchNextLine = strchr(pchNextLine, '\n');
174	if (pchNextLine != NULL)
175	*pchNextLine++ = 0;
176	pchCurLine = StripSpace(pchCurLine);
177
178	/* handle blank/comment lines */
179	if (strlen(pchCurLine) < 1 \|\| pchCurLine == ';' \|\| pchCurLine == '#')
180	continue;
181
182	/* handle section (joystick name in ini file) */
183	if (*pchCurLine == '[' && pchCurLine[strlen(pchCurLine)-1] == ']')
184	{
185	char Word[64];
186	char *wordPtr;
187	int joyFound = 1;
188
189	if (eParseState == E_PARAM_READ)
190	{
191	/* we've finished parsing all parameters for the discovered input device */
192	free(pchIni);
193	return ControllersFound;
194	}
195	else if (eParseState == E_NAME_FOUND)
196	{
197	/* this is an equivalent device name to the one we're looking for (and found); keep looking for parameters */
198	continue;
199	}
200	/* we need to look through the device name word by word to see if it matches the joySDLName that we're looking for */
201	pchCurLine[strlen(pchCurLine)-1] = 0;
202	wordPtr = StripSpace(pchCurLine + 1);
203	/* first, if there is a preceding system name in this .ini device name, and the system matches, then strip out */
204	#if defined(__unix__)
205	if (strncmp(wordPtr, "Unix:", 5) == 0)
206	wordPtr = StripSpace(wordPtr + 5);
207	#endif
208	#if defined(__linux__)
209	if (strncmp(wordPtr, "Linux:", 6) == 0)
210	wordPtr = StripSpace(wordPtr + 6);
211	#endif
212	#if defined(__APPLE__)
213	if (strncmp(wordPtr, "OSX:", 4) == 0)
214	wordPtr = StripSpace(wordPtr + 4);
215	#endif
216	#if defined(WIN32)
217	if (strncmp(wordPtr, "Win32:", 6) == 0)
218	wordPtr = StripSpace(wordPtr + 6);
219	#endif
220	/* search in the .ini device name for all the words in the joystick name. If any are missing, then this is not the right joystick model */
221	while (wordPtr != NULL && strlen(wordPtr) > 0)
222	{
223	char *nextSpace = strchr(wordPtr, ' ');
224	if (nextSpace == NULL)
225	{
226	strncpy(Word, wordPtr, 63);
227	Word[63] = 0;
228	wordPtr = NULL;
229	}
230	else
231	{
232	int length = (int) (nextSpace - wordPtr);
233	if (length > 63) length = 63;
234	strncpy(Word, wordPtr, length);
235	Word[length] = 0;
236	wordPtr = nextSpace + 1;
237	}
238	if (strcasestr(joySDLName, Word) == NULL)
239	joyFound = 0;
240	}
241	/* if we found the right joystick, then open up the core config section to store parameters and set the 'device' param */
242	if (joyFound)
243	{
244	char SectionName[32];
245	sprintf(SectionName, "AutoConfig%i", ControllersFound);
246	if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS)
247	{
248	DebugMessage(M64MSG_ERROR, "auto_set_defaults(): Couldn't open config section '%s'", SectionName);
249	free(pchIni);
250	return 0;
251	}
252	eParseState = E_NAME_FOUND;
253	ControllersFound++;
254	ConfigSetParameter(pConfig, "device", M64TYPE_INT, &iDeviceIdx);
255	}
256	continue;
257	}
258
259	/* handle parameters */
260	pivot = strchr(pchCurLine, '=');
261	if (pivot != NULL)
262	{
263	/* if we haven't found the correct section yet, just skip this */
264	if (eParseState == E_NAME_SEARCH)
265	continue;
266	eParseState = E_PARAM_READ;
267	/* otherwise, store this parameter in the current active joystick config */
268	*pivot++ = 0;
269	pchCurLine = StripSpace(pchCurLine);
270	pivot = StripSpace(pivot);
271	if (strcasecmp(pchCurLine, "plugin") == 0 \|\| strcasecmp(pchCurLine, "device") == 0)
272	{
273	int iVal = atoi(pivot);
274	ConfigSetParameter(pConfig, pchCurLine, M64TYPE_INT, &iVal);
275	}
276	else if (strcasecmp(pchCurLine, "plugged") == 0 \|\| strcasecmp(pchCurLine, "mouse") == 0)
277	{
278	int bVal = (strcasecmp(pivot, "true") == 0);
279	ConfigSetParameter(pConfig, pchCurLine, M64TYPE_BOOL, &bVal);
280	}
281	else
282	{
283	ConfigSetParameter(pConfig, pchCurLine, M64TYPE_STRING, pivot);
284	}
285	continue;
286	}
287
288	/* handle keywords */
289	if (pchCurLine[strlen(pchCurLine)-1] == ':')
290	{
291	/* if we haven't found the correct section yet, just skip this */
292	if (eParseState == E_NAME_SEARCH)
293	continue;
294	/* otherwise parse the keyword */
295	if (strcmp(pchCurLine, "__NextController:") == 0)
296	{
297	char SectionName[32];
298	/* if there are no more N64 controller spaces left, then exit */
299	if (ControllersFound == 4)
300	{
301	free(pchIni);
302	return ControllersFound;
303	}
304	/* otherwise go to the next N64 controller */
305	sprintf(SectionName, "AutoConfig%i", ControllersFound);
306	if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS)
307	{
308	DebugMessage(M64MSG_ERROR, "auto_set_defaults(): Couldn't open config section '%s'", SectionName);
309	free(pchIni);
310	return ControllersFound;
311	}
312	ControllersFound++;
313	ConfigSetParameter(pConfig, "device", M64TYPE_INT, &iDeviceIdx);
314	}
315	else
316	{
317	DebugMessage(M64MSG_ERROR, "Unknown keyword '%s' in %s", pchCurLine, INI_FILE_NAME);
318	}
319	continue;
320	}
321
322	/* unhandled line in .ini file */
323	DebugMessage(M64MSG_ERROR, "Invalid line in %s: '%s'", INI_FILE_NAME, pchCurLine);
324	}
325
326	if (eParseState == E_PARAM_READ)
327	{
328	/* we've finished parsing all parameters for the discovered input device, which is the last in the .ini file */
329	free(pchIni);
330	return ControllersFound;
331	}
332
333	free(pchIni);
334	return 0;
335	}
336
337