DWORD RegLexParseDefaultState( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state == REGLEX_STATE_IN_QUOTE || lexHandle->state == REGLEX_STATE_IN_KEY) { /* Append current character to string */ RegLexAppendChar(lexHandle, inC); } else if (lexHandle->state == REGLEX_STATE_BINHEX_STR) { if (inC == ' ' || inC == ',') { /* Eat white spaces in binhex strings */ lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_HEXPAIR; return dwError; } if (!isxdigit((int)inC)) { dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; return dwError; } if (lexHandle->curToken.valueCursor == 2) { dwError = RegIOUnGetChar(ioHandle, &inC); lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_HEXPAIR; return dwError; } RegLexAppendChar(lexHandle, inC); } else { RegLexAppendChar(lexHandle, inC); if (lexHandle->state != REGLEX_STATE_DWORD) { lexHandle->curToken.token = REGLEX_PLAIN_TEXT; } #ifdef _LW_DEBUG if (lexHandle->state != REGLEX_STATE_IN_QUOTE && lexHandle->state != REGLEX_STATE_IN_KEY && lexHandle->state != REGLEX_STATE_BINHEX_STR) { printf("<%c> <%02x>\n", inC, inC); } #endif } return dwError; }
DWORD RegLexParseDash( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; BOOLEAN eof = FALSE; BOOLEAN isDash = FALSE; if (lexHandle->curToken.pszValue[lexHandle->curToken.valueCursor] == '-') { isDash = TRUE; } else { dwError = RegIOGetChar(ioHandle, &inC, &eof); if (inC == '\r' || inC == '\n') { isDash = TRUE; } else if (inC != '-') { RegLexAppendChar(lexHandle, '-'); RegLexAppendChar(lexHandle, inC); return dwError; } else { dwError = RegIOUnGetChar(ioHandle, NULL); isDash = TRUE; } } if (isDash && lexHandle->state != REGLEX_STATE_IN_QUOTE && lexHandle->state != REGLEX_STATE_IN_KEY && lexHandle->eValueNameType != REGLEX_VALUENAME_SECURITY) { if (lexHandle->curToken.valueCursor > 0) { dwError = RegIOUnGetChar(ioHandle, NULL); lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } else { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_DASH; lexHandle->curToken.valueCursor = 0; RegLexAppendChar(lexHandle, inC); } } else { RegLexAppendChar(lexHandle, inC); } return dwError; }
DWORD RegLexParseAt( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; BOOLEAN eof = FALSE; BOOLEAN bHasSecurity = FALSE; if (lexHandle->state != REGLEX_STATE_IN_QUOTE && lexHandle->state != REGLEX_STATE_IN_KEY) { /* Default value for a registry key */ lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_KEY_NAME_DEFAULT; lexHandle->state = REGLEX_STATE_INIT; lexHandle->curToken.valueCursor = 0; RegLexAppendChar(lexHandle, inC); /* Handle the case of @frob, i.e. "@security" */ dwError = RegIOGetChar(ioHandle, &inC, &eof); while (dwError == 0 && !eof && isalpha((int) inC)) { RegLexAppendChar(lexHandle, inC); dwError = RegIOGetChar(ioHandle, &inC, &eof); bHasSecurity = TRUE; } if (eof) { return dwError; } dwError = RegIOUnGetChar(ioHandle, NULL); if (bHasSecurity) { if (strcmp(lexHandle->curToken.pszValue, "@security") == 0) { lexHandle->eValueNameType = REGLEX_VALUENAME_SECURITY; } else { dwError = LWREG_ERROR_UNEXPECTED_TOKEN; } } } return dwError; }
DWORD RegLexParseComment( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; BOOLEAN eof = FALSE; if (lexHandle->state == REGLEX_STATE_IN_QUOTE || lexHandle->state == REGLEX_STATE_IN_KEY) { RegLexAppendChar(lexHandle, inC); } else { do { dwError = RegIOGetChar(ioHandle, &inC, &eof); } while (dwError == 0 && !eof && inC != '\n' && inC != '\r'); if (!eof && (inC == '\n' || inC == '\r')) { dwError = RegIOUnGetChar(ioHandle, NULL); } } return dwError; }
DWORD RegLexParseComma( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state != REGLEX_STATE_IN_QUOTE && lexHandle->state != REGLEX_STATE_IN_KEY) { if (lexHandle->curToken.valueCursor > 0 && lexHandle->curToken.valueCursor <=2) { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_HEXPAIR; } else { /* Syntax error: Hex pair is only 2 characters */ dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } } else { RegLexAppendChar(lexHandle, inC); } return dwError; }
DWORD RegLexParseEquals( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state != REGLEX_STATE_IN_QUOTE && lexHandle->state != REGLEX_STATE_IN_KEY) { if (lexHandle->curToken.valueCursor > 0) { dwError = RegIOUnGetChar(ioHandle, NULL); lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } else { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_EQUALS; lexHandle->curToken.valueCursor = 0; } } else { RegLexAppendChar(lexHandle, inC); } return dwError; }
DWORD RegLexParseCloseBrace( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state != REGLEX_STATE_IN_QUOTE && lexHandle->state != REGLEX_STATE_IN_KEY) { if (lexHandle->eValueNameType != REGLEX_VALUENAME_ATTRIBUTES) { /* This is a problem, can't have } without a previous { */ dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } else { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_ATTRIBUTES_END; lexHandle->state = REGLEX_STATE_INIT; } } else { RegLexAppendChar(lexHandle, inC); } return dwError; }
DWORD RegLexParseCloseBracket( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state != REGLEX_STATE_IN_QUOTE) { lexHandle->curToken.token = REGLEX_KEY_SUFFIX; if (lexHandle->state != REGLEX_STATE_IN_KEY) { /* This is a problem, can't have ] without a previous [ */ dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } else { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_REG_KEY; lexHandle->state = REGLEX_STATE_INIT; } } else { RegLexAppendChar(lexHandle, inC); } return dwError; }
DWORD RegLexParseColon( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state == REGLEX_STATE_IN_QUOTE || lexHandle->state == REGLEX_STATE_IN_KEY || lexHandle->eValueNameType == REGLEX_VALUENAME_SECURITY) { RegLexAppendChar(lexHandle, inC); return dwError; } return RegLexParseBinary(lexHandle); }
DWORD RegLexParseQuote( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->curToken.token == REGLEX_PLAIN_TEXT) { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; dwError = RegIOUnGetChar(ioHandle, NULL); return dwError; } /* * Track state of "in quote" and "out quote" since * the same character begins/ends a string literal. * This is further complicated by escaped '\"' sequences * which are a literal quote in a quoted string. */ if (lexHandle->state == REGLEX_STATE_IN_KEY) { RegLexAppendChar(lexHandle, inC); } else if (lexHandle->state != REGLEX_STATE_IN_QUOTE) { /* Close quote found, done with current string */ lexHandle->curToken.token = REGLEX_QUOTE_BEGIN; lexHandle->state = REGLEX_STATE_IN_QUOTE; lexHandle->curToken.valueCursor = 0; lexHandle->curToken.pszValue[lexHandle->curToken.valueCursor] = '\0'; } else { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_REG_SZ; lexHandle->state = REGLEX_STATE_INIT; return dwError; } return dwError; }
DWORD RegLexParseWhitespace( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state == REGLEX_STATE_IN_QUOTE || lexHandle->state == REGLEX_STATE_IN_KEY) { RegLexAppendChar(lexHandle, inC); } else if (lexHandle->state == REGLEX_STATE_BINHEX_STR) { if (lexHandle->curToken.valueCursor > 0 && lexHandle->curToken.valueCursor <= 2) { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_HEXPAIR; } } else { dwError = RegLexParseBinary(lexHandle); if (dwError || lexHandle->isToken) { lexHandle->curToken.lineNum = lexHandle->parseLineNum; return dwError; } if (lexHandle->curToken.token != REGLEX_FIRST) { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } } return dwError; }
DWORD RegLexParseOpenBrace( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->state != REGLEX_STATE_IN_QUOTE && lexHandle->state != REGLEX_STATE_IN_KEY) { lexHandle->curToken.token = REGLEX_ATTRIBUTES_BEGIN; if (lexHandle->eValueNameType == REGLEX_VALUENAME_ATTRIBUTES) { /* This is a problem, can't have { then another { */ dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } else if (!lexHandle->curToken.pszValue || !lexHandle->curToken.pszValue[0]) { dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } else { lexHandle->curToken.token = REGLEX_ATTRIBUTES_BEGIN; lexHandle->eValueNameType = REGLEX_VALUENAME_ATTRIBUTES; lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.valueCursor = 0; } } else { RegLexAppendChar(lexHandle, inC); } return dwError; }
DWORD RegLexParseOpenBracket( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; if (lexHandle->curToken.token == REGLEX_PLAIN_TEXT) { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; dwError = RegIOUnGetChar(ioHandle, NULL); return dwError; } if (lexHandle->state != REGLEX_STATE_IN_QUOTE) { lexHandle->curToken.token = REGLEX_KEY_PREFIX; if (lexHandle->state == REGLEX_STATE_IN_KEY) { /* This is a problem, can't have [ then another [ */ dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; } else { lexHandle->curToken.token = REGLEX_KEY_PREFIX; lexHandle->state = REGLEX_STATE_IN_KEY; lexHandle->curToken.valueCursor = 0; } } else { RegLexAppendChar(lexHandle, inC); } return dwError; }
DWORD RegLexParseNewline( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; CHAR prevC = '\0'; BOOLEAN eof = 0; if (lexHandle->state != REGLEX_STATE_IN_QUOTE) { /* * Throw out CR when not in a quoted string. CR/LF * is still handled correctly by this treatment. */ if (inC == '\r') { return dwError; } } else { /* * Count CR/LF sequence in a quoted string as a single newline. * A bare CR is maintained, but not counted as a newline. */ if (inC == '\r') { RegLexAppendChar(lexHandle, inC); dwError = RegIOGetChar(ioHandle, &inC, &eof); if (eof) { return dwError; } if (inC == '\n') { RegLexAppendChar(lexHandle, inC); lexHandle->parseLineNum++; } else { dwError = RegIOUnGetChar(ioHandle, &inC); } } } if (lexHandle->state != REGLEX_STATE_IN_QUOTE) { lexHandle->parseLineNum++; } /* Emit the final token in a BINHEX_STR sequence */ if (lexHandle->state == REGLEX_STATE_BINHEX_STR) { /* Don't care about "\\n sequence */ dwError = RegIOGetPrevChar(ioHandle, &prevC); if (dwError == ERROR_SUCCESS && prevC == '\\') { return dwError; } lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_HEXPAIR_END; lexHandle->state = REGLEX_STATE_INIT; return dwError; } else if (lexHandle->tokenDataType == REGLEX_REG_STRING_ARRAY) { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->tokenDataType = REGLEX_FIRST; return dwError; } else if (lexHandle->state == REGLEX_STATE_DWORD) { if (lexHandle->curToken.valueCursor == 8) { lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum; lexHandle->curToken.token = REGLEX_REG_DWORD; return dwError; } else { dwError = LWREG_ERROR_UNEXPECTED_TOKEN; lexHandle->curToken.lineNum = lexHandle->parseLineNum; return dwError; } } else if ((lexHandle->state == REGLEX_STATE_INIT || lexHandle->state == REGLEX_STATE_INTEGER_RANGE) && lexHandle->curToken.valueCursor > 0) { /* * This is "junk" accumulated so far, since no valid token start * has been found before the current end-of-line. */ lexHandle->isToken = TRUE; lexHandle->curToken.lineNum = lexHandle->parseLineNum - 1; lexHandle->curToken.token = REGLEX_PLAIN_TEXT; return dwError; } else { /* Syntax error case... */ /* Error needed */ } return dwError; }
DWORD RegLexParseBackslash( PREGLEX_ITEM lexHandle, HANDLE ioHandle, CHAR inC) { DWORD dwError = 0; BOOLEAN eof = FALSE; if (lexHandle->state == REGLEX_STATE_BINHEX_STR || lexHandle->tokenDataType == REGLEX_REG_STRING_ARRAY) { /* Eat line continuation character when in BINHEX state */ dwError = RegIOGetChar(ioHandle, &inC, &eof); if (eof) { return dwError; } if (inC == '\r' || inC == '\n') { lexHandle->parseLineNum++; dwError = RegIOGetChar(ioHandle, &inC, &eof); if (eof) { return dwError; } if (inC != '\r' && inC != '\n') { dwError = RegIOUnGetChar(ioHandle, NULL); } } else { dwError = RegIOUnGetChar(ioHandle, NULL); } } if (lexHandle->state == REGLEX_STATE_IN_QUOTE) { /* * Treat sequence '\C' (C=any character) as * the literal escaped character. Only handle backslashes * in this way when in quoted strings. When processing a * registry key value, this is a "bad thing" to do. * [HKEY_LOCAL_MACHINE\HARDWARE] * This processing in this case would be an escaped 'H', not * what is intended. */ dwError = RegIOGetChar(ioHandle, &inC, &eof); if (!eof) { switch(inC) { case 'n': RegLexAppendChar(lexHandle, '\n'); break; case 'r': RegLexAppendChar(lexHandle, '\r'); break; case 't': RegLexAppendChar(lexHandle, '\t'); break; case 'a': RegLexAppendChar(lexHandle, '\a'); break; case 'v': RegLexAppendChar(lexHandle, '\v'); break; case 'f': RegLexAppendChar(lexHandle, '\f'); break; case '\\': RegLexAppendChar(lexHandle, '\\'); break; case '"': RegLexAppendChar(lexHandle, '"'); break; default: RegLexAppendChar(lexHandle, '\\'); RegLexAppendChar(lexHandle, inC); break; } } } else if (lexHandle->state == REGLEX_STATE_IN_KEY) { RegLexAppendChar(lexHandle, '\\'); } else if (lexHandle->state != REGLEX_STATE_BINHEX_STR) { RegLexAppendChar(lexHandle, '\\'); } lexHandle->curToken.lineNum = lexHandle->parseLineNum; return dwError; }