static inline void
PushMarkStack(GCMarker *gcmarker, JSString *str)
{
JS_COMPARTMENT_ASSERT_STR(gcmarker->runtime, str);
/*
* As string can only refer to other strings we fully scan its GC graph
* using the explicit stack when navigating the rope tree to avoid
* dealing with strings on the stack in drainMarkStack.
*/
if (str->markIfUnmarked())
ScanString(gcmarker, str);
}
void Lexer::ScanLiteral()
{
// Literal; remove #
tp--;
NextChar();
if (isIdentifierFirst(m_cc))
{
ScanSymbol();
m_tokenType = SymbolConst;
}
else if (isAnsiBinaryChar(m_cc))
{
ScanBinary();
m_tokenType = SymbolConst;
}
else if (m_cc == STRINGDELIM)
{
// Quoted Symbol
ScanString(CharPosition());
m_tokenType = SymbolConst;
}
else if (m_cc == '(')
{
m_tokenType = ArrayBegin;
}
else if (m_cc == '[')
{
m_tokenType = ByteArrayBegin;
}
else if (m_cc == LITERAL)
{
// Second hash, so should be a constant expression ##(xxx)
NextChar();
if (m_cc != '(')
CompileError(TEXTRANGE(CharPosition(), CharPosition()), LErrExpectExtendedLiteral);
m_tokenType = ExprConstBegin;
}
else
{
m_thisTokenRange.m_stop = CharPosition();
CompileError(LErrExpectConst);
}
}
int
XkbCFScan(FILE *file, XkbCFScanResultPtr val_rtrn, XkbConfigRtrnPtr rtrn)
{
int ch;
do {
ch = getc(file);
} while ((ch == '\t') || (ch == ' '));
if (isalpha(ch))
return ScanIdent(file, ch, val_rtrn);
else if (isdigit(ch))
return ScanInteger(file, ch, val_rtrn);
else if (ch == '"')
return ScanString(file, ch, val_rtrn);
else if (ch == '\n') {
rtrn->line++;
return XkbCF_EOL;
}
else if (ch == ';')
return XkbCF_Semi;
else if (ch == '=')
return XkbCF_Equals;
else if (ch == '+') {
ch = getc(file);
if (ch == '=')
return XkbCF_PlusEquals;
if ((ch != EOF) && (ch != ' ') && (ch != '\t'))
ungetc(ch, file);
return XkbCF_Plus;
}
else if (ch == '-') {
ch = getc(file);
if (ch == '=')
return XkbCF_MinusEquals;
if ((ch != EOF) && (ch != ' ') && (ch != '\t'))
ungetc(ch, file);
return XkbCF_Minus;
}
else if (ch == EOF)
return XkbCF_EOF;
else if ((ch == '#') || ((ch == '/') && (getc(file) == '/'))) {
while ((ch != '\n') && (ch != EOF))
ch = getc(file);
rtrn->line++;
return XkbCF_EOL;
}
return XkbCF_Unknown;
}
bool FScanner::GetToken ()
{
if (ScanString (true))
{
if (TokenType == TK_NameConst)
{
Name = FName(String);
}
else if (TokenType == TK_IntConst)
{
char *stopper;
// Check for unsigned
if (String[StringLen - 1] == 'u' || String[StringLen - 1] == 'U' ||
String[StringLen - 2] == 'u' || String[StringLen - 2] == 'U')
{
TokenType = TK_UIntConst;
Number = strtoul(String, &stopper, 0);
Float = (unsigned)Number;
}
else
{
Number = strtol(String, &stopper, 0);
Float = Number;
}
}
else if (TokenType == TK_FloatConst)
{
char *stopper;
Float = strtod(String, &stopper);
}
else if (TokenType == TK_StringConst)
{
StringLen = strbin(String);
}
return true;
}
return false;
}
local void ProcessRecord( // PROCESS A RECORD OF INPUT
int kw, // - key-word for record
char *record )// - record
{
SEGMENT *seg; // - current segment
switch( kw ) {
case KW_SEGMENT:
PushSegStack();
switch( ProcessMode ) {
case MODE_DELETE:
ProcessMode = MODE_SKIPPING;
break;
case MODE_OUTPUT:
SegmentCheck();
break;
}
break;
case KW_ELSESEGMENT:
switch( ProcessMode ) {
case MODE_DELETE:
EatWhite();
if( *Rptr == '\0' ) {
ProcessMode = MODE_OUTPUT;
} else {
SegmentCheck();
}
break;
case MODE_OUTPUT:
ProcessMode = MODE_SKIPPING;
break;
}
break;
case KW_ENDSEGMENT:
PopSegStack();
break;
case KW_KEEP:
switch( ProcessMode ) {
case MODE_OUTPUT:
seg = ScanSegment();
if( seg != NULL )
seg->seg_type = SEG_KEEP;
break;
}
break;
case KW_REMOVE:
switch( ProcessMode ) {
case MODE_OUTPUT:
seg = ScanSegment();
if( seg != NULL )
seg->seg_type = SEG_REMOVE;
break;
}
break;
case KW_INCLUDE:
switch( ProcessMode ) {
case MODE_OUTPUT:
if( ScanString() ) {
OpenFileNormal( Token, "r" );
} else {
Error( "Missing or invalid inclusion file" );
}
break;
}
break;
case KW_TEXT:
switch( ProcessMode ) {
case MODE_OUTPUT:
OutputString( OutFmt, record );
PutNL();
break;
}
break;
}
}
// ****************************************************************************
// Constructor: Atom::Atom
//
// Arguments:
// line the line of text in a PDB file
//
// Programmer: Jeremy Meredith
// Creation: March 23, 2006
//
// Modifications:
// Brad Whitlock, Fri Jun 2 13:15:47 PST 2006
// Added Jeremy's fix for yet another style of ATOM line.
//
// Jeremy Meredith, Mon Aug 28 17:58:02 EDT 2006
// Changed the scanning to (a) match the PDB spec document more
// effectively, (b) be faster, and (c) handle some missing elements
// (short lines) better.
//
// Jeremy Meredith, Wed Oct 17 11:27:10 EDT 2007
// Added compound support.
//
// ****************************************************************************
eavlPDBImporter::Atom::Atom(const char *line, int cmpnd)
{
char record[7];
int len = strlen(line);
ScanString(line, len, 1, 6, record);
ScanInt (line, len, 7, 11, &serial);
ScanString(line, len, 13, 16, name);
ScanChar (line, len, 17, &altloc);
ScanString(line, len, 18, 20, resname);
ScanChar (line, len, 22, &chainid);
ScanInt (line, len, 23, 26, &resseq);
ScanChar (line, len, 27, &icode);
ScanFloat (line, len, 31, 38, &x);
ScanFloat (line, len, 39, 46, &y);
ScanFloat (line, len, 47, 54, &z);
ScanFloat (line, len, 55, 60, &occupancy);
ScanFloat (line, len, 61, 66, &tempfactor);
ScanString(line, len, 73, 76, segid);
ScanString(line, len, 77, 78, element);
ScanString(line, len, 79, 80, charge);
// Left-justify element names
if (element[0] == ' ')
{
element[0] = element[1];
element[1] = '\0';
}
if((atomicnumber = ElementNameToAtomicNumber(element)) < 0)
{
// We have a weird file that does not keep the element name in
// the place designated by the ATOM record. Files like this seem
// to use the space for a line number. Check columns 12,13
// for the atom number.
if(line[12] == ' ' || (line[12] >= '0' && line[12] <= '9'))
{
element[0] = line[13];
element[1] = '\0';
}
else if (line[13] >= '0' && line[13] <= '9')
{
element[0] = line[12];
element[1] = '\0';
}
else
{
element[0] = line[12];
element[1] = line[13];
}
atomicnumber = ElementNameToAtomicNumber(element);
if (atomicnumber < 0 &&
element[1] != '\0')
{
element[1] = '\0';
atomicnumber = ElementNameToAtomicNumber(element);
}
if (atomicnumber < 0)
{
char msg[2000];
snprintf(msg, 2000, "Unknown element name <%s> in line: %s",
element, line);
THROW(eavlException, msg);
}
}
// Shift spaces out of the resname.
if(resname[0] == ' ')
{
if(resname[1] == ' ')
{
resname[0] = resname[2];
resname[1] = '\0';
}
else
{
resname[0] = resname[1];
resname[1] = resname[2];
resname[2] = '\0';
}
}
// Look up the residue number from the name.
if((residuenumber = ResiduenameToNumber(resname)) < 0)
{
residuenumber = 0;
}
backbone = false;
if (strcmp(name, " N ")==0 ||
strcmp(name, " C ")==0 ||
strcmp(name, " CA ")==0)
{
backbone = true;
}
compound = cmpnd;
}
bool FScanner::GetString ()
{
return ScanString (false);
}
void
LEXR::ScanToken(TKN * ptkn)
{
char ch;
char chT;
BOOL fSpace;
/* Skip over any white space at the beginning of the next token.
*/
fSpace = fFalse;
while (fTrue) {
ch = ChNext();
/* Check for end of line.
*/
if ((ch == '\n') || (ch == '\0')) {
break;
}
/* If doing Intel or Motorola style assembler, check for comment.
*/
if (flg.FTst(flgLexrStyleIntel|flgLexrStyleMotorola) && (ch == ';')) {
ch = ChEatUntil('\0');
break;
}
/* The Motorola Freeware assemblers use the convention
** of an '*' in the first column on a line to make the
** entire line a comment.
*/
if (flg.FTst(flgLexrStyleMotorola) &&
((ch == '*') && (ichCur == 0))) {
ch = ChEatUntil('\0');
break;
}
/* The C/C++ convention for a single line comment is a
** double slash.
*/
if (flg.FTst(flgLexrStyleC) && (ch == '/')) {
chT = ChNext();
if (chT == '/') {
ch = ChEatUntil('\0');
}
else {
UngetCh(chT);
}
break;
}
/* Any non white space character is the start of the token.
*/
if (!FIsSpace(ch)) {
break;
}
fSpace = fTrue;
}
/* We have skipped any white space in front of the next token
** and ch contains the first character of the token. Decide what
** kind of token it is and proceed accordingly.
*/
if (flg.FTst(flgLexrNoSkipSpace) && fSpace) {
/* If we return space as a token, indicate that we have
** seen some white space.
*/
ptkn->SetTktTkn(tktSpace);
}
else if ((ch == '\n') || (ch == '\0')) {
ptkn->SetTktTkn(tktEoln);
}
else if (FScanOperator(ch)) {
ptkn->SetTktTkn(tktOperator);
}
#if OptLexrDigitTokens != 0
else if (FScanDigit(ch)) {
ptkn->SetTktTkn(tktDigit);
}
#endif
else if (FScanConstant(ch)) {
ptkn->SetTktTkn(tktConstant);
}
else if (FScanSymbol(ch)) {
ptkn->SetTktTkn(tktSymbol);
#if OptLexrKeywords != 0
if (mpsmKwd.find(ptkn->SzToken()) != mpsmKwd.end()) {
ptkn->SetTktTkn(tktKeyword);
ptkn->SetId(mpsmKwd[ptkn->SzToken()]);
}
#endif
}
else if (ch == '"') {
ScanString(ch);
}
else if (ch == ':') {
ptkn->SetTktTkn(tktColon);
}
else if (ch == ';') {
ptkn->SetTktTkn(tktSemicolon);
}
else if (ch == ',') {
ptkn->SetTktTkn(tktComma);
}
else if ((ch == '$') && !flg.FTst(flgLexrStyleNoDollar)) {
ptkn->SetTktTkn(tktDollar);
}
else if (ch == '#') {
ptkn->SetTktTkn(tktHash);
}
else if (ch == '(') {
ptkn->SetTktTkn(tktLPara);
}
else if (ch == ')') {
ptkn->SetTktTkn(tktRPara);
}
else if (ch == '[') {
ptkn->SetTktTkn(tktLBracket);
}
else if (ch == ']') {
ptkn->SetTktTkn(tktRBracket);
}
else if (ch == '{') {
ptkn->SetTktTkn(tktLBrace);
}
else if (ch == '}') {
ptkn->SetTktTkn(tktRBrace);
}
else {
/* This character isn't a valid first character for any token
** so we have an error.
*/
ptkn->SetErr(errTknInvalidChar);
}
/* If we got any errors, change the token type to invalid.
*/
if (ptkn->Err() != errLexrOK) {
ptkn->SetTktTkn(tktInvalid);
}
}
globle void GetToken(
void *theEnv,
const char *logicalName,
struct token *theToken)
{
int inchar;
unsigned short type;
/*=======================================*/
/* Set Unknown default values for token. */
/*=======================================*/
theToken->type = UNKNOWN_VALUE;
theToken->value = NULL;
theToken->printForm = "unknown";
ScannerData(theEnv)->GlobalPos = 0;
ScannerData(theEnv)->GlobalMax = 0;
/*==============================================*/
/* Remove all white space before processing the */
/* GetToken() request. */
/*==============================================*/
inchar = EnvGetcRouter(theEnv,logicalName);
while ((inchar == ' ') || (inchar == '\n') || (inchar == '\f') ||
(inchar == '\r') || (inchar == ';') || (inchar == '\t'))
{
/*=======================*/
/* Remove comment lines. */
/*=======================*/
if (inchar == ';')
{
inchar = EnvGetcRouter(theEnv,logicalName);
while ((inchar != '\n') && (inchar != '\r') && (inchar != EOF) )
{ inchar = EnvGetcRouter(theEnv,logicalName); }
}
inchar = EnvGetcRouter(theEnv,logicalName);
}
/*==========================*/
/* Process Symbolic Tokens. */
/*==========================*/
if (isalpha(inchar) || IsUTF8MultiByteStart(inchar))
{
theToken->type = SYMBOL;
EnvUngetcRouter(theEnv,inchar,logicalName);
theToken->value = (void *) ScanSymbol(theEnv,logicalName,0,&type);
theToken->printForm = ValueToString(theToken->value);
}
/*===============================================*/
/* Process Number Tokens beginning with a digit. */
/*===============================================*/
else if (isdigit(inchar))
{
EnvUngetcRouter(theEnv,inchar,logicalName);
ScanNumber(theEnv,logicalName,theToken);
}
else switch (inchar)
{
/*========================*/
/* Process String Tokens. */
/*========================*/
case '"':
theToken->value = (void *) ScanString(theEnv,logicalName);
theToken->type = STRING;
theToken->printForm = StringPrintForm(theEnv,ValueToString(theToken->value));
break;
/*=======================================*/
/* Process Tokens that might be numbers. */
/*=======================================*/
case '-':
case '.':
case '+':
EnvUngetcRouter(theEnv,inchar,logicalName);
ScanNumber(theEnv,logicalName,theToken);
break;
/*===================================*/
/* Process ? and ?<variable> Tokens. */
/*===================================*/
case '?':
inchar = EnvGetcRouter(theEnv,logicalName);
if (isalpha(inchar) || IsUTF8MultiByteStart(inchar)
#if DEFGLOBAL_CONSTRUCT
|| (inchar == '*'))
#else
)
#endif
{
EnvUngetcRouter(theEnv,inchar,logicalName);
theToken->value = (void *) ScanSymbol(theEnv,logicalName,0,&type);
theToken->type = SF_VARIABLE;
#if DEFGLOBAL_CONSTRUCT
if ((ValueToString(theToken->value)[0] == '*') &&
(((int) strlen(ValueToString(theToken->value))) > 1) &&
(ValueToString(theToken->value)[strlen(ValueToString(theToken->value)) - 1] == '*'))
{
size_t count;
theToken->type = GBL_VARIABLE;
theToken->printForm = AppendStrings(theEnv,"?",ValueToString(theToken->value));
count = strlen(ScannerData(theEnv)->GlobalString);
ScannerData(theEnv)->GlobalString[count-1] = EOS;
theToken->value = EnvAddSymbol(theEnv,ScannerData(theEnv)->GlobalString+1);
ScannerData(theEnv)->GlobalString[count-1] = (char) inchar;
}
else
#endif
theToken->printForm = AppendStrings(theEnv,"?",ValueToString(theToken->value));
}
else
{
theToken->type = SF_WILDCARD;
theToken->value = (void *) EnvAddSymbol(theEnv,"?");
EnvUngetcRouter(theEnv,inchar,logicalName);
theToken->printForm = "?";
}
break;
/*=====================================*/
/* Process $? and $?<variable> Tokens. */
/*=====================================*/
case '$':
if ((inchar = EnvGetcRouter(theEnv,logicalName)) == '?')
{
inchar = EnvGetcRouter(theEnv,logicalName);
if (isalpha(inchar) || IsUTF8MultiByteStart(inchar)
#if DEFGLOBAL_CONSTRUCT
|| (inchar == '*'))
#else
)
#endif
{
EnvUngetcRouter(theEnv,inchar,logicalName);
theToken->value = (void *) ScanSymbol(theEnv,logicalName,0,&type);
theToken->type = MF_VARIABLE;
#if DEFGLOBAL_CONSTRUCT
if ((ValueToString(theToken->value)[0] == '*') &&
((int) (strlen(ValueToString(theToken->value))) > 1) &&
(ValueToString(theToken->value)[strlen(ValueToString(theToken->value)) - 1] == '*'))
{
size_t count;
theToken->type = MF_GBL_VARIABLE;
theToken->printForm = AppendStrings(theEnv,"$?",ValueToString(theToken->value));
count = strlen(ScannerData(theEnv)->GlobalString);
ScannerData(theEnv)->GlobalString[count-1] = EOS;
theToken->value = EnvAddSymbol(theEnv,ScannerData(theEnv)->GlobalString+1);
ScannerData(theEnv)->GlobalString[count-1] = (char) inchar;
}
else
#endif
theToken->printForm = AppendStrings(theEnv,"$?",ValueToString(theToken->value));
}
else
{
void sXSILoader::ScanMesh(sInt indent,sXSIModel *model)
{
sChar buffer[256];
sChar chunk[XSISIZE];
sChar name[XSISIZE];
sChar *cmd;
sInt supports,i,j,k,max;
sInt fcount;
sInt vcount;
sXSICluster *cluster;
sInt cr,cg,cb,ca;
sInt set,set2;
sInt PosCount;
sVector *Pos;
sInt NormCount;
sVector *Norm;
sInt ColorCount;
sU32 *Color;
sInt UVCount[sXSI_MAXUV];
sF32 *UV[sXSI_MAXUV];
sChar UVName[sXSI_MAXUV][XSISIZE];
// init shape holder
PosCount = 0;
Pos = 0;
NormCount = 0;
Norm = 0;
ColorCount = 0;
Color = 0;
for(i=0;i<sXSI_MAXUV;i++)
{
UVCount[i] = 0;
UV[i] = 0;
}
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent,chunk,name);
if(sCmpString(chunk,"SI_Shape")==0)
{
supports = ScanInt();
ScanString(buffer,sizeof(buffer));
if(sCmpString(buffer,"ORDERED")!=0)
Error = sTRUE;
for(i=0;i<supports && !Error;i++)
{
max = ScanInt();
ScanString(buffer,sizeof(buffer));
if(sCmpString(buffer,"POSITION")==0)
{
sVERIFY(Pos==0);
PosCount = max;
Pos = new sVector[max];
for(j=0;j<max;j++)
{
Pos[j].x = ScanFloat();
Pos[j].y = ScanFloat();
Pos[j].z = ScanFloat();
}
}
else if(sCmpString(buffer,"NORMAL")==0)
{
sVERIFY(Norm==0);
NormCount = max;
Norm = new sVector[max];
for(j=0;j<max;j++)
{
Norm[j].x = ScanFloat();
Norm[j].y = ScanFloat();
Norm[j].z = ScanFloat();
}
}
else if(sCmpString(buffer,"COLOR")==0)
{
sVERIFY(Color==0);
ColorCount = max;
Color = new sU32[max];
for(j=0;j<max;j++)
{
cr = sRange<sInt>(ScanFloat()*255,255,0);
cg = sRange<sInt>(ScanFloat()*255,255,0);
cb = sRange<sInt>(ScanFloat()*255,255,0);
ca = sRange<sInt>(ScanFloat()*256,255,0);
Color[j] = (ca<<24)|(cb<<16)|(cg<<8)|(cr);
}
}
else if(sCmpString(buffer,"TEX_COORD_UV")==0)
{
set = 0;
sVERIFY(UV[set]==0);
UVCount[set] = max;
UV[set] = new sF32[max*2];
for(j=0;j<max;j++)
{
UV[set][j*2+0] = ScanFloat();
UV[set][j*2+1] = 1.0f-ScanFloat();
}
}
else if(sCmpMem(buffer,"TEX_COORD_UV",12)==0)
{
j=12;
set = 0;
while(buffer[j]>='0' && buffer[j]<='9')
set = set*10 + (buffer[j++]-'0');
sVERIFY(set>=0 && set<sXSI_MAXUV);
sVERIFY(UV[set]==0);
ScanString(UVName[set],sizeof(UVName[set]));
UVCount[set] = max;
UV[set] = new sF32[max*2];
for(j=0;j<max;j++)
{
UV[set][j*2+0] = ScanFloat();
UV[set][j*2+1] = 1.0f-ScanFloat();
}
}
else
{
Error = sTRUE;
}
}
EndChunk();
}
else if(sCmpString(chunk,"SI_PolygonList")==0)
{
cluster = new sXSICluster;
fcount = ScanInt();
sCopyString(buffer,"|POSITION|",sizeof(buffer));
i = sGetStringLen(buffer);
ScanString(buffer+i,sizeof(buffer)-i);
#if DUMPCHUNK
sDPrintF(" %s",buffer);
#endif
ScanString(name,sizeof(name));
cluster->Material = FindMaterial(name);
vcount = ScanInt();
cluster->VertexCount = vcount;
cluster->IndexCount = vcount;
cluster->Vertices = new sXSIVertex[vcount];
cluster->Faces = new sInt[vcount*2];
model->Clusters->Add(cluster);
j = 0;
for(i=0;i<fcount;i++)
{
max = ScanInt();
cluster->Vertices[j].Init();
cluster->Faces[j*2+0] = max;
cluster->Faces[j*2+1] = j;
j++;
for(k=1;k<max;k++)
{
cluster->Vertices[j].Init();
cluster->Faces[j*2+0] = 0;
cluster->Faces[j*2+1] = j;
j++;
}
}
sVERIFY(j==vcount);
cmd = buffer;
while(!Error && *cmd)
{
if(sCmpMem(cmd,"|POSITION",9)==0)
{
cmd+=9;
sVERIFY(Pos);
for(i=0;i<vcount;i++)
{
j = ScanInt();
cluster->Vertices[i].Pos = Pos[j];
cluster->Vertices[i].Index = j;
}
}
else if(sCmpMem(cmd,"|NORMAL",7)==0)
{
cmd+=7;
sVERIFY(Norm);
for(i=0;i<vcount;i++)
{
j = ScanInt();
cluster->Vertices[i].Normal = Norm[j];
cluster->Vertices[i].Normal.Init(0,0,0,1);
}
}
else if(sCmpMem(cmd,"|COLOR",6)==0)
{
cmd+=6;
sVERIFY(Color);
for(i=0;i<vcount;i++)
{
j = ScanInt();
cluster->Vertices[i].Color = Color[j];
}
}
else if(sCmpMem(cmd,"|TEX_COORD_UV",13)==0)
{
cmd+=13;
set = 0;
if(*cmd>='0' && *cmd<='9')
{
while(*cmd>='0' && *cmd<='9')
set = set*10 + ((*cmd++)-'0');
sVERIFY(set>=0 && set<sXSI_MAXUV);
sVERIFY(UV[set])
for(set2=0;set2<4;set2++)
if(sCmpString(TSName[cluster->Material->TUV[set2]],UVName[set])==0)
break;
}
else
{
set2 = 0;
}
for(i=0;i<vcount;i++)
{
j = ScanInt();
if(set2>=0 && set2<2)
{
cluster->Vertices[i].UV[set2][0] = 0.0f;// UV[set][j*2+0];
cluster->Vertices[i].UV[set2][1] = 0.0f;// UV[set][j*2+1];
}
}
}
else
{
void sXSILoader::ScanMatLib(sInt indent)
{
sChar chunk[XSISIZE];
sChar name[XSISIZE];
sChar texname[256];
sChar buffer[XSISIZE];
sChar pname[XSISIZE];
sChar tname[XSISIZE];
sChar tsup[2][XSISIZE];
sInt texena[2];
sXSIMaterial *mat;
sXSITexture *tex;
sInt i,max;
sInt pcount,ccount;
sInt ival;
sF32 fval;
ScanInt();
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent,chunk,name);
if(sCmpString(chunk,"SI_Material")==0)
{
mat = new sXSIMaterial;
sCopyString(mat->Name,name,sizeof(mat->Name));
mat->Flags |= 0;
Materials->Add(mat);
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat();
ScanInt();
ScanFloat(); ScanFloat(); ScanFloat();
sScanSpace(Scan);
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent+1,chunk,name);
if(sCmpString(chunk,"SI_Texture2D")==0)
{
ScanString(texname,sizeof(texname));
ScanInt(); ScanInt(); ScanInt(); ScanInt();
ScanInt(); ScanInt(); ScanInt(); ScanInt();
ScanInt(); ScanInt(); ScanInt(); ScanInt();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanInt();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat();
EndChunk();
if(mat->Tex[0] == 0)
{
tex = FindTexture(texname);
if(tex)
mat->Tex[0] = tex;
}
}
else
{
SkipChunk();
}
sScanSpace(Scan);
}
EndChunk();
}
else if(sCmpString(chunk,"XSI_Material")==0)
{
mat = new sXSIMaterial;
sCopyString(mat->Name,name,sizeof(mat->Name));
mat->TFlags[0] = 0;
mat->TFlags[1] = 0;
mat->Flags |= 0;
sDPrintF("%08x:<%s>\n",Scan,name);
Materials->Add(mat);
max = ScanInt();
for(i=0;i<max;i++)
{
ScanString(buffer,sizeof(buffer));
ScanString(buffer,sizeof(buffer));
}
sScanSpace(Scan);
tsup[0][0]=0;
tsup[0][1]=0;
texena[0] = 0;
texena[1] = 0;
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent+1,chunk,name);
if(sCmpString(chunk,"XSI_Shader")==0)
{
ScanString(buffer,sizeof(buffer));
ScanInt();
pcount = ScanInt();
ccount = ScanInt();
for(i=0;i<pcount;i++)
{
ScanString(pname,sizeof(pname));
ScanString(tname,sizeof(tname));
if(sCmpString(tname,"STRING")==0)
{
ScanString(buffer,sizeof(buffer));
if(sCmpString(pname,"tspace_id1")==0) sCopyString(tsup[0],buffer,sizeof(tsup[0]));
if(sCmpString(pname,"tspace_id" )==0) sCopyString(tsup[0],buffer,sizeof(tsup[0]));
if(sCmpString(pname,"tspace_id2")==0) sCopyString(tsup[1],buffer,sizeof(tsup[1]));
}
else if(sCmpString(tname,"FLOAT")==0)
{
fval = ScanFloat();
ival = sRange<sInt>(255*fval,255,0);
if(sCmpString(pname,"Ambient.red")==0) mat->Ambient.r = ival;
if(sCmpString(pname,"Ambient.green")==0) mat->Ambient.g = ival;
if(sCmpString(pname,"Ambient.blue")==0) mat->Ambient.b = ival;
if(sCmpString(pname,"Diffuse.red")==0) mat->Diffuse.r = ival;
if(sCmpString(pname,"Diffuse.green")==0) mat->Diffuse.g = ival;
if(sCmpString(pname,"Diffuse.blue")==0) mat->Diffuse.b = ival;
if(sCmpString(pname,"Specular.red")==0) mat->Specular.r = ival;
if(sCmpString(pname,"Specular.green")==0) mat->Specular.g = ival;
if(sCmpString(pname,"Specular.blue")==0) mat->Specular.b = ival;
if(sCmpString(pname,"Shininess")==0) mat->Specularity = fval;
}
else if(sCmpString(tname,"INTEGER")==0)
{
ival = ScanInt();
}
else if(sCmpString(tname,"BOOLEAN")==0)
{
ival = ScanInt();
if(ival!=0)
{
// if(sCmpString(pname,"WrapS1")==0) mat->TFlags[0] |= sMTF_TILE;
// if(sCmpString(pname,"WrapT1")==0) mat->TFlags[0] |= sMTF_TILE;
if(sCmpString(pname,"Refmap1")==0) mat->TFlags[0] |= sMTF_UVENVI;
if(sCmpString(pname,"Texture_1_Enable")==0) texena[0]=1;
// if(sCmpString(pname,"WrapS2")==0) mat->TFlags[1] |= sMTF_TILE;
// if(sCmpString(pname,"WrapT2")==0) mat->TFlags[1] |= sMTF_TILE;
if(sCmpString(pname,"Refmap2")==0) mat->TFlags[1] |= sMTF_UVENVI;
if(sCmpString(pname,"Texture_2_Enable")==0) texena[1]=1;
}
else
{
if(sCmpString(pname,"Enable_Ambient")==0) mat->Ambient = 0xffffffff;
if(sCmpString(pname,"Enable_Diffuse")==0) mat->Diffuse = 0xffffffff;
if(sCmpString(pname,"Enable_Specular")==0) mat->Specular = 0xffffffff;
if(sCmpString(pname,"Enable_Shininess")==0) mat->Specularity = 0;
// if(sCmpString(pname,"Enable_Lighting")==0) mat->Flags &= ~sMF_LIGHTMASK;
}
}
else
{
Error = sTRUE;
}
}
for(i=0;i<ccount;i++)
{
ScanString(pname,sizeof(pname));
ScanString(buffer,sizeof(buffer));
ScanString(tname,sizeof(tname));
if(sCmpString(tname,"IMAGE")==0)
{
if((sCmpString(pname,"Texture_1")==0 || sCmpString(pname,"tex")==0) && texena[0])
{
if(mat->Tex[0] == 0
&& (tsup[0][0]!=0 || (mat->TFlags[0]&sMTF_UVMASK)==sMTF_UVENVI)
&& TSCount<sXSI_MAXTS)
{
tex = FindTexture(buffer);
if(tex)
{
mat->Tex[0] = tex;
mat->Mode = sMBM_TEX;
sCopyString(TSName[TSCount],tsup[0],XSISIZE);
mat->TUV[0] = TSCount++;
}
}
}
if(sCmpString(pname,"Texture_2")==0 && texena[1])
{
if(mat->Tex[1] == 0
&& (tsup[1][0]!=0 || (mat->TFlags[1]&sMTF_UVMASK)==sMTF_UVENVI)
&& TSCount<sXSI_MAXTS)
{
tex = FindTexture(buffer);
if(tex)
{
mat->Tex[1] = tex;
mat->Mode = sMBM_MUL;
// mat->TFlags[1] = sMTF_FILTER|sMTF_MIPMAP;//|sMTF_UVENVI;
sCopyString(TSName[TSCount],tsup[1],XSISIZE);
mat->TUV[1] = TSCount++;
}
}
}
}
}
sScanSpace(Scan);
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent+1,chunk,name);
SkipChunk();
sScanSpace(Scan);
}
EndChunk();
}
else
{
SkipChunk();
}
sScanSpace(Scan);
}
if((mat->TFlags[1] & sMTF_UVMASK)==0)
mat->TFlags[1] |= sMTF_UV1;
if(mat->Specularity>0.0001f || mat->Ambient!=0xffffffff
|| mat->Diffuse != 0xffffffff || mat->Specular != 0xffffffff)
{
// mat->Flags = (mat->Flags & (~sMF_LIGHTMASK)) | sMF_LIGHTMAT;
// sDPrintF("extlight: %08x %08x %08x\n",mat->Diffuse.Color,mat->Ambient.Color,mat->Specular.Color);
}
else
{
// mat->Flags |= sMF_COLBOTH;
}
mat->TFlags[0] |= sMTF_FILTERMIN | sMTF_FILTERMAG | sMTF_MIPMAP;
mat->TFlags[1] |= sMTF_FILTERMIN | sMTF_FILTERMAG | sMTF_MIPMAP;
EndChunk();
}
else
{
SkipChunk();
}
sScanSpace(Scan);
}
EndChunk();
}
sBool MAPFileReader::ReadDebugInfo(sChar *fileName,DebugInfo &to)
{
PUnDecorateSymbolName UnDecorateSymbolName = 0;
// determine map file name
sChar fileBuf[260];
sChar *text;
sInt i;
sCopyString(fileBuf,fileName,256);
for(i=sGetStringLen(fileBuf)-1;i>=0 && fileBuf[i] != '.';i--);
if(i > 0)
sCopyString(fileBuf + i,".map",260-i);
else
sAppendString(fileBuf,".map",260);
text = (sChar *) sSystem->LoadFile(fileBuf);
if(!text)
return sFALSE;
// load dbghelp.dll to resolve symbol names if available
void *module = LoadLibraryA("dbghelp.dll");
if(module)
UnDecorateSymbolName = (PUnDecorateSymbolName) GetProcAddress(module,"UnDecorateSymbolName");
// actual reading code
sChar *line,buffer[2048];
sInt j,code,data;
sInt snum,offs,type,name,VA,fname;
sInt symStart = to.Symbols.Count;
Section *sec;
DISymbol *sym;
Sections.Init();
code = to.MakeString("CODE");
data = to.MakeString("DATA");
while(*text)
{
// find end of line
line = text;
while(*text && *text != '\n')
text++;
if(text[-1] == '\r' && text[0] == '\n')
text[-1] = 0;
if(*text)
*text++ = 0;
// parse this line of text
if(line[0]==' ' && IsHexString(line+1,4) && line[5]==':'
&& IsHexString(line+6,8) && line[14]==' ')
{
if(IsHexString(line+15,8)) // section definition
{
sec = Sections.Add();
line += 1; sec->Num = sScanHex(line);
line += 1; sec->Start = sScanHex(line);
line += 1; sec->Length = sScanHex(line);
line += 2; sec->Name.Index = ScanString(line,to);
sScanSpace(line);
type = ScanString(line,to);
if(type == code)
sec->Class = DIC_CODE;
else if(type == data)
sec->Class = DIC_DATA;
else
sec->Class = DIC_UNKNOWN;
sec->Seen = sFALSE;
}
else // assume name definition
{
line += 1; snum = sScanHex(line);
line += 1; offs = sScanHex(line);
sec = GetSection(snum,offs);
if(sec)
{
sScanSpace(line);
name = ScanString(line,to);
sScanSpace(line);
VA = sScanHex(line);
line += 5; fname = ScanString(line,to);
if(!sec->Seen)
{
sym = to.Symbols.Add();
sSPrintF(buffer,2048,"__end%s",to.GetStringPrep(sec->Name.Index));
sym->Name.Index = to.MakeString(buffer);
sym->FileNum = -1;
sym->VA = VA-offs+sec->Start+sec->Length;
sym->Size = 0;
sym->Class = DIC_END;
sec->Seen = sTRUE;
}
if(UnDecorateSymbolName)
UnDecorateSymbolName(to.GetStringPrep(name),buffer,2048,0x1800);
else
sCopyString(buffer,to.GetStringPrep(name),2048);
// add symbol
sym = to.Symbols.Add();
sym->Name.Index = to.MakeString(buffer);
sym->MangledName.Index = name;
sym->FileNum = to.GetFile(fname);
sym->VA = VA;
sym->Size = 0;
sym->Class = sec->Class;
sym->NameSpNum = to.GetNameSpaceByName(buffer);
}
}
}
else if(!sCmpMem(line," Preferred load address is ",28) && IsHexString(line+28,8))
{
line += 28;
sU32 base = sScanHex(line);
to.SetBaseAddress(base);
}
}
// sort symbols by virtual address
for(i=symStart+1;i<to.Symbols.Count;i++)
for(j=i;j>symStart;j--)
if(to.Symbols[j].VA<to.Symbols[j-1].VA)
sSwap(to.Symbols[j],to.Symbols[j-1]);
// calc sizes
for(i=symStart;i<to.Symbols.Count;i++)
{
sym = &to.Symbols[i];
if(sym->Class!=DIC_END)
{
sVERIFY(i != to.Symbols.Count-1);
sym->Size = sym[1].VA - sym->VA;
}
}
// cleanup
Sections.Exit();
delete[] text;
return sTRUE;
}
tokens JSONScanner::Scan()
{
pTokenString = currentChar;
while (currentChar < inputText + inputLen)
{
switch(ReadNextChar())
{
case 0:
//EOF
currentChar--;
return (pToken->tk = tkEOF);
case '\t':
case '\r':
case '\n':
case ' ':
//WS - keep looping
break;
case '"':
//check for string
return ScanString();
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
//decimal digit starts a number
{
currentChar--;
// we use StrToDbl() here for compat with the rest of the engine. StrToDbl() accept a larger syntax.
// Verify first the JSON grammar.
const char16* saveCurrentChar = currentChar;
if(!IsJSONNumber())
{
ThrowSyntaxError(JSERR_JsonBadNumber);
}
currentChar = saveCurrentChar;
double val;
const char16* end;
val = Js::NumberUtilities::StrToDbl(currentChar, &end, scriptContext);
if(currentChar == end)
{
ThrowSyntaxError(JSERR_JsonBadNumber);
}
AssertMsg(!Js::JavascriptNumber::IsNan(val), "Bad result from string to double conversion");
pToken->tk = tkFltCon;
pToken->SetDouble(val, false);
currentChar = end;
return tkFltCon;
}
case ',':
return (pToken->tk = tkComma);
case ':':
return (pToken->tk = tkColon);
case '[':
return (pToken->tk = tkLBrack);
case ']':
return (pToken->tk = tkRBrack);
case '-':
return (pToken->tk = tkSub);
case 'n':
//check for 'null'
if (currentChar + 2 < inputText + inputLen && currentChar[0] == 'u' && currentChar[1] == 'l' && currentChar[2] == 'l')
{
currentChar += 3;
return (pToken->tk = tkNULL);
}
ThrowSyntaxError(JSERR_JsonIllegalChar);
case 't':
//check for 'true'
if (currentChar + 2 < inputText + inputLen && currentChar[0] == 'r' && currentChar[1] == 'u' && currentChar[2] == 'e')
{
currentChar += 3;
return (pToken->tk = tkTRUE);
}
ThrowSyntaxError(JSERR_JsonIllegalChar);
case 'f':
//check for 'false'
if (currentChar + 3 < inputText + inputLen && currentChar[0] == 'a' && currentChar[1] == 'l' && currentChar[2] == 's' && currentChar[3] == 'e')
{
currentChar += 4;
return (pToken->tk = tkFALSE);
}
ThrowSyntaxError(JSERR_JsonIllegalChar);
case '{':
return (pToken->tk = tkLCurly);
case '}':
return (pToken->tk = tkRCurly);
default:
ThrowSyntaxError(JSERR_JsonIllegalChar);
}
}
return (pToken->tk = tkEOF);
}
Lexer::TokenType Lexer::NextToken()
{
m_lastTokenRange = m_thisTokenRange;
NextChar();
// Skip blanks and comments
SkipBlanks();
SkipComments();
// Start remembering this token
int start = CharPosition();
m_thisTokenRange.m_start = start;
tp = m_token;
char ch = m_cc;
*tp++ = ch;
if (!ch)
{
// Hit EOF straightaway - so be careful not to write another Null term into the token
// as this would involve writing off the end of the token buffer
m_tokenType = Eof;
m_thisTokenRange.m_stop = start;
m_thisTokenRange.m_start = start + 1;
}
else
{
if (isIdentifierFirst(ch))
{
ScanIdentifierOrKeyword();
}
else if (isdigit(ch))
{
ScanNumber();
}
else if (ch == '-' && isdigit(PeekAtChar()))
{
Step();
ScanNumber();
if (m_tokenType == SmallIntegerConst)
m_integer *= -1;
}
else if (ch == LITERAL)
{
ScanLiteral();
}
else if (ch == STRINGDELIM)
{
int stringStart = CharPosition();
// String constant; remove quote
tp--;
ScanString(stringStart);
m_tokenType = StringConst;
}
else if (ch == CHARLITERAL)
{
ScanLiteralCharacter();
}
else if (ch == '^')
{
m_tokenType = Return;
}
else if (ch == ':')
{
if (PeekAtChar() == '=')
{
m_tokenType = Assignment;
*tp++ = NextChar();
}
else
m_tokenType = Special;
}
else if (ch == ')')
{
m_tokenType = CloseParen;
}
else if (ch == '.')
{
m_tokenType = CloseStatement;
}
else if (ch == ']')
{
m_tokenType = CloseSquare;
}
else if (ch == ';')
{
m_tokenType = Cascade;
}
else if (IsASingleBinaryChar(ch))
{
// Single binary expressions
m_tokenType = Binary;
}
else if (isAnsiBinaryChar(ch))
{
m_tokenType = Binary;
}
else
{
int pos = CharPosition();
CompileError(TEXTRANGE(pos, pos), LErrBadChar);
}
*tp = '\0';
}
m_thisTokenRange.m_stop = CharPosition();
return m_tokenType;
}
BOOL IniParsReadFile(IniParsStruct *Data, Map *CfgValues)
{ int Token, i;
BOOL Ret;
IniValue *ValuePtr;
Ret = TRUE;
do {
Token = Scan(IniParsGetScanner(Data));
if (Token == EofSy)
{
}
else if (Token == HashSy)
{
ScanUeberlesen(IniParsGetScanner(Data));
Token = Scan(IniParsGetScanner(Data));
}
else
{
i = 0;
while ((i < IniParsGetAnzKeywords(Data)) &&
(IniParsGetKeywords(Data)[i].Symbol != Token))
{
i++;
}
if (i < IniParsGetAnzKeywords(Data))
{
Token = Scan(IniParsGetScanner(Data));
if ((IniParsGetKeywords(Data)[i].DataType == IniParsString) &&
(Token == ZeichenkettenSy))
{
ValuePtr = (IniValue *)MapGet(CfgValues,
(MapKeyType)IniParsGetKeywords(Data)[i].Keyword);
if (ValuePtr == (IniValue *)NULL)
{
ValuePtr = malloc(sizeof(IniValue));
ValuePtr->DataType = IniParsString;
ValuePtr->IntValue = 0;
ScanString(IniParsGetScanner(Data), ValuePtr->StringValue);
MapSet(CfgValues,
(MapKeyType *)strdup(IniParsGetKeywords(Data)[i].Keyword),
(MapDataType)ValuePtr);
}
else
{
ValuePtr->DataType = IniParsString;
ValuePtr->IntValue = 0;
ScanString(IniParsGetScanner(Data), ValuePtr->StringValue);
}
}
else if ((IniParsGetKeywords(Data)[i].DataType == IniParsInt) &&
(Token == GzahlSy))
{
ValuePtr = (IniValue *)MapGet(CfgValues,
(MapKeyType)IniParsGetKeywords(Data)[i].Keyword);
if (ValuePtr == (IniValue *)NULL)
{
ValuePtr = malloc(sizeof(IniValue));
ValuePtr->DataType = IniParsInt;
ValuePtr->IntValue = ScanGanz(IniParsGetScanner(Data));
ValuePtr->StringValue[0] = '\0';
MapSet(CfgValues,
(MapKeyType)strdup(IniParsGetKeywords(Data)[i].Keyword),
(MapDataType)ValuePtr);
}
else
{
ValuePtr->DataType = IniParsInt;
ValuePtr->IntValue = ScanGanz(IniParsGetScanner(Data));
ValuePtr->StringValue[0] = '\0';
}
}
else
{
Ret = FALSE;
}
}
else
{
Token = Scan(IniParsGetScanner(Data));
Ret = FALSE;
}
Token = Scan(IniParsGetScanner(Data));
if (Token == HashSy)
{
ScanUeberlesen(IniParsGetScanner(Data));
Token = Scan(IniParsGetScanner(Data));
}
}
} while (Token != EofSy);
return(Ret);
}
