parse3dt.c

3D游戏场景编辑器

	}

	Parser = geRam_Allocate (sizeof (Parse3dt));
	if (Parser != NULL)
	{
		geBoolean NoErrors;

		Parser->HashTable = NULL;
		Parser->Scanner = Scanner_Create (StateInitializers, NumInitializers, SNull);

		// Create the hash table
		Parser->HashTable = Iden_CreateHashTable();

		NoErrors = ((Parser->Scanner != NULL) && (Parser->HashTable != NULL));

		if (NoErrors)
		{
			NoErrors = Scanner_InitFile (Parser->Scanner, Filename, SCANNER_FILE_TEXT, Parser->HashTable);
		}
		if (!NoErrors)
		{
			Parse3dt_Destroy (&Parser);
		}
	}
	return Parser;
}


void Parse3dt_Destroy (Parse3dt **pParser)
{
	Parse3dt *Parser;

	assert (pParser != NULL);
	assert (*pParser != NULL);

	Parser = *pParser;
	if (Parser->Scanner != NULL)
	{
		Scanner_Destroy (Parser->Scanner);
	}
	if (Parser->HashTable != NULL)
	{
		Iden_DestroyHashTable (Parser->HashTable);
	}
	geRam_Free (*pParser);
	*pParser = NULL;
}


char const *Parse3dt_Error (Parse3dt *Parser, char *fmt, ...)
{
	va_list			ap;
	static char		buff[1024];
	char			tmpBuff[1024];

	va_start(ap, fmt);

	// format the caller's string into the temporary buffer
	vsprintf (tmpBuff, fmt, ap);

	va_end(ap);

	// and then wrap the whole thing up prettily into buff
	sprintf (buff, "Error '%s' in file <%s> at offset 0x%08X",
		tmpBuff, Scanner_GetFileName (Parser->Scanner),
		Scanner_GetOffset (Parser->Scanner));

	return buff;
}

geBoolean Parse3dt_ScanExpecting
	(
	  Parse3dt *Parser,
	  Scanner_Token *t, 
	  Parse3dt_TokenKind kind
	)
{
	Scanner_Scan (Parser->Scanner, t);
	return (t->tKind == kind);
}

geBoolean Parse3dt_ScanExpectingText
	(
	  Parse3dt *Parser,
	  const char *idText
	)
{
	Scanner_Token t;

	assert (idText != NULL);

	Scanner_Scan (Parser->Scanner, &t);
	if (t.tKind != P3TK_ERROR)
	{
		*(t.tTokenDataPtr) = '\0';
		return (strcmp (idText, t.tTokenData) == 0) ? GE_TRUE : GE_FALSE;
	}
	return GE_FALSE;
}

geBoolean Parse3dt_GetIdentifier 
	(
	  Parse3dt *Parser,
	  const char *Tag, 
	  char *idText
	)
{
	Scanner_Token t;

	if (Tag != NULL)
	{
		if (!Parse3dt_ScanExpectingText (Parser, Tag))
		{
			return GE_FALSE;
		}
	}

	if (Parse3dt_ScanExpecting (Parser, &t, P3TK_IDEN))
	{
		// identifiers are nul-terminated...
		strcpy (idText, t.tTokenData);
		return GE_TRUE;
	}
	return GE_FALSE;
}

geBoolean Parse3dt_GetPath
	(
	  Parse3dt *Parser,
	  char const *Tag,
	  char *Path
	)
{
	Scanner_Token t;

	if (Tag != NULL)
	{
		if (!Parse3dt_ScanExpectingText (Parser, Tag))
		{
			return GE_FALSE;
		}
	}
	Scanner_Scan (Parser->Scanner, &t);
	if ((t.tKind == P3TK_IDEN) || (t.tKind == P3TK_PATH))
	{
		strcpy (Path, t.tTokenData);
		return GE_TRUE;
	}
	return GE_FALSE;
}

geBoolean Parse3dt_GetInt (Parse3dt *Parser, char const *Tag, int *Value)
{
	Scanner_Token t;

	assert (Parser != NULL);
	assert (Value != NULL);

	if (Tag != NULL)
	{
		if (!Parse3dt_ScanExpectingText (Parser, Tag))
		{
			return GE_FALSE;
		}
	}
	if (Parse3dt_ScanExpecting (Parser, &t, P3TK_ICON))
	{
		*Value = t.tICONValue;
		return GE_TRUE;
	}
	return GE_FALSE;
}

geBoolean Parse3dt_GetFloat (Parse3dt *Parser, char const *Tag, float *Value)
{
	Scanner_Token t;

	assert (Parser != NULL);
	assert (Value != NULL);

	if (Tag != NULL)
	{
		if (!Parse3dt_ScanExpectingText (Parser, Tag))
		{
			return GE_FALSE;
		}
	}
	Scanner_Scan (Parser->Scanner, &t);
	switch (t.tKind)
	{
		case P3TK_FCON :
			*Value = t.tFCONValue;
			return GE_TRUE;
		case P3TK_ICON :
			*Value = (float)t.tICONValue;
			return GE_TRUE;
		default :
			break;
	}
	return GE_FALSE;
}

geBoolean Parse3dt_GetLiteral (Parse3dt *Parser, char const *Tag, char *strtext)
{
	Scanner_Token t;

	if (Tag != NULL)
	{
		if (!Parse3dt_ScanExpectingText (Parser, Tag))
		{
			return GE_FALSE;
		}
	}
	Scanner_Scan (Parser->Scanner, &t);
	if ((t.tKind == P3TK_IDEN) || (t.tKind == P3TK_LITERALSTRING))
	{
		strcpy (strtext, t.tTokenData);
		return GE_TRUE;
	}
	return GE_FALSE;
}

geBoolean Parse3dt_GetVec3d (Parse3dt *Parser, char const *Tag, geVec3d *pVec)
{
	assert (Parser != NULL);
	assert (pVec != NULL);

	if (Tag != NULL)
	{
		if (!Parse3dt_ScanExpectingText (Parser, Tag))
		{
			return GE_FALSE;
		}
	}
	
	return (Parse3dt_GetFloat (Parser, NULL, &pVec->X) &&
			Parse3dt_GetFloat (Parser, NULL, &pVec->Y) &&
			Parse3dt_GetFloat (Parser, NULL, &pVec->Z));
}

geBoolean Parse3dt_GetXForm3d (Parse3dt *Parser, char const *Tag, geXForm3d *pXfm)
{
	assert (Parser != NULL);
	assert (pXfm != NULL);

	if (Tag != NULL)
	{
		if (!Parse3dt_ScanExpectingText (Parser, Tag))
		{
			return GE_FALSE;
		}
	}

	return
	(
		Parse3dt_GetFloat (Parser, NULL, &pXfm->AX) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->AY) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->AZ) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->BX) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->BY) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->BZ) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->CX) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->CY) &&
		Parse3dt_GetFloat (Parser, NULL, &pXfm->CZ) &&
		Parse3dt_GetVec3d (Parser, NULL, &pXfm->Translation)
	);
}


geBoolean Parse3dt_GetVersion (Parse3dt *Parser, int *VersionMajor, int *VersionMinor)
{
	Scanner_Token t;

	if (!Parse3dt_ScanExpectingText (Parser, "3dtVersion"))
	{
		return GE_FALSE;
	}
	Scanner_Scan (Parser->Scanner, &t);

	switch (t.tKind)
	{
		case P3TK_FCON :
		{
			// If it's a float, then parse the token data to get
			// major and minor version numbers.
			char *c;

			*(t.tTokenDataPtr) = '\0';
			c = strchr (t.tTokenData, '.');
			if (c != NULL)
			{
				*c = '\0';
				++c;
				*VersionMinor = atoi (c);
			}
			else
			{
				*VersionMinor = 0;
			}

			*VersionMajor = atoi (t.tTokenData);
			return GE_TRUE;
		}
		case P3TK_ICON :
			// if it's an integer, then the major version is the number
			// and the minor version number is 0.
			*VersionMajor = t.tICONValue;
			*VersionMinor = 0;
			return GE_TRUE;
		default :
			break;
	}
	return GE_FALSE;
}