/*
* skip to the end of the current string and the beginning of the next one
*/
int
xpmNextString(xpmData *data)
{
if (!data->type)
data->cptr = (data->stream.data)[++data->line];
else if (data->type == XPMBUFFER) {
register char c;
/* get to the end of the current string */
if (data->Eos)
while ((c = *data->cptr++) && c != data->Eos);
/*
* then get to the beginning of the next string looking for possible
* comment
*/
if (data->Bos) {
while ((c = *data->cptr++) && c != data->Bos)
if (data->Bcmt && c == data->Bcmt[0])
ParseComment(data);
} else if (data->Bcmt) { /* XPM2 natural */
while ((c = *data->cptr++) == data->Bcmt[0])
ParseComment(data);
data->cptr--;
}
} else {
register int c;
FILE *file = data->stream.file;
/* get to the end of the current string */
if (data->Eos)
while ((c = Getc(data, file)) != data->Eos && c != EOF);
/*
* then get to the beginning of the next string looking for possible
* comment
*/
if (data->Bos) {
while ((c = Getc(data, file)) != data->Bos && c != EOF)
if (data->Bcmt && c == data->Bcmt[0])
ParseComment(data);
} else if (data->Bcmt) { /* XPM2 natural */
while ((c = Getc(data, file)) == data->Bcmt[0])
ParseComment(data);
Ungetc(data, c, file);
}
}
return 0;
}
/* IScanner */
static inline int ParseValue(struct IParse *parse, struct ISection *section)
{
ParseComment(parse);
ParseSkip(parse);
/* Value Name */
char name[MAX_NAME];
if (!ParseName(parse, name, MAX_NAME)) {
return 0;
}
ParseSkip(parse);
int code = ParsePeek(parse, 0);
if (!(code == '=')) {
return 0;
}
ParseRead(parse); /* = */
ParseSkip(parse);
/* Value Data */
char data[MAX_VALUE];
if (!ParseData(parse, data, MAX_VALUE)) {
return 0;
}
AddSectionString(section, name, data);
return 1;
}
/* IScanner */
static inline int ParseSection(struct IParse *parse, struct ISettings *settings)
{
ParseComment(parse);
ParseSkip(parse);
int code = ParsePeek(parse, 0);
if (!(code == '[')) {
return 0;
}
ParseRead(parse); /* [ */
ParseSkip(parse);
/* Section Name */
char name[MAX_NAME];
if (!ParseName(parse, name, MAX_NAME)) {
return 0;
}
ParseSkip(parse);
code = ParsePeek(parse, 0);
if (!(code == ']')) {
return 0;
}
ParseRead(parse); /* "]" */
HSECTION section = NULL;
if (!(section = CreateSection(settings, name))) {
return 0;
}
while (ParseValue(parse, section));
return 1;
}
// Get a single char token
bool SqlParser::GetSingleCharToken(Token *token)
{
if(token == NULL)
return false;
bool exists = false;
while(_remain_size > 0)
{
const char *cur = _next_start;
// Check for a comment, but do not return it as a token
if(ParseComment() == true)
continue;
// Check for quoted identifier
exists = GetQuotedIdentifier(token);
if(exists == true)
break;
// Check for string literal
exists = GetStringLiteral(token);
if(exists == true)
break;
// Return if not a single char
if(strchr(g_symbols, *cur) == NULL)
break;
_next_start++;
_remain_size--;
token->type = TOKEN_SYMBOL;
token->chr = *cur;
token->wchr = 0;
token->str = NULL;
token->wstr = NULL;
token->len = 0;
token->remain_size = _remain_size;
token->next_start = _next_start;
_tokens.Add(token);
cur++;
exists = true;
break;
}
return exists;
}
void DwRfc1521Tokenizer::ParseToken()
{
// Assume the field body has already been extracted. That is, we don't
// have to watch for the end of the field body or folding. We just
// treat any CRs or LFs as white space.
mTokenStart = mNextStart;
mTokenLength = 0;
mTkType = eTkNull;
if (mTokenStart >= mString.length()) {
return;
}
// Skip leading space. Also, since control chars are not permitted
// in atoms, skip these, too.
while (1) {
if (mTokenStart >= mString.length()) {
return;
}
if (!isspace(mString[mTokenStart]) && !iscntrl(mString[mTokenStart]))
break;
++mTokenStart;
}
char ch = mString[mTokenStart];
// Quoted string
if (ch == '"') {
mTkType = eTkQuotedString;
ParseQuotedString();
}
// Comment
else if (ch == '(') {
mTkType = eTkComment;
ParseComment();
}
// Domain literal
else if (ch == '[') {
mTkType = eTkDomainLiteral;
ParseDomainLiteral();
}
// Special
else if (istspecial(ch)) {
mTkType = eTkTspecial;
mTokenLength = 1;
mToken = mString.substr(mTokenStart, 1);
mNextStart = mTokenStart + 1;
}
// Atom
else {
mTkType = eTkToken;
ParseAtom();
}
if (mDebugOut) PrintToken(mDebugOut);
}
void MIME::Headers::SetType (std::string const & type, std::string const & comment)
{
unsigned curPos = 0;
// type/subtype delimited by semicolon
unsigned slashPos = type.find ('/', curPos);
if (slashPos != std::string::npos)
{
_type = type.substr (curPos, slashPos - curPos);
curPos = slashPos + 1;
_subtype = type.substr (curPos);
}
else
{
_type = type.substr (curPos);
}
ParseComment (comment, _typeAttrib);
}
void
XMLParser::ParseLevel()
{
// MAIN PARSING LOOP
while(*m_pointer)
{
// STEP 1: Skip whitespace
SkipOuterWhiteSpace();
// STEP 2: Check for end
if(!*m_pointer)
{
return;
}
// STEP 3: Check for a node
if(*m_pointer != '<')
{
SetError(XmlError::XE_NotAnXMLMessage,m_pointer);
return;
}
// STEP 4: One of five node types
if(strncmp((const char*)m_pointer,"<?xml",5) == 0)
{
ParseDeclaration();
}
else if(strncmp((const char*)m_pointer,"<!--",4) == 0)
{
ParseComment();
}
else if(strncmp((const char*)m_pointer,"<![CDATA[",9) == 0)
{
ParseCDATA();
return;
}
else if(strncmp((const char*)m_pointer,"<!",2) == 0)
{
ParseDTD();
}
else if(ParseElement())
{
ParseAfterElement();
return;
}
}
}
/**
\fn int ParseFile (FILE* file, Comment* result)
\brief parse a file and put the documentation comments to result
\param file the file for the parsing
\param result the table which contains the documentation comments
\return the number of documentation comments find during the parsing
*/
int ParseFile (FILE* file, Comment** result){
int count=0,test=0,bloc=0;
char c,tmp;
detail=0;
while(!feof()){
c=fgetc(file);
if(test==0 && c=='/')
test++;
else
if(bloc==1){
bloc==0;
count++;
}
if(test==1 && (c=='/' || c=='*')){
tmp=c;
test++;
}
else {
test=0;
if(bloc==1){
bloc==0;
count++;
}
}
if(test==2 && (c=='/' || c=='*') && c=tmp){
ParseComment(file,tmp,result[count]);
bloc=1;
test=0;
}
else{
test=0;
if(bloc==1){
bloc==0;
count++;
}
}
}
return count;
}
// Main recursive parsing function
bool wxSimpleHtmlParser::ParseHtml(wxSimpleHtmlTag* parent)
{
while (!Eof())
{
EatWhitespace();
if (IsComment())
{
ParseComment();
}
else if (IsDirective())
{
wxSimpleHtmlTag* tag = ParseDirective();
if (tag)
parent->AppendTag(tag);
}
else if (IsTagClose())
{
wxSimpleHtmlTag* tag = ParseTagClose();
if (tag)
parent->AppendTag(tag);
}
else if (IsTagStartBracket(GetChar(m_pos)))
{
wxSimpleHtmlTag* tag = ParseTagHeader();
if (tag)
parent->AppendTag(tag);
}
else
{
// Just a text string
wxString text;
ParseText(text);
wxSimpleHtmlTag* tag = new wxSimpleHtmlTag(wxT("TEXT"), wxSimpleHtmlTag_Text);
tag->SetText(text);
parent->AppendTag(tag);
}
}
return TRUE;
}
Anything GenericXMLParser::ParseCommentCdataOrDtd(bool withindtd)
{
StartTrace(GenericXMLParser.ParseCommentCdataOrDtd);
int c;
c = Get();// read the '!'
String key("!");
Anything result;
switch (Peek()) {
case '-':
return ParseComment();
case '[':
if (!withindtd) {
return ParseCdata(); // ignore include or ignore for the moment
} else {
goto error;
}
case 'D':
if (!withindtd) {
return ParseDtd(); // DOCTYPE
} else {
goto error;
}
case 'E': // ELEMENT or ENTITY
case 'A': // ATTLIST
case 'N': // NOTATION
if (withindtd) {
key.Append(ParseName());
break;
}
default://lint !e616
error: {
String msg("unexpected character in <! element: ");
msg.Append(char(c));
Error(msg);
}
}
result[key] = SkipToClosingAngleBracket();
return result;
}
ModelData* ModelLoader::LoadModelFile(std::string filePath)
{
ifstream file;
file.open(filePath + ".obj");
if (!file)
return 0;
string str;
while (!file.eof())
{
file >> str;
if (str == "#" || str == "s") ParseComment(file);
else if (str == "v") ParsePosition(file); //position
else if (str == "vn") ParseNormal(file); //normal
else if (str == "vt") ParseTexCoord(file); //texturkoordinat
else if (str == "f") ParseFace(file); //face
else if (str == "usemtl") ParseMaterial(file); //material
else if (str == "g") ParseGroup(file); //group
else if (str == "mtllib") //materialfile
{
ParseMaterialFile(file, filePath);
}
str = "";
}
//ParseFace2(file);
ModelData* model = new ModelData();
for (auto it = m_groups.begin(); it != m_groups.end(); ++it)
model->Groups.push_back(it->second);
return model;
}
void MIME::Headers::SetDisposition (std::string const & disposition, std::string const & comment)
{
_disposition = disposition;
ParseComment (comment, _dispositionAttrib);
}
//------------------------------------------------------------------------------
Tokeniser::tokentype Tokeniser::GetNextToken ()
{
tokentype TokenType = EMPTY;
while ((TokenType == EMPTY) && !in.bad() && !atEOF)
{
curChar = GetNextChar ();
if (IsWhiteSpace (curChar))
{
// skip white space
}
else
{
if (IsPunctuation (curChar))
{
// classify punctuation token
switch (curChar)
{
case '[': ParseComment (); break;
case '\'':
if (ParseString ())
TokenType = STRING;
else TokenType = BAD;
break;
case '(':
TokenType = LPAR;
break;
case ')':
TokenType = RPAR;
break;
case '{':
TokenType = LPAR;
break;
case '}':
TokenType = RPAR;
break;
case '!':
TokenType = BANG;
break;
case '#':
TokenType = HASH;
break;
case '=':
TokenType = EQUALS;
break;
case ';':
TokenType = SEMICOLON;
break;
case ',':
TokenType = COMMA;
break;
case '*':
TokenType = ASTERIX;
break;
case ':':
TokenType = COLON;
break;
case '-':
TokenType = MINUS;
break;
case '"':
TokenType = DOUBLEQUOTE;
break;
case '/':
TokenType = BACKSLASH;
break;
default:
TokenType = OTHER;
break;
}
}
else
{
// It's either a number, or a string
if (isdigit (curChar))
{
TokenType = ParseNumber();
}
else
{
if (ParseToken ())
TokenType = STRING;
else TokenType = BAD;
}
}
}
}
if ((TokenType != STRING) && (TokenType != NUMBER))
{
token = "";
token += curChar;
}
return TokenType;
}
int CVPParser::Parse(const char *str)
{
int i,iline = 0;
bool inProgram = false;
std::stringstream input(str);
struct nvfx_src none = nvfx_src(nvfx_reg(NVFXSR_NONE,0));
while(!input.eof()) {
char line[256];
opcode *opc = NULL;
struct nvfx_insn *insn = NULL;
input.getline(line,255);
iline++;
for(i=0; i<256; i++) {
char c = line[i];
if(c=='\n' || c=='\r' || c==';')
c = 0;
if(c=='\t')
c = ' ';
line[i] = c;
if(c==0) break;
}
if(line[0]=='#') {
ParseComment(line);
continue;
}
if(!inProgram) {
if(strncmp(line,"!!VP2.0",7)==0)
inProgram = true;
else if(strncmp(line,"!!ARBvp1.0",10)==0)
inProgram = true;
continue;
}
char *label = NULL;
char *col_ptr = NULL;
char *opcode = NULL;
char *ptr = line;
if((col_ptr = strstr((char*)ptr,":"))!=NULL) {
int j = 0;
bool valid = true;
while((ptr+j)<col_ptr) {
if(j==0 && !(isLetter(ptr[j]) || ptr[j]=='_')) valid = false;
if(!(isLetter(ptr[j]) || isDigit(ptr[j]) || ptr[j]=='_')) valid = false;
j++;
}
if(valid) {
label = strtok(ptr,":\x20");
ptr = col_ptr + 1;
}
}
opcode = strtok(ptr," ");
if(label) {
jmpdst d;
strcpy(d.ident,label);
d.location = m_nInstructions;
m_lIdent.push_back(d);
}
if(opcode) {
char *param_str = SkipSpaces(strtok(NULL,"\0"));
if(strcasecmp(opcode,"OPTION")==0) {
if(strncasecmp(param_str,"NV_vertex_program3",18)==0)
m_nOption |= NV_OPTION_VP3;
continue;
} else if(strcasecmp(opcode,"PARAM")==0)
continue;
else if(strcasecmp(opcode,"TEMP")==0)
continue;
else {
opc = FindOpcode(opcode);
insn = &m_pInstructions[m_nInstructions];
if(!opc) continue;
InitInstruction(insn,opc->opcode);
if(opc->opcode==OPCODE_END) {
m_nInstructions++;
break;
}
char *opc_ext = opcode + strlen(opc->mnemonic);
if(m_nOption&(NV_OPTION_VP2|NV_OPTION_VP3)) {
if(opc_ext[0]=='C') {
insn->cc_update = TRUE;
if(m_nOption&NV_OPTION_VP3 && (opc_ext[1]=='0' || opc_ext[1]=='1')) {
switch(opc_ext[1]) {
case '0':
insn->cc_update_reg = 0;
break;
case '1':
insn->cc_update_reg = 1;
break;
}
opc_ext++;
}
opc_ext++;
}
}
if(opc_ext[0]=='_') {
if(strncasecmp(opc_ext,"_sat",4)==0) insn->sat = TRUE;
}
ParseInstruction(insn,opc,param_str);
m_nInstructions++;
}
}
}
for(std::list<jmpdst>::iterator r=m_lJmpDst.begin(); r!=m_lJmpDst.end(); r++) {
bool found = false;
for(std::list<jmpdst>::iterator i=m_lIdent.begin(); i!=m_lIdent.end(); i++) {
if(strcmp(r->ident,i->ident)==0) {
found = true;
m_pInstructions[r->location].dst = nvfx_reg(NVFXSR_RELOCATED,i->location);
break;
}
}
if(found==false) {
fprintf(stderr,"Identifier \'%s\' not found.\n",r->ident);
exit(EXIT_FAILURE);
}
}
return 0;
}
int CFPParser::Parse(const char *str)
{
int i,iline = 0;
bool inProgram = false;
std::stringstream input(str);
while(!input.eof()) {
char line[256];
struct nvfx_insn *insn = NULL;
input.getline(line,255);
iline++;
for(i=0;i<256;i++) {
char c = line[i];
if(c=='\n' || c=='\r' || c==';')
c = 0;
if(c=='\t')
c = ' ';
line[i] = c;
if(c==0) break;
}
if(line[0]=='#') {
ParseComment(line);
continue;
}
if(!inProgram) {
if(strncmp(line,"!!FP2.0",7)==0)
inProgram = true;
else if(strncmp(line,"!!ARBfp1.0",10)==0)
inProgram = true;
continue;
}
char *label = NULL;
char *col_ptr = NULL;
char *opcode = NULL;
char *ptr = line;
if((col_ptr = strstr((char*)ptr,":"))!=NULL) {
int j = 0;
bool valid = true;
while((ptr+j)<col_ptr) {
if(j==0 && !(isLetter(ptr[j]) || ptr[j]=='_')) valid = false;
if(!(isLetter(ptr[j]) || isDigit(ptr[j]) || ptr[j]=='_')) valid = false;
j++;
}
if(valid) {
label = strtok(ptr,":\x20");
ptr = col_ptr + 1;
}
}
opcode = strtok(ptr," ");
if(opcode) {
char *param_str = SkipSpaces(strtok(NULL,"\0"));
if(strcasecmp(opcode,"OPTION")==0) {
if(strncasecmp(param_str,"NV_fragment_program2",20)==0)
m_nOption |= NV_OPTION_FP2;
continue;
} else if(strcasecmp(opcode,"PARAM")==0)
continue;
else if(strcasecmp(opcode,"TEMP")==0)
continue;
else if(strcasecmp(opcode,"OUTPUT")==0) {
ParseOutput(param_str);
continue;
} else {
struct _opcode opc = FindOpcode(opcode);
insn = &m_pInstructions[m_nInstructions];
if(opc.opcode>=MAX_OPCODE) continue;
InitInstruction(insn,opc.opcode);
if(opc.opcode==OPCODE_END) {
m_nInstructions++;
break;
}
ParseInstruction(insn,&opc,param_str);
m_nInstructions++;
}
}
}
return 0;
}
// Get a word token
bool SqlParser::GetWordToken(Token *token)
{
if(token == NULL)
return false;
int len = 0;
const char *cur = _next_start;
// Check for a sign for numbers in the first position (sign can go before variable name -num i.e)
if(_remain_size > 1 && (*cur == '+' || *cur == '-') /*&& cur[1] >= '0' && cur[1] <= '9'*/ &&
// Skip comment --
cur[1] != '-')
{
char sign = *cur;
_remain_size--;
len++;
cur++;
// Allow spaces follow the sign
while(sign == '-' && _remain_size > 1 && *cur == ' ')
{
_remain_size--;
len++;
cur++;
}
}
// Identifiers starts as a word but then there is quoted part SCHEMA."TABLE".COL i.e.
bool partially_quoted_identifier = false;
// Calculate the length
while(_remain_size > 0)
{
// Check for a comment
if(len == 0 && ParseComment() == true)
{
cur = _next_start;
continue;
}
// Check whether we meet a special character allowed in identifiers
if(strchr(g_symbols, *cur) != NULL)
{
// @variable in SQL Server and MySQL, :new in Oracle trigger, #temp table name in SQL Server
// * meaning all columns, - in COBOL identifier, label : label name in DB2
if(*cur != '_' && *cur != '.' && *cur != '@' && *cur != ':' && *cur != '#' && *cur != '*' &&
*cur != '-' && *cur != '"' && *cur != '[' && *cur != ' ' && *cur != '&')
break;
// Spaces are allowed between identifier parts: table . name
if(*cur == ' ')
{
int ident_len = 0;
for(int i = 0; i < _remain_size - 1; i++)
{
if(cur[i] == ' ' || cur[i] == '\t' || cur[i] == '\n' || cur[i] == '\r')
continue;
if(cur[i] == '.')
ident_len = i;
break;
}
// Not a multi-part identifier
if(len == 0 || ident_len == 0)
break;
_remain_size -= ident_len;
cur += ident_len;
len += ident_len;
continue;
}
// * must be after . to not confuse with multiplication operator
if(*cur == '*' && (len == 0 || (len > 0 && cur > _start && cur[-1] != '.')))
break;
// Check for partially quoted identifier that starts as a word then quoted part follows
if(*cur == '"' || *cur == '[')
{
if(len > 0 && cur > _start && cur[-1] == '.')
partially_quoted_identifier = true;
break;
}
if(*cur == ':')
{
// But := also means assigment in Oracle (space is not allowed between : and =)
if((_remain_size > 1 && cur[1] == '=') ||
// In DB2, Teradata, MySQL : used in label, and label:BEGIN (without spaces) or
// label :BEGIN is correct, but :param can be also used in scripts
(Source(SQL_DB2, SQL_TERADATA, SQL_MYSQL) == true &&
IsScope(SQL_SCOPE_SELECT_STMT) == false) ||
// In Informix, PostgreSQL :: is data type cast operator
(_remain_size > 1 && cur[1] == ':') || (cur > _start && cur[-1] == ':'))
break;
}
// : can follow after label in DB2
//if(*cur == ':' && len == 0 && _remain_size > 1 && Str::IsSpace(cur[1]) == true)
// break;
// & used as parameter marker in scripts i.e. SQL*Plus, must be at the first position
if(*cur == '&' && len != 0)
break;
// Allow - in COBOL only
if(*cur == '-' && _source_app != APP_COBOL && _level != LEVEL_APP)
break;
bool right = true;
// @ must not be followed by a blank or delimiter
if(*cur == '@')
{
// Remain size not decremented yet
if(_remain_size == 1 ||
(_remain_size > 1 && (cur[1] == ' ' || cur[1] == '\r' || cur[1] == '\n' || cur[1] == '\t')))
right = false;
}
else
// . is the statement delimiter in COBOL
if(_source_app == APP_COBOL && _level == LEVEL_APP && *cur == '.')
right = false;
if(right == false)
break;
}
_remain_size--;
cur++;
len++;
}
if(partially_quoted_identifier == true)
{
_remain_size += len;
GetQuotedIdentifier(token, true);
}
else
if(len > 0)
{
// If a single special character was selected in the right position, but no more characters followed
// do not return as word
if(len == 1 && (strchr(g_symbols, *_next_start) != NULL ||
// Also skip N'literal' in SQL Server
(*_next_start == 'N' && _remain_size > 1 && *cur == '\'')))
{
_remain_size++;
return false;
}
token->type = TOKEN_WORD;
token->chr = 0;
token->wchr = 0;
token->str = _next_start;
token->wstr = 0;
token->len = len;
token->remain_size = _remain_size;
token->next_start = _next_start + len;
_tokens.Add(token);
_next_start = cur;
}
return (len > 0) ? true : false;
}
void DwRfc1521Tokenizer::ParseToken()
{
// Assume the field body has already been extracted. That is, we don't
// have to watch for the end of the field body or folding. We just
// treat any CRs or LFs as white space.
mTokenStart = mNextStart;
mTokenLength = 0;
mTkType = eTkNull;
// Skip leading space. Also, since control chars are not permitted
// in atoms, skip these, too.
while(1)
{
if(mTokenStart >= mString.length())
{
return;
}
if(isnotspaceorcntrl(mString[mTokenStart]))
break;
++mTokenStart;
}
char ch = mString[mTokenStart];
switch(ch)
{
// Quoted string
case '"':
mTkType = eTkQuotedString;
ParseQuotedString();
break;
// Comment
case '(':
mTkType = eTkComment;
ParseComment();
break;
// Domain literal
case '[':
mTkType = eTkDomainLiteral;
ParseDomainLiteral();
break;
// Special
case ')':
case '<':
case '>':
case '@':
case ',':
case ';':
case ':':
case '\\':
case '/':
case ']':
case '?':
case '=':
mTkType = eTkTspecial;
mTokenLength = 1;
mToken = mString.substr(mTokenStart, 1);
mNextStart = mTokenStart + 1;
break;
default:
mTkType = eTkToken;
ParseAtom();
break;
}
if(mDebugOut) PrintToken(mDebugOut);
}
bool Parser::GetToken(token& out)
{
// trim leading whitespace first:
for (; text.str < text.end; ++text.str)
{
char ch = *text.str;
if (ch == ' ' || ch == '\t') continue;
if (ch == '\r' || ch == '\n') SkipNewLine(ch);
else break; // not ' ' or '\t', so finish trim
}
out.end = out.str = text.str; // mark down start and default end
column = GetColumn();
for ( ; text.str < text.end; ++text.str)
{
char ch = *text.str;
if (ch == '\r' || ch == '\n') {
SkipNewLine(ch);
continue;
}
if (ch == '/') { // possible comment start?
char c2 = text.str[1];
if (c2 == '/' || c2 == '*') // line comment '//' or block comment '/*'
return ParseComment(out, c2 == '*'); // parse the comment
}
else if (ch == '"')
return ParseStringLiteral(out); // skip the literal
else if (ch == '\'')
return ParseCharLiteral(out);
if (BreakerIndex[ch] == 1) // token starts with a breaker char
{
line = cur_line;
column = GetColumn();
char c2 = *++text.str;
char c3 = text.str[1];
if (c3 == '=' && (
(ch == '<' && c2 == '<')|| // <<=
(ch == '>' && c2 == '>'))) // >>=
{
text.str += 2; // 3 char token parsed
}
else if ((c2 == '=' && (
ch == '<' || // <=
ch == '>' || // >=
ch == '=' || // ==
ch == '!' || // !=
ch == '+' || // +=
ch == '-' || // -=
ch == '*' || // *=
ch == '/' || // /=
ch == '%' || // %=
ch == '&' || // &=
ch == '|' || // |=
ch == '^' // ^=
)) ||
(ch == '+' && c2 == '+') || // ++
(ch == '-' && c2 == '-') || // --
(ch == '-' && c2 == '>') || // ->
(ch == '?' && c2 == '?') || // ??
(ch == '&' && c2 == '&') || // &&
(ch == '|' && c2 == '|') || // ||
(ch == '<' && c2 == '<') || // <<
(ch == '>' && c2 == '>') || // >>
(ch == ':' && c2 == ':')) // ::
{
++text.str; // 2 char token parsed
}
out.end = text.str;
return true; // 1 char token parsed
}
// so this is a literal or a statement?
return ParseStatement(out);
}
return false; // end of buffer
}
void CASEFile::Parse()
{
if (m_file == NULL)
{
return;
}
CAlertErrHandler errhandler;
CTokenizer* tokenizer = CTokenizer::Create(TKF_USES_EOL | TKF_NUMERICIDENTIFIERSTART);
tokenizer->SetErrHandler(&errhandler);
tokenizer->SetKeywords(s_keywords);
tokenizer->SetSymbols(s_symbols);
tokenizer->AddParseFile(m_file, 16 * 1024);
int tokType = TK_UNDEFINED;
while(tokType != TK_EOF)
{
CToken* curToken = tokenizer->GetToken();
if (curToken->GetType() == TK_EOF)
{
curToken->Delete();
tokType = TK_EOF;
break;
}
if (curToken->GetType() == TK_EOL)
{
curToken->Delete();
continue;
}
if (curToken->GetType() != TK_ASE_ASTERISK)
{
tokenizer->Error(TKERR_UNEXPECTED_TOKEN);
curToken->Delete();
tokenizer->GetToEndOfLine()->Delete();
continue;
}
curToken->Delete();
curToken = tokenizer->GetToken();
tokType = curToken->GetType();
curToken->Delete();
switch(tokType)
{
case TK_EOF:
break;
case TK_GEOMOBJECT:
ParseGeomObject(tokenizer);
break;
case TK_SCENE:
ParseScene(tokenizer);
break;
case TK_MATERIAL_LIST:
ParseMaterialList(tokenizer);
break;
case TK_ASE_COMMENT:
ParseComment(tokenizer);
break;
case TK_3DSMAX_ASCIIEXPORT:
ParseAsciiExport(tokenizer);
break;
default:
tokenizer->Error(TKERR_UNEXPECTED_TOKEN);
tokenizer->GetToEndOfLine()->Delete();
break;
}
}
}
