void CParser::ParseCondition(int nTabs)
{
m_sProgress = m_sProgress + GetTabs(nTabs)
+ "ParseCondition\r\n";
ETokenType tt = m_oToken.GetCurrentTokenType();
if(tt == ttNumber)
ParseNumber(nTabs+1);
else if(tt == ttString)
ParseString(nTabs+1);
else if(tt == ttNames)
ParseID(nTabs+1);
CString sToken = m_oToken.GetCurrentToken();
if(sToken != "Then")
{
//parse conditional operators i,e < > == != etc
ParseConditionalOperator(nTabs+1);
//parse number/string/id
ETokenType tt = m_oToken.GetCurrentTokenType();
if(tt == ttNumber)
ParseNumber(nTabs+1);
else if(tt == ttString)
ParseString(nTabs+1);
else if(tt == ttNames)
ParseID(nTabs+1);
}
}
void CParser::ParseStatementDim(int nTabs)
{
//Dim Num As Integer
CString sToken = m_oToken.GetCurrentToken();
m_sProgress = m_sProgress + GetTabs(nTabs)
+ "ParseStatemenDim " + sToken + "\r\n";
m_oToken.GetNextToken();
ParseID(nTabs+1);
ParseAsKeyword(nTabs+1);
ParseDataType(nTabs+1);
}
void CParser::ParseStatementAssignment(int nTabs)
{
CString sToken = m_oToken.GetCurrentToken();
m_sProgress = m_sProgress + GetTabs(nTabs)
+ "ParseStatementAssignment\r\n";
ParseID(nTabs+1);
ParseEqualSign(nTabs+1);
ParseExpression(nTabs+1);
}
void CParser::ParseArgument()
{
int nTabs = 6;
m_sProgress = m_sProgress + GetTabs(nTabs) +
"ParseArgument\r\n";
ParseArgumentScope();
ParseID(nTabs+1);
// parse As keyword
ParseAsKeyword(nTabs+1);
ParseDataType(nTabs+1);
}
void CParser::ParseExpressionFactor(int nTabs)
{
CString sToken = m_oToken.GetCurrentToken();
ETokenType tt = m_oToken.GetCurrentTokenType();
m_sProgress = m_sProgress + GetTabs(nTabs)
+ "ParseExpressionFactor " + sToken + "\r\n";
if(IsID() == true)
ParseID(nTabs+1);
else if(tt == ttNumber)
ParseNumber(nTabs+1);
else if(tt == ttFunctionStartBracket)
{
m_sProgress = m_sProgress + GetTabs(nTabs+1)
+ "ParseStartBarcket " + sToken + "\r\n";
m_oToken.GetNextToken();
ParseExpression(nTabs+1);
sToken = m_oToken.GetCurrentToken();
m_sProgress = m_sProgress + GetTabs(nTabs+1)
+ "ParseEndBarcket " + sToken + "\r\n";
if(sToken != ")")
m_sProgress = m_sProgress + GetTabs(nTabs+1)
+ GetErrorString();
m_oToken.GetNextToken();
}
//else if(tt == ttFunctionEndBracket)
//{
//m_oToken.GetNextToken();
//return;
//}
else
{
m_sProgress = m_sProgress + GetTabs(nTabs+1)
+ GetErrorString();
m_oToken.GetNextToken();
}
}
//CString CParser::ParseProcedureHead()
void CParser::ParseProcedureHead()
{
m_sProgress = m_sProgress + GetTabs(4)
+ "ParseProcedureHead\r\n";
//CString sRetVal,sRetVal2="true";
//sRetVal = ParseProcedureScope();
ParseProcedureScope();
ParseProcedureStatic();
ParseProcedureType(5);
ParseID(5);
ParseProcedureStartBracket();
ParseArgumentList();
ParseProcedureEndBracket();
ParseProcedureReturn();
} // ParseProcedureHead()
CCompoundID CCompoundIDDumpParser::ParseID()
{
SkipSpace();
x_SaveErrPos();
if (x_EOF() || !isalpha(*m_Ch)) {
CID_PARSER_EXCEPTION("missing compound ID class name");
}
const char* token_begin = m_Ch;
do
++m_Ch;
while (!x_EOF() && isalpha(*m_Ch));
CTempString new_id_class_name(token_begin, m_Ch - token_begin);
ECompoundIDClass new_id_class = eCIC_NumberOfClasses;
switch (*token_begin) {
case 'C':
if (new_id_class_name == CIC_GENERICID_CLASS_NAME)
new_id_class = eCIC_GenericID;
break;
case 'N':
if (new_id_class_name == CIC_NETCACHEBLOBKEY_CLASS_NAME)
new_id_class = eCIC_NetCacheBlobKey;
else if (new_id_class_name == CIC_NETSCHEDULEJOBKEY_CLASS_NAME)
new_id_class = eCIC_NetScheduleJobKey;
else if (new_id_class_name == CIC_NETSTORAGEOBJECTLOC_CLASS_NAME)
new_id_class = eCIC_NetStorageObjectLoc;
else if (new_id_class_name == CIC_NETSTORAGEOBJECTLOC_CLASS_NAME_V1)
new_id_class = eCIC_NetStorageObjectLocV1;
}
if (new_id_class == eCIC_NumberOfClasses) {
CID_PARSER_EXCEPTION("unknown compound ID class '" <<
new_id_class_name << '\'');
}
SkipSpace();
if (x_EOF() || *m_Ch != '{') {
x_SaveErrPos();
CID_PARSER_EXCEPTION("missing '{'");
}
++m_Ch;
SkipSpaceToNextToken();
CCompoundID result(m_Pool.NewID(new_id_class));
if (*m_Ch != '}')
for (;;) {
token_begin = m_Ch;
x_SaveErrPos();
do
++m_Ch;
while (isalnum(*m_Ch) || *m_Ch == '_');
CTempString field_type_name(token_begin, m_Ch - token_begin);
ECompoundIDFieldType field_type = eCIT_NumberOfTypes;
switch (*token_begin) {
case '}':
CID_PARSER_EXCEPTION("a field type name is required");
case 'b':
if (field_type_name == CIT_BOOLEAN_TYPE_NAME)
field_type = eCIT_Boolean;
break;
case 'd':
if (field_type_name == CIT_DATABASE_NAME_TYPE_NAME)
field_type = eCIT_DatabaseName;
break;
case 'f':
if (field_type_name == CIT_FLAGS_TYPE_NAME)
field_type = eCIT_Flags;
break;
case 'h':
if (field_type_name == CIT_HOST_TYPE_NAME)
field_type = eCIT_Host;
break;
case 'i':
if (field_type_name == CIT_ID_TYPE_NAME)
field_type = eCIT_ID;
else if (field_type_name == CIT_INTEGER_TYPE_NAME)
field_type = eCIT_Integer;
else if (field_type_name == CIT_IPV4_ADDRESS_TYPE_NAME)
field_type = eCIT_IPv4Address;
else if (field_type_name == CIT_IPV4_SOCK_ADDR_TYPE_NAME)
field_type = eCIT_IPv4SockAddr;
break;
case 'n':
if (field_type_name == CIT_NESTED_CID_TYPE_NAME)
field_type = eCIT_NestedCID;
else if (field_type_name == CIT_CUE_TYPE_NAME)
field_type = eCIT_Cue;
break;
case 'p':
if (field_type_name == CIT_OBJECTREF_TYPE_NAME)
field_type = eCIT_ObjectRef;
else if (field_type_name == CIT_PORT_TYPE_NAME)
field_type = eCIT_Port;
break;
case 'r':
if (field_type_name == CIT_RANDOM_TYPE_NAME)
field_type = eCIT_Random;
break;
case 's':
if (field_type_name == CIT_SEQ_ID_TYPE_NAME)
field_type = eCIT_SeqID;
else if (field_type_name == CIT_SERVICE_NAME_TYPE_NAME)
field_type = eCIT_ServiceName;
else if (field_type_name == CIT_STRING_TYPE_NAME)
field_type = eCIT_String;
break;
case 't':
if (field_type_name == CIT_LABEL_TYPE_NAME)
field_type = eCIT_Label;
else if (field_type_name == CIT_TAX_ID_TYPE_NAME)
field_type = eCIT_TaxID;
else if (field_type_name == CIT_TIMESTAMP_TYPE_NAME)
field_type = eCIT_Timestamp;
}
if (field_type == eCIT_NumberOfTypes) {
CID_PARSER_EXCEPTION("unknown field type '" <<
field_type_name << '\'');
}
SkipSpaceToNextToken();
switch (field_type) {
case eCIT_ID:
result.AppendID(x_ReadUint8());
break;
case eCIT_Integer:
result.AppendInteger(x_ReadInt8());
break;
case eCIT_ServiceName:
result.AppendServiceName(x_ReadString());
break;
case eCIT_DatabaseName:
result.AppendDatabaseName(x_ReadString());
break;
case eCIT_Timestamp:
result.AppendTimestamp(x_ReadInt8());
break;
case eCIT_Random:
{
x_SaveErrPos();
Uint8 random_number = x_ReadUint8();
if (random_number >= ((Uint8) 1) << 8 * sizeof(Uint4)) {
CID_PARSER_EXCEPTION(
"random number exceeds maximum allowed value");
}
result.AppendRandom((Uint4) random_number);
}
break;
case eCIT_IPv4Address:
result.AppendIPv4Address(x_ReadIPv4Address());
break;
case eCIT_Host:
result.AppendHost(x_ReadString());
break;
case eCIT_Port:
result.AppendPort(x_ReadPortNumber());
break;
case eCIT_IPv4SockAddr:
{
Uint4 ipv4_address = x_ReadIPv4Address();
if (x_EOF() || *m_Ch != ':') {
x_SaveErrPos();
CID_PARSER_EXCEPTION("missing ':'");
}
++m_Ch;
result.AppendIPv4SockAddr(ipv4_address, x_ReadPortNumber());
}
break;
case eCIT_ObjectRef:
result.AppendObjectRef(x_ReadString());
break;
case eCIT_String:
result.AppendString(x_ReadString());
break;
case eCIT_Boolean:
{
token_begin = m_Ch;
x_SaveErrPos();
while (!x_EOF() && isalpha(*m_Ch))
++m_Ch;
CTempString bool_val(token_begin, m_Ch - token_begin);
if (bool_val == "false")
result.AppendBoolean(false);
else if (bool_val == "true")
result.AppendBoolean(true);
else {
CID_PARSER_EXCEPTION("invalid boolean value \"" <<
bool_val << '\"');
}
}
break;
case eCIT_Flags:
result.AppendFlags(x_ReadUint8());
break;
case eCIT_Label:
result.AppendLabel(x_ReadString());
break;
case eCIT_Cue:
result.AppendCue(x_ReadUint8());
break;
case eCIT_SeqID:
result.AppendSeqID(x_ReadString());
break;
case eCIT_TaxID:
result.AppendTaxID(x_ReadUint8());
break;
case eCIT_NestedCID:
result.AppendNestedCID(ParseID());
break;
case eCIT_NumberOfTypes:
break;
}
SkipSpaceToNextToken();
if (*m_Ch == ',')
++m_Ch;
else if (*m_Ch == '}')
break;
else {
x_SaveErrPos();
CID_PARSER_EXCEPTION("either ',' or '}' expected");
}
SkipSpaceToNextToken();
}
++m_Ch;
return result;
}
static BOOL
HandleToolTypes( UBYTE** tool_types,
struct ISAPNP_Card* card,
struct ISAPNPBase* res )
{
while( *tool_types )
{
if( Strnicmp( *tool_types, "DISABLE_CARD=", 13 ) == 0 )
{
LONG manufacturer;
WORD product;
BYTE revision;
LONG serial;
if( ParseID( *tool_types + 13,
&manufacturer, &product, &revision, &serial ) )
{
struct ISAPNP_Card* card = NULL;
while( ( card = ISAPNP_FindCard( card,
manufacturer,
product,
revision,
serial,
res ) ) != NULL )
{
card->isapnpc_Disabled = TRUE;
}
}
else
{
Req( "Illegal tool type: %s\n", (ULONG) *tool_types );
return FALSE;
}
}
else if( Strnicmp( *tool_types, "DISABLE_DEVICE=", 15 ) == 0 )
{
LONG manufacturer;
WORD product;
BYTE revision;
if( ParseID( *tool_types + 15,
&manufacturer, &product, &revision, NULL ) )
{
struct ISAPNP_Device* dev = NULL;
while( ( dev = ISAPNP_FindDevice( dev,
manufacturer,
product,
revision,
res ) ) != NULL )
{
dev->isapnpd_Disabled = TRUE;
}
}
else
{
Req( "Illegal tool type value: %s\n", (ULONG) *tool_types );
return FALSE;
}
}
else if( Strnicmp( *tool_types, "LEGACY_DEVICE=", 14 ) == 0 )
{
UBYTE* str;
int conv;
LONG manufacturer;
WORD product;
BYTE revision;
UWORD dev_num = 0;
str = *tool_types + 14;
conv = ParseID( str, &manufacturer, &product, &revision, NULL );
str += conv;
if( conv != 0 )
{
struct ISAPNP_Device* dev;
struct ISAPNP_Identifier* id;
dev = ISAPNP_AllocDevice( res );
if( dev == NULL )
{
Req( "Out of memory!" );
return FALSE;
}
dev->isapnpd_Card = card;
id = AllocVec( sizeof( *id ), MEMF_PUBLIC | MEMF_CLEAR );
if( id == NULL )
{
Req( "Out of memory!" );
ISAPNP_FreeDevice( dev, res );
return FALSE;
}
id->isapnpid_Vendor[ 0 ] = ( manufacturer >> 24 ) & 0xff;
id->isapnpid_Vendor[ 1 ] = ( manufacturer >> 16 ) & 0xff;
id->isapnpid_Vendor[ 2 ] = ( manufacturer >> 8 ) & 0xff;
id->isapnpid_Vendor[ 3 ] = 0;
id->isapnpid_ProductID = product;
id->isapnpid_Revision = revision;
AddTail( (struct List*) &dev->isapnpd_IDs, (struct Node*) id );
if( card->isapnpc_Devices.lh_Head->ln_Succ != NULL )
{
dev_num = ( (struct ISAPNP_Device*)
card->isapnpc_Devices.lh_TailPred )->isapnpd_DeviceNumber;
++dev_num;
}
dev->isapnpd_DeviceNumber = dev_num;
AddTail( &card->isapnpc_Devices, (struct Node*) dev );
while( *str != 0 )
{
if( *str != ' ' )
{
if( Strnicmp( str, "IRQ=", 4 ) == 0 )
{
int irq;
irq = strtol( str + 4, (char**) &str, 0 );
if( irq <= 0 || irq >= 16 )
{
Req( "Invalid IRQ value '%ld' in tooltype line\n"
"'%s'",
irq,
(ULONG) *tool_types );
return FALSE;
}
else
{
struct ISAPNP_IRQResource* r;
r = (struct ISAPNP_IRQResource*)
ISAPNP_AllocResource( ISAPNP_NT_IRQ_RESOURCE, res );
if( r == NULL )
{
Req( "Out of memory!" );
return FALSE;
}
r->isapnpirqr_IRQMask = 1 << irq;
r->isapnpirqr_IRQType = ISAPNP_IRQRESOURCE_ITF_HIGH_EDGE;
AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
(struct Node*) r );
}
}
else if( Strnicmp( str, "DMA=", 4 ) == 0 )
{
int dma;
dma = strtol( str + 4, (char**) &str, 0 );
if( dma <= 0 || dma >= 8 )
{
Req( "Invalid DMA value '%ld' in tooltype line\n"
"'%s'",
dma,
(ULONG) *tool_types );
return FALSE;
}
else
{
struct ISAPNP_DMAResource* r;
r = (struct ISAPNP_DMAResource*)
ISAPNP_AllocResource( ISAPNP_NT_DMA_RESOURCE, res );
if( r == NULL )
{
Req( "Out of memory!" );
return FALSE;
}
r->isapnpdmar_ChannelMask = 1 << dma;
r->isapnpdmar_Flags = 0;
AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
(struct Node*) r );
}
}
else if( Strnicmp( str, "IO=", 3 ) == 0 )
{
int base;
int length;
struct ISAPNP_IOResource* r;
base = strtol( str + 3, (char**) &str, 0 );
if( *str != '/' )
{
Req( "Length missing from IO value in tooltype line\n"
"'%s'",
(ULONG) *tool_types );
return FALSE;
}
++str;
length = strtol( str, (char**) &str, 0 );
if( base <= 0 || base >= 0xffff )
{
Req( "Invalid IO base value '%ld' in tooltype line\n"
"'%s'",
base,
(ULONG) *tool_types );
return FALSE;
}
if( length <= 0 || length >= 0xffff )
{
Req( "Invalid IO length value '%ld' in tooltype line\n"
"'%s'",
length,
(ULONG) *tool_types );
return FALSE;
}
r = (struct ISAPNP_IOResource*)
ISAPNP_AllocResource( ISAPNP_NT_IO_RESOURCE, res );
if( r == NULL )
{
Req( "Out of memory!" );
return FALSE;
}
r->isapnpior_MinBase = base;
r->isapnpior_MaxBase = base;
r->isapnpior_Length = length;
r->isapnpior_Alignment = 1;
AddTail( (struct List*) &dev->isapnpd_Options->isapnprg_Resources,
(struct Node*) r );
}
else
{
Req( "Parse error near '%s'\n"
"in tooltype line\n"
"'%s'",
(ULONG) str,
(ULONG) *tool_types );
return FALSE;
}
}
if( *str )
{
++str;
}
}
}
else
{
Req( "Illegal tool type: '%s'\n", (ULONG) *tool_types );
return FALSE;
}
}
