/*++ | |
Copyright (c) 2004, Intel Corporation | |
All rights reserved. This program and the accompanying materials | |
are licensed and made available under the terms and conditions of the BSD License | |
which accompanies this distribution. The full text of the license may be found at | |
http://opensource.org/licenses/bsd-license.php | |
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
Module Name: | |
DepexParser.c | |
Abstract: | |
Validate Dependency Expression syntax | |
recursive descent Algorithm | |
The original BNF grammar(taken from "Pre EFI Initialization Core Interface Specification | |
draft review 0.9") is thus: | |
<depex> ::= BEFORE <guid> END | |
| AFTER <guid> END | |
| SOR <bool> END | |
| <bool> END | |
<bool> ::= <bool> AND <term> | |
| <bool> OR <term> | |
| <term> | |
<term> ::= NOT <factor> | |
| <factor> | |
<factor> ::= <bool> | |
| TRUE | |
| FALSE | |
| GUID | |
<guid> ::= '{' <hex32> ',' <hex16> ',' <hex16> ',' | |
<hex8> ',' <hex8> ',' <hex8> ',' <hex8> ',' | |
<hex8> ',' <hex8> ',' <hex8> ',' <hex8> '}' | |
<hex32> ::= <hexprefix> <hexvalue> | |
<hex16> ::= <hexprefix> <hexvalue> | |
<hex8> ::= <hexprefix> <hexvalue> | |
<hexprefix>::= '0' 'x' | |
| '0' 'X' | |
<hexvalue> ::= <hexdigit> <hexvalue> | |
| <hexdigit> | |
<hexdigit> ::= [0-9] | |
| [a-f] | |
| [A-F] | |
After cleaning left recursive and parentheses supported, the BNF grammar used in this module is thus: | |
<depex> ::= BEFORE <guid> | |
| AFTER <guid> | |
| SOR <bool> | |
| <bool> | |
<bool> ::= <term><rightbool> | |
<rightbool>::= AND <term><rightbool> | |
| OR <term><rightbool> | |
| '' | |
<term> ::= NOT <factor> | |
| <factor> | |
<factor> ::= '('<bool>')'<rightfactor> | |
| NOT <factor> <rightbool> <rightfactor> | |
| TRUE <rightfactor> | |
| FALSE <rightfactor> | |
| END <rightfactor> | |
| <guid> <rightfactor> | |
<rightfactor> ::=AND <term><rightbool> <rightfactor> | |
| OR <term><rightbool> <rightfactor> | |
| '' | |
<guid> ::= '{' <hex32> ',' <hex16> ',' <hex16> ',' | |
<hex8> ',' <hex8> ',' <hex8> ',' <hex8> ',' | |
<hex8> ',' <hex8> ',' <hex8> ',' <hex8> '}' | |
<hex32> ::= <hexprefix> <hexvalue> | |
<hex16> ::= <hexprefix> <hexvalue> | |
<hex8> ::= <hexprefix> <hexvalue> | |
<hexprefix>::= '0' 'x' | |
| '0' 'X' | |
<hexvalue> ::= <hexdigit> <hexvalue> | |
| <hexdigit> | |
<hexdigit> ::= [0-9] | |
| [a-f] | |
| [A-F] | |
Note: 1. There's no precedence in operators except parentheses; | |
2. For hex32, less and equal than 8 bits is valid, more than 8 bits is invalid. | |
Same constraint for hex16 is 4, hex8 is 2. All hex should contains at least 1 bit. | |
3. "<factor> ::= '('<bool>')'<rightfactor>" is added to support parentheses; | |
4. "<factor> ::= GUID" is changed to "<factor> ::= <guid>"; | |
5. "DEPENDENCY_END" is the terminal of the expression. But it has been filtered by caller. | |
During parsing, "DEPENDENCY_END" will be treated as illegal factor; | |
This code should build in any environment that supports a standard C-library w/ string | |
operations and File I/O services. | |
As an example of usage, consider the following: | |
The input string could be something like: | |
NOT ({ 0xce345171, 0xba0b, 0x11d2, 0x8e, 0x4f, 0x0, 0xa0, 0xc9, 0x69, 0x72, | |
0x3b } AND { 0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, | |
0x72, 0x3b }) OR { 0x03c4e603, 0xac28, 0x11d3, 0x9a, 0x2d, 0x00, 0x90, 0x27, | |
0x3f, 0xc1, 0x4d } AND | |
It's invalid for an extra "AND" in the end. | |
Complies with Tiano C Coding Standards Document, version 0.33, 16 Aug 2001. | |
--*/ | |
#include "DepexParser.h" | |
BOOLEAN | |
ParseBool ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
); | |
BOOLEAN | |
ParseTerm ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
); | |
BOOLEAN | |
ParseRightBool ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
); | |
BOOLEAN | |
ParseFactor ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
); | |
VOID | |
LeftTrim ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Left trim the space, '\n' and '\r' character in string. | |
The space at the end does not need trim. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
None | |
--*/ | |
{ | |
while | |
( | |
((*Pindex) < (Pbegin + length)) && | |
((strncmp (*Pindex, " ", 1) == 0) || (strncmp (*Pindex, "\n", 1) == 0) || (strncmp (*Pindex, "\r", 1) == 0)) | |
) { | |
(*Pindex)++; | |
} | |
} | |
BOOLEAN | |
ParseHexdigit ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse Hex bit in dependency expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length Length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If parses a valid hex bit, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
// | |
// <hexdigit> ::= [0-9] | [a-f] | [A-F] | |
// | |
if (((**Pindex) >= '0' && (**Pindex) <= '9') || | |
((**Pindex) >= 'a' && (**Pindex) <= 'f') || | |
((**Pindex) >= 'A' && (**Pindex) <= 'F') | |
) { | |
(*Pindex)++; | |
return TRUE; | |
} else { | |
return FALSE; | |
} | |
} | |
BOOLEAN | |
ParseHex32 ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse Hex32 in dependency expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length Length of the string | |
Pindex The pointer of point to the next parse character in the string | |
Returns: | |
BOOLEAN If parses a valid hex32, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
INT32 Index; | |
INT8 *Pin; | |
Index = 0; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
if ((strncmp (*Pindex, "0x", 2) != 0) && (strncmp (*Pindex, "0X", 2) != 0)) { | |
return FALSE; | |
} | |
(*Pindex) += 2; | |
while (ParseHexdigit (Pbegin, length, Pindex)) { | |
Index++; | |
} | |
if (Index > 0 && Index <= 8) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
} | |
BOOLEAN | |
ParseHex16 ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse Hex16 in dependency expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length Length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If parses a valid hex16, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
int Index; | |
INT8 *Pin; | |
Index = 0; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
if ((strncmp (*Pindex, "0x", 2) != 0) && (strncmp (*Pindex, "0X", 2) != 0)) { | |
return FALSE; | |
} | |
(*Pindex) += 2; | |
while (ParseHexdigit (Pbegin, length, Pindex)) { | |
Index++; | |
} | |
if (Index > 0 && Index <= 4) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
} | |
BOOLEAN | |
ParseHex8 ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse Hex8 in dependency expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length Length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If parses a valid hex8, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
int Index; | |
INT8 *Pin; | |
Index = 0; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
if ((strncmp (*Pindex, "0x", 2) != 0) && (strncmp (*Pindex, "0X", 2) != 0)) { | |
return FALSE; | |
} | |
(*Pindex) += 2; | |
while (ParseHexdigit (Pbegin, length, Pindex)) { | |
Index++; | |
} | |
if (Index > 0 && Index <= 2) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
} | |
BOOLEAN | |
ParseGuid ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse guid in dependency expression. | |
There can be any number of spaces between '{' and hexword, ',' and hexword, | |
hexword and ',', hexword and '}'. The hexword include hex32, hex16 and hex8. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If parses a valid guid, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
INT32 Index; | |
INT8 *Pin; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, "{", 1) != 0) { | |
return FALSE; | |
} | |
(*Pindex)++; | |
LeftTrim (Pbegin, length, Pindex); | |
if (!ParseHex32 (Pbegin, length, Pindex)) { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, ",", 1) != 0) { | |
return FALSE; | |
} else { | |
(*Pindex)++; | |
} | |
for (Index = 0; Index < 2; Index++) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (!ParseHex16 (Pbegin, length, Pindex)) { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, ",", 1) != 0) { | |
return FALSE; | |
} else { | |
(*Pindex)++; | |
} | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, "{", 1) != 0) { | |
return FALSE; | |
} | |
(*Pindex)++; | |
for (Index = 0; Index < 7; Index++) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (!ParseHex8 (Pbegin, length, Pindex)) { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, ",", 1) != 0) { | |
return FALSE; | |
} else { | |
(*Pindex)++; | |
} | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
if (!ParseHex8 (Pbegin, length, Pindex)) { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, "}", 1) != 0) { | |
return FALSE; | |
} else { | |
(*Pindex)++; | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, "}", 1) != 0) { | |
return FALSE; | |
} else { | |
(*Pindex)++; | |
} | |
return TRUE; | |
} | |
BOOLEAN | |
ParseRightFactor ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse rightfactor in bool expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If string is a valid rightfactor expression, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
INT8 *Pin; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
// | |
// <rightfactor> ::=AND <term> <rightbool> <rightfactor> | |
// | |
if (strncmp (*Pindex, OPERATOR_AND, strlen (OPERATOR_AND)) == 0) { | |
*Pindex += strlen (OPERATOR_AND); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseTerm (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightBool (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
// | |
// <rightfactor> ::=OR <term> <rightbool> <rightfactor> | |
// | |
if (strncmp (*Pindex, OPERATOR_OR, strlen (OPERATOR_OR)) == 0) { | |
*Pindex += strlen (OPERATOR_OR); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseTerm (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightBool (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
// | |
// <rightfactor> ::= '' | |
// | |
*Pindex = Pin; | |
return TRUE; | |
} | |
BOOLEAN | |
ParseRightBool ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse rightbool in bool expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If string is a valid rightbool expression, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
INT8 *Pin; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
// | |
// <rightbool>::= AND <term><rightbool> | |
// | |
if (strncmp (*Pindex, OPERATOR_AND, strlen (OPERATOR_AND)) == 0) { | |
*Pindex += strlen (OPERATOR_AND); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseTerm (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightBool (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
// | |
// <rightbool>::= OR <term><rightbool> | |
// | |
if (strncmp (*Pindex, OPERATOR_OR, strlen (OPERATOR_OR)) == 0) { | |
*Pindex += strlen (OPERATOR_OR); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseTerm (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightBool (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
// | |
// <rightbool>::= '' | |
// | |
*Pindex = Pin; | |
return TRUE; | |
} | |
BOOLEAN | |
ParseFactor ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse factor in bool expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If string is a valid factor, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
INT8 *Pin; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
// | |
// <factor> ::= '('<bool>')'<rightfactor> | |
// | |
if (strncmp (*Pindex, OPERATOR_LEFT_PARENTHESIS, strlen (OPERATOR_LEFT_PARENTHESIS)) == 0) { | |
*Pindex += strlen (OPERATOR_LEFT_PARENTHESIS); | |
LeftTrim (Pbegin, length, Pindex); | |
if (!ParseBool (Pbegin, length, Pindex)) { | |
*Pindex = Pin; | |
} else { | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, OPERATOR_RIGHT_PARENTHESIS, strlen (OPERATOR_RIGHT_PARENTHESIS)) == 0) { | |
*Pindex += strlen (OPERATOR_RIGHT_PARENTHESIS); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
} | |
} | |
// | |
// <factor> ::= NOT <factor> <rightbool> <rightfactor> | |
// | |
if (strncmp (*Pindex, OPERATOR_NOT, strlen (OPERATOR_NOT)) == 0) { | |
*Pindex += strlen (OPERATOR_NOT); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseFactor (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightBool (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
// | |
// <factor> ::= TRUE <rightfactor> | |
// | |
if (strncmp (*Pindex, OPERATOR_TRUE, strlen (OPERATOR_TRUE)) == 0) { | |
*Pindex += strlen (OPERATOR_TRUE); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
// | |
// <factor> ::= FALSE <rightfactor> | |
// | |
if (strncmp (*Pindex, OPERATOR_FALSE, strlen (OPERATOR_FALSE)) == 0) { | |
*Pindex += strlen (OPERATOR_FALSE); | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
} | |
} | |
// | |
// <factor> ::= <guid> <rightfactor> | |
// | |
if (ParseGuid (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseRightFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
} else { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
} | |
BOOLEAN | |
ParseTerm ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse term in bool expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If string is a valid term, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
INT8 *Pin; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
// | |
// <term> ::= NOT <factor> | |
// | |
if (strncmp (*Pindex, OPERATOR_NOT, strlen (OPERATOR_NOT)) == 0) { | |
*Pindex += strlen (OPERATOR_NOT); | |
LeftTrim (Pbegin, length, Pindex); | |
if (!ParseFactor (Pbegin, length, Pindex)) { | |
*Pindex = Pin; | |
} else { | |
return TRUE; | |
} | |
} | |
// | |
// <term> ::=<factor> | |
// | |
if (ParseFactor (Pbegin, length, Pindex)) { | |
return TRUE; | |
} else { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
} | |
BOOLEAN | |
ParseBool ( | |
IN INT8 *Pbegin, | |
IN UINT32 length, | |
IN OUT INT8 **Pindex | |
) | |
/*++ | |
Routine Description: | |
Parse bool expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Pindex The pointer of pointer to the next parse character in the string | |
Returns: | |
BOOLEAN If string is a valid bool expression, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
INT8 *Pin; | |
Pin = *Pindex; | |
LeftTrim (Pbegin, length, Pindex); | |
if (ParseTerm (Pbegin, length, Pindex)) { | |
LeftTrim (Pbegin, length, Pindex); | |
if (!ParseRightBool (Pbegin, length, Pindex)) { | |
*Pindex = Pin; | |
return FALSE; | |
} else { | |
return TRUE; | |
} | |
} else { | |
*Pindex = Pin; | |
return FALSE; | |
} | |
} | |
BOOLEAN | |
ParseDepex ( | |
IN INT8 *Pbegin, | |
IN UINT32 length | |
) | |
/*++ | |
Routine Description: | |
Parse whole dependency expression. | |
Arguments: | |
Pbegin The pointer to the string | |
length length of the string | |
Returns: | |
BOOLEAN If string is a valid dependency expression, return TRUE, otherwise FALSE | |
--*/ | |
{ | |
BOOLEAN Result; | |
INT8 **Pindex; | |
INT8 *temp; | |
Result = FALSE; | |
temp = Pbegin; | |
Pindex = &temp; | |
LeftTrim (Pbegin, length, Pindex); | |
if (strncmp (*Pindex, OPERATOR_BEFORE, strlen (OPERATOR_BEFORE)) == 0) { | |
(*Pindex) += strlen (OPERATOR_BEFORE); | |
Result = ParseGuid (Pbegin, length, Pindex); | |
} else if (strncmp (*Pindex, OPERATOR_AFTER, strlen (OPERATOR_AFTER)) == 0) { | |
(*Pindex) += strlen (OPERATOR_AFTER); | |
Result = ParseGuid (Pbegin, length, Pindex); | |
} else if (strncmp (*Pindex, OPERATOR_SOR, strlen (OPERATOR_SOR)) == 0) { | |
(*Pindex) += strlen (OPERATOR_SOR); | |
Result = ParseBool (Pbegin, length, Pindex); | |
} else { | |
Result = ParseBool (Pbegin, length, Pindex); | |
} | |
LeftTrim (Pbegin, length, Pindex); | |
return (BOOLEAN) (Result && (*Pindex) >= (Pbegin + length)); | |
} |