void t_plugin::_convertXMDL(const char * filename)
{
TString128 path = filename;
int count = 0;
int len = path.Length();
while (count < 2)
{
if (path[len - 1] == '\\' || path[len - 1] == '/')
++count;
path[len - 1] = 0;
--len;
}
{
TString128 dirtyFile = path + "\\actor\\dirty.txt";
if (File::Exist(dirtyFile))
{
return ;
}
File fp;
fp.Open(dirtyFile.c_str());
fp.Close();
}
FileSystem fs(path + "\\xmdl\\³èÎï");
fs.Load();
Archive::FileInfoVisitor v = fs.GetFileInfos();
while (!v.eof())
{
if (v.Cursor()->second.type != Archive::FILE_DIRECTORY)
{
TString128 _xmdl = v.Cursor()->second.name;
if (File::GetExternName(_xmdl) == "xmdl")
{
TString128 ifilename = path + "\\xmdl\\³èÎï\\" + _xmdl;
TString128 ofilename = path + "\\actor\\³èÎï\\" + File::RemoveExternName(_xmdl) + ".mesh";
__convert(ofilename, ifilename);
}
else if (File::GetExternName(_xmdl) == "dds")
{
TString128 ifilename = path + "\\xmdl\\³èÎï\\" + _xmdl;
TString128 ofilename = path + "\\actor\\texture\\" + File::GetBaseName(_xmdl);
__copyTex(ofilename, ifilename);
}
}
++v;
}
}
globle struct expr *ParseAssertTemplate(
void *theEnv,
const char *readSource,
struct token *theToken,
int *error,
int endType,
int constantsOnly,
struct deftemplate *theDeftemplate)
{
struct expr *firstSlot, *lastSlot, *nextSlot;
struct expr *firstArg, *tempSlot;
struct templateSlot *slotPtr;
firstSlot = NULL;
lastSlot = NULL;
/*==============================================*/
/* Parse each of the slot fields in the assert. */
/*==============================================*/
while ((slotPtr = ParseSlotLabel(theEnv,readSource,theToken,theDeftemplate,error,endType)) != NULL)
{
/*========================================================*/
/* Check to see that the slot hasn't already been parsed. */
/*========================================================*/
for (tempSlot = firstSlot;
tempSlot != NULL;
tempSlot = tempSlot->nextArg)
{
if (tempSlot->value == (void *) slotPtr->slotName)
{
AlreadyParsedErrorMessage(theEnv,__convert("slot "),
ValueToString(slotPtr->slotName));
*error = TRUE;
ReturnExpression(theEnv,firstSlot);
return(NULL);
}
}
/*============================================*/
/* Parse the values to be stored in the slot. */
/*============================================*/
nextSlot = ParseAssertSlotValues(theEnv,readSource,theToken,
slotPtr,error,constantsOnly);
if (*error)
{
ReturnExpression(theEnv,firstSlot);
return(NULL);
}
/*============================================*/
/* Check to see if the values to be stored in */
/* the slot violate the slot's constraints. */
/*============================================*/
if (CheckRHSSlotTypes(theEnv,nextSlot->argList,slotPtr,__convert("assert")) == 0)
{
*error = TRUE;
ReturnExpression(theEnv,firstSlot);
ReturnExpression(theEnv,nextSlot);
return(NULL);
}
/*===================================================*/
/* Add the slot to the list of slots already parsed. */
/*===================================================*/
if (lastSlot == NULL)
{ firstSlot = nextSlot; }
else
{ lastSlot->nextArg = nextSlot; }
lastSlot = nextSlot;
}
/*=================================================*/
/* Return if an error occured parsing a slot name. */
/*=================================================*/
if (*error)
{
ReturnExpression(theEnv,firstSlot);
return(NULL);
}
/*=============================================================*/
/* Reorder the arguments to the order used by the deftemplate. */
/*=============================================================*/
firstArg = ReorderAssertSlotValues(theEnv,theDeftemplate->slotList,firstSlot,error);
ReturnExpression(theEnv,firstSlot);
/*==============================*/
/* Return the assert arguments. */
/*==============================*/
return(firstArg);
}
static struct expr *ParseAssertSlotValues(
void *theEnv,
const char *inputSource,
struct token *tempToken,
struct templateSlot *slotPtr,
int *error,
int constantsOnly)
{
struct expr *nextSlot;
struct expr *newField, *valueList, *lastValue;
int printError;
/*=============================*/
/* Handle a single field slot. */
/*=============================*/
if (slotPtr->multislot == FALSE)
{
/*=====================*/
/* Get the slot value. */
/*=====================*/
SavePPBuffer(theEnv,__convert(" "));
newField = GetAssertArgument(theEnv,inputSource,tempToken,
error,RPAREN,constantsOnly,&printError);
if (*error)
{
if (printError) SyntaxErrorMessage(theEnv,__convert("deftemplate pattern"));
return(NULL);
}
/*=================================================*/
/* A single field slot value must contain a value. */
/* Only a multifield slot can be empty. */
/*=================================================*/
if (newField == NULL)
{
*error = TRUE;
SingleFieldSlotCardinalityError(theEnv,slotPtr->slotName->contents);
return(NULL);
}
/*==============================================*/
/* A function returning a multifield value can */
/* not be called to get the value for the slot. */
/*==============================================*/
if ((newField->type == FCALL) ? (ExpressionFunctionType(newField) == 'm') :
(newField->type == MF_VARIABLE))
{
*error = TRUE;
SingleFieldSlotCardinalityError(theEnv,slotPtr->slotName->contents);
ReturnExpression(theEnv,newField);
return(NULL);
}
/*============================*/
/* Move on to the next token. */
/*============================*/
GetToken(theEnv,inputSource,tempToken);
}
/*========================================*/
/* Handle a multifield slot. Build a list */
/* of the values stored in the slot. */
/*========================================*/
else
{
SavePPBuffer(theEnv,__convert(" "));
valueList = GetAssertArgument(theEnv,inputSource,tempToken,
error,RPAREN,constantsOnly,&printError);
if (*error)
{
if (printError) SyntaxErrorMessage(theEnv,__convert("deftemplate pattern"));
return(NULL);
}
if (valueList == NULL)
{
PPBackup(theEnv);
PPBackup(theEnv);
SavePPBuffer(theEnv,__convert(")"));
}
lastValue = valueList;
while (lastValue != NULL) /* (tempToken->type != RPAREN) */
{
if (tempToken->type == RPAREN)
{ SavePPBuffer(theEnv,__convert(" ")); }
else
{
/* PPBackup(theEnv); */
SavePPBuffer(theEnv,__convert(" "));
/* SavePPBuffer(theEnv,tempToken->printForm); */
}
newField = GetAssertArgument(theEnv,inputSource,tempToken,error,RPAREN,constantsOnly,&printError);
if (*error)
{
if (printError) SyntaxErrorMessage(theEnv,__convert("deftemplate pattern"));
ReturnExpression(theEnv,valueList);
return(NULL);
}
if (newField == NULL)
{
PPBackup(theEnv);
PPBackup(theEnv);
SavePPBuffer(theEnv,__convert(")"));
}
lastValue->nextArg = newField;
lastValue = newField;
}
newField = valueList;
}
/*==========================================================*/
/* Slot definition must be closed with a right parenthesis. */
/*==========================================================*/
if (tempToken->type != RPAREN)
{
SingleFieldSlotCardinalityError(theEnv,slotPtr->slotName->contents);
*error = TRUE;
ReturnExpression(theEnv,newField);
return(NULL);
}
/*=========================================================*/
/* Build and return a structure describing the slot value. */
/*=========================================================*/
nextSlot = GenConstant(theEnv,SYMBOL,slotPtr->slotName);
nextSlot->argList = newField;
return(nextSlot);
}
static struct expr *GetSlotAssertValues(
void *theEnv,
struct templateSlot *slotPtr,
struct expr *firstSlot,
int *error)
{
struct expr *slotItem;
struct expr *newArg, *tempArg;
DATA_OBJECT theDefault;
const char *nullBitMap = "\0";
/*==================================================*/
/* Determine if the slot is assigned in the assert. */
/*==================================================*/
slotItem = FindAssertSlotItem(slotPtr,firstSlot);
/*==========================================*/
/* If the slot is assigned, use that value. */
/*==========================================*/
if (slotItem != NULL)
{
newArg = slotItem->argList;
slotItem->argList = NULL;
}
/*=================================*/
/* Otherwise, use a default value. */
/*=================================*/
else
{
/*================================================*/
/* If the (default ?NONE) attribute was specified */
/* for the slot, then a value must be supplied. */
/*================================================*/
if (slotPtr->noDefault)
{
PrintErrorID(theEnv,__convert("TMPLTRHS"),1,TRUE);
EnvPrintRouter(theEnv,WERROR,__convert("Slot "));
EnvPrintRouter(theEnv,WERROR,slotPtr->slotName->contents);
EnvPrintRouter(theEnv,WERROR,__convert(" requires a value because of its (default ?NONE) attribute.\n"));
*error = TRUE;
return(NULL);
}
/*===================================================*/
/* If the (default ?DERIVE) attribute was specified */
/* (the default), then derive the default value from */
/* the slot's constraints. */
/*===================================================*/
else if ((slotPtr->defaultPresent == FALSE) &&
(slotPtr->defaultDynamic == FALSE))
{
DeriveDefaultFromConstraints(theEnv,slotPtr->constraints,&theDefault,
(int) slotPtr->multislot,TRUE);
newArg = ConvertValueToExpression(theEnv,&theDefault);
}
/*=========================================*/
/* Otherwise, use the expression contained */
/* in the default attribute. */
/*=========================================*/
else
{ newArg = CopyExpression(theEnv,slotPtr->defaultList); }
}
/*=======================================================*/
/* Since a multifield slot default can contain a list of */
/* values, the values need to have a store-multifield */
/* function called wrapped around it to group all of the */
/* values into a single multifield value. */
/*=======================================================*/
if (slotPtr->multislot)
{
tempArg = GenConstant(theEnv,FACT_STORE_MULTIFIELD,EnvAddBitMap(theEnv,(void *) nullBitMap,1));
tempArg->argList = newArg;
newArg = tempArg;
}
/*==============================================*/
/* Return the value to be asserted in the slot. */
/*==============================================*/
return(newArg);
}
static struct templateSlot *ParseSlotLabel(
void *theEnv,
const char *inputSource,
struct token *tempToken,
struct deftemplate *theDeftemplate,
int *error,
int endType)
{
struct templateSlot *slotPtr;
short position;
/*========================*/
/* Initialize error flag. */
/*========================*/
*error = FALSE;
/*============================================*/
/* If token is a right parenthesis, then fact */
/* template definition is complete. */
/*============================================*/
GetToken(theEnv,inputSource,tempToken);
if (tempToken->type == endType)
{ return(NULL); }
/*=======================================*/
/* Put a space between the template name */
/* and the first slot definition. */
/*=======================================*/
PPBackup(theEnv);
SavePPBuffer(theEnv,__convert(" "));
SavePPBuffer(theEnv,tempToken->printForm);
/*=======================================================*/
/* Slot definition begins with opening left parenthesis. */
/*=======================================================*/
if (tempToken->type != LPAREN)
{
SyntaxErrorMessage(theEnv,__convert("deftemplate pattern"));
*error = TRUE;
return(NULL);
}
/*=============================*/
/* Slot name must be a symbol. */
/*=============================*/
GetToken(theEnv,inputSource,tempToken);
if (tempToken->type != SYMBOL)
{
SyntaxErrorMessage(theEnv,__convert("deftemplate pattern"));
*error = TRUE;
return(NULL);
}
/*======================================================*/
/* Check that the slot name is valid for this template. */
/*======================================================*/
if ((slotPtr = FindSlot(theDeftemplate,(SYMBOL_HN *) tempToken->value,&position)) == NULL)
{
InvalidDeftemplateSlotMessage(theEnv,ValueToString(tempToken->value),
ValueToString(theDeftemplate->header.name),TRUE);
*error = TRUE;
return(NULL);
}
/*====================================*/
/* Return a pointer to the slot name. */
/*====================================*/
return(slotPtr);
}
