void RawParser::ParseInfoToken(const char *&pcs, int &iLen, bool *pbMoreFollows)
{
if (!FindNextToken()) {
if (pbMoreFollows) *pbMoreFollows = false;
return;
}
pcs = (const char *)pbPos;
if (*pcs == '"') pcs++;
ParseToken(sz, pbMoreFollows);
iLen = int(strlen(sz));
}
/**
* @brief Parses an incoming SVC_PRINT message.
*/
static void Cl_ParsePrint(void) {
const byte level = Net_ReadByte(&net_message);
const char *string = Net_ReadString(&net_message);
// the server shouldn't have sent us anything below our level anyway
if (level >= message_level->integer) {
// check to see if we should ignore the message
if (*cl_ignore->string) {
char patterns[MAX_STRING_CHARS];
g_strlcpy(patterns, cl_ignore->string, sizeof(patterns));
const char *p = patterns;
while (true) {
const char *pattern = ParseToken(&p);
if (pattern == NULL) {
break;
}
if (GlobMatch(pattern, string)) {
return;
}
}
}
char *sample = NULL;
switch (level) {
case PRINT_CHAT:
case PRINT_TEAM_CHAT:
if (level == PRINT_CHAT && *cl_chat_sound->string) {
sample = cl_chat_sound->string;
} else if (level == PRINT_TEAM_CHAT && *cl_team_chat_sound->string) {
sample = cl_team_chat_sound->string;
}
break;
default:
break;
}
if (sample) {
S_AddSample(&(const s_play_sample_t) {
.sample = S_LoadSample(sample)
});
}
Con_Append(level, string);
}
// Initialize net service list
void InitNetSvcList(CEDAR *cedar)
{
char filename[MAX_PATH] = "/etc/services";
BUF *b;
// Validate arguments
if (cedar == NULL)
{
return;
}
#ifdef OS_WIN32
Format(filename, sizeof(filename), "%s\\drivers\\etc\\services", MsGetSystem32Dir());
#endif
cedar->NetSvcList = NewList(CompareNetSvc);
b = ReadDump(filename);
if (b == NULL)
{
return;
}
while (true)
{
char *s = CfgReadNextLine(b);
if (s == NULL)
{
break;
}
Trim(s);
if (s[0] != '#')
{
TOKEN_LIST *t = ParseToken(s, " \t/");
if (t->NumTokens >= 3)
{
NETSVC *n = ZeroMalloc(sizeof(NETSVC));
n->Name = CopyStr(t->Token[0]);
n->Udp = (StrCmpi(t->Token[2], "udp") == 0 ? true : false);
n->Port = ToInt(t->Token[1]);
Add(cedar->NetSvcList, n);
}
FreeToken(t);
}
Free(s);
}
FreeBuf(b);
}
eTokenType asCTokenizer::GetToken(const char *source, size_t sourceLength, size_t *tokenLength)
{
assert(source != 0);
assert(tokenLength != 0);
this->source = source;
this->sourceLength = sourceLength;
ParseToken();
// Copy the output to the token
*tokenLength = this->tokenLength;
return tokenType;
}
int Anasin::ListidP(){
Lexema nextLexema = this->_symTab->lookAheadLexema();
if(nextLexema._tipo == "Punctuation" && nextLexema._valor == ","){
//12) ListidP -> , Listid
if(!ParseToken(Lexema("Punctuation",","),true)) return 0;
if(!Listid()) return 0;
}else if(nextLexema._tipo == "Reserved" && nextLexema._valor == "nil"){
//13) ListidP -> €
// No hago nada
}else{
std::cout << "Error sintáctico, se esperaba : Punctuation, nil y se obtuvo: " << nextLexema._tipo << " ("<< nextLexema._valor <<")["<< this->_symTab->getOffset() <<"]" << std::endl;
return 0;
}
return 1;
}
Value* JSONReader::JsonToValue(const std::string& json, bool check_root,
bool allow_trailing_comma)
{
// 输入必须是UTF-8编码.
if(!IsStringUTF8(json.c_str()))
{
error_code_ = JSON_UNSUPPORTED_ENCODING;
return NULL;
}
// 从UTF8到wstring的转换会移除空字节(好事).
std::wstring json_wide(UTF8ToWide(json));
start_pos_ = json_wide.c_str();
// 当输入的JSON字符串开头有UTF-8的Byte-Order-Mark(0xEF, 0xBB, 0xBF),
// UTF8ToWide()函数会把它转换成BOM(U+FEFF). 为防止JSONReader::BuildValue()
// 函数把它当成非法字符而返回NULL, 如果存在Unicode的BOM则先跳过.
if(!json_wide.empty() && start_pos_[0]==0xFEFF)
{
++start_pos_;
}
json_pos_ = start_pos_;
allow_trailing_comma_ = allow_trailing_comma;
stack_depth_ = 0;
error_code_ = JSON_NO_ERROR;
scoped_ptr<Value> root(BuildValue(check_root));
if(root.get())
{
if(ParseToken().type == Token::END_OF_INPUT)
{
return root.release();
}
else
{
SetErrorCode(JSON_UNEXPECTED_DATA_AFTER_ROOT, json_pos_);
}
}
// "语法错误".
if(error_code_ == 0)
{
SetErrorCode(JSON_SYNTAX_ERROR, json_pos_);
}
return NULL;
}
eTokenType asCTokenizer::GetToken(const char *source, size_t sourceLength, size_t *tokenLength, asETokenClass *tc)
{
asASSERT(source != 0);
asASSERT(tokenLength != 0);
this->source = source;
this->sourceLength = sourceLength;
asETokenClass t = ParseToken();
if( tc ) *tc = t;
// Copy the output to the token
*tokenLength = this->tokenLength;
return tokenType;
}
static int
ParseExtendedTX(void)
{
int style = TX_ORIGINAL;
if (ParseToken(PARSE_COMMENT)) {
if (!strncmp(token, "//TX", 4)) {
if (token[4] == '1')
style = TX_QUARK_TYPE1;
else if (token[4] == '2')
style = TX_QUARK_TYPE2;
}
}
return style;
}
static texcoord_style_t
ParseExtendedTX(parser_t *parser)
{
texcoord_style_t style = TX_ORIGINAL;
if (ParseToken(parser, PARSE_COMMENT)) {
if (!strncmp(parser->token, "//TX", 4)) {
if (parser->token[4] == '1')
style = TX_QUARK_TYPE1;
else if (parser->token[4] == '2')
style = TX_QUARK_TYPE2;
}
}
return style;
}
void CommandLineMode(int argc, char *argv[], void *htmsocket) {
char *messageName;
char *token;
typedArg args[MAX_ARGS];
int i,j, numArgs;
OSCbuf buf[1];
OSC_initBuffer(buf, SC_BUFFER_SIZE, bufferForOSCbuf);
if (argc > 1) {
if (OSC_openBundle(buf, OSCTT_Immediately())) {
complain("Problem opening bundle: %s\n", OSC_errorMessage);
return;
}
}
for (i = 0; i < argc; i++) {
messageName = strtok(argv[i], ",");
if (messageName == NULL) {
break;
}
j = 0;
while ((token = strtok(NULL, ",")) != NULL) {
args[j] = ParseToken(token);
j++;
if (j >= MAX_ARGS) {
complain("Sorry; your message has more than MAX_ARGS (%d) arguments; ignoring the rest.\n",
MAX_ARGS);
break;
}
}
numArgs = j;
WriteMessage(buf, messageName, numArgs, args);
}
if (argc > 1) {
if (OSC_closeBundle(buf)) {
complain("Problem closing bundle: %s\n", OSC_errorMessage);
return;
}
}
SendBuffer(htmsocket, buf);
}
int Anasin::Operador(){
Lexema nextLexema = this->_symTab->lookAheadLexema();
if(nextLexema._tipo == "Arithmetic"){
// 27) Operador -> arithmetic Expresion
if(!ParseToken(Lexema("Arithmetic",""),false)) return 0;
if(!Expresion()) return 0;
}else if(nextLexema._tipo == "Relational" ||
(nextLexema._tipo == "Agrupation" && nextLexema._valor == ")") ||
(nextLexema._tipo == "Punctuation" && nextLexema._valor == ";")){
// 28) Operador -> €
// No hago nada
}else{
std::cout << "Error sintáctico, se esperaba : Arithmetic, Relational, ) o ; y se obtuvo: " << nextLexema._tipo << " ("<< nextLexema._valor <<")["<< this->_symTab->getOffset() <<"]" << std::endl;
return 0;
}
return 1;
}
int DoInclude(ParsePtr p)
{
DynamicBuffer buf;
int r, e;
DBufInit(&buf);
if ( (r=ParseToken(p, &buf)) ) return r;
e = VerifyEoln(p);
if (e) Eprint("%s", ErrMsg[e]);
if ( (r=IncludeFile(DBufValue(&buf))) ) {
DBufFree(&buf);
return r;
}
DBufFree(&buf);
NumIfs = 0;
IfFlags = 0;
return OK;
}
bool CXMLElement::ParseRootTag (IMemoryBlock &Stream, CString *retsTag)
// ParseRootTag
//
// This function parses only enough to determine the root tag, either by reading
// as far as the first open tag or by getting the DOCTYPE.
//
// This function is a hack to allow Transcendence to read the root tag for an
// extension without loading the whole file.
{
// Initialize context
ParserCtx Ctx(Stream, NULL);
Ctx.m_bParseRootTag = true;
// Parse the prologue
if (!ParsePrologue(&Ctx))
return false;
if (!Ctx.m_sRootTag.IsEmpty())
{
*retsTag = Ctx.m_sRootTag;
return true;
}
// Next token must be an element open tag
if (Ctx.iToken != tkTagOpen)
return false;
// Parse the root element name
if (ParseToken(&Ctx) != tkText)
return false;
*retsTag = Ctx.sToken;
// Done
return true;
}
int CCloseCaptionPhrase::CountTokens( void ) const
{
int count = 0;
wchar_t token[ 1024 ];
wchar_t const *in = GetStream();
while ( in )
{
in = ParseToken( in, token, sizeof( token ) );
if ( wcslen( token ) > 0 )
{
count++;
}
if ( !in || *in == L'\0' )
break;
}
return count;
}
bool Scanner::GetToken(Token *token)
{
if ((token == NULL))
{
return false;
}
Skip();
if (ParseDigit(token))
return true;
if (ParseToken(token))
return true;
if (ParseOperator(token))
return true;
return false;
}
bool RawParser::ParseParams(PCTCHAR pcszDefaultFile)
{
if (!ParseToken(sz)) return false;
if (_strcmpi(sz, "RawImage") != 0) return false;
for (int n = 0; n < 4; n++) {
_tcscpy(Comps[n].szFile, pcszDefaultFile);
Comps[n].nStart = 0;
Comps[n].nDelta = -1;
}
ParseMainBlock();
for (int n = 0; n < 4; n++) {
if (Comps[n].nDelta < 0)
Comps[n].nDelta = cbComp;
}
return true;
}
static inline
int ParseFile(char* Filename, GLArbToken* ArbHash,
GLToken* FunctionsHash, unsigned int* FunctionCount,
GLToken* DefinesHash, unsigned int* DefinesCount,
GLSettings* Settings)
{
char* Data = ReadEntireFile(Filename);
int Success = 0;
if (Data)
{
GLTokenizer Tokenizer;
Tokenizer.At = Data;
while(*Tokenizer.At)
{
GLToken Token = ParseToken(&Tokenizer);
if (StartsWith(Token.Value, "gl") && IsUpperCase(Token.Value.Chars[2]))
{
if (!Contains(FunctionsHash, Token) && IsKnownOrIgnoredToken(ArbHash, &Token, Settings))
{
AddToken(FunctionsHash, Token);
*FunctionCount += 1;
}
}
if (StartsWith(Token.Value, "GL_"))
{
if (!Contains(DefinesHash, Token) && IsKnownOrIgnoredToken(ArbHash, &Token, Settings))
{
AddToken(DefinesHash, Token);
*DefinesCount += 1;
}
}
}
free(Data);
Success = 1;
}
else
{
fprintf(stderr, "Couldn't open file %s", Filename);
}
return Success;
}
//
// parses format and (via UpdateAttr and convert) outputs data
void ydpDictionary::ParseRTF(void) {
char *def = curDefinition;
int level=0, attr=0, attrs[16], phon;
newline_=0; newattr=0; newphon=0;
textlen=0;
outputView->SetText("");
while(*def) {
switch(*def) {
case '{':
if (level<16) attrs[level++] = attr;
break;
case '\\':
def = ParseToken(def);
UpdateAttr(attr);
attr = newattr;
break;
case '}':
newattr = attrs[--level];
UpdateAttr(attr);
break;
default:
line += *def;
break;
}
def++;
if (newline_) {
if (newattr & A_MARGIN) {
line.Prepend("\t\t",2);
}
line.Append("\n",1);
UpdateAttr(attr);
newline_ = 0;
}
attr = newattr;
phon = newphon;
}
UpdateAttr(attr);
}
// returns pointer to array of pointers to null terminated strings
// (like argc, argv from main), quoted arguments have quotes stripped.
// this function is destructive in that it will write null's and remove
// quotes from the string.
//
// the caller must use HeapFree to free the returned pointer.
//
LPCTSTR * TokenizeString (
LPCTSTR pszInput,
LPUINT pcArgs)
{
*pcArgs = 0;
if ( ! pszInput)
return NULL;
UINT cch = lstrlen (pszInput);
if ( ! cch)
return NULL;
UINT cbAlloc = ((cch + 1) * sizeof(char*) + cch * sizeof(TCHAR) * 2);
LPCTSTR * pArgv = (LPCTSTR *)HeapAlloc(GetProcessHeap(), 0, cbAlloc);
if ( ! pArgv)
return NULL;
LPTSTR pszToken = (LPTSTR)(&pArgv[cch + 1]);
UINT cArgs = 0;
CopyMemory(pszToken, pszInput, (cch+1) * sizeof(TCHAR));
pszToken = _SkipWhiteSpace (pszToken);
while (0 != pszToken[0])
{
LPTSTR psz = ParseToken(pszToken);
pArgv[cArgs++] = pszToken;
pszToken = _SkipWhiteSpace (psz);
}
*pcArgs = cArgs;
pArgv[cArgs] = NULL;
if ( ! cArgs)
{
HeapFree(GetProcessHeap(), 0, pArgv);
pArgv = NULL;
}
return pArgv;
}
void ParseMoves(POS *p, char *ptr) {
char token[180];
UNDO u[1];
for (;;) {
// Get next move to parse
ptr = ParseToken(ptr, token);
// No more moves!
if (*token == '\0') break;
p->DoMove(StrToMove(p, token), u);
// We won't be taking back moves beyond this point:
if (p->rev_moves == 0) p->head = 0;
}
}
int Anasin::BloqueE(){
Lexema nextLexema = this->_symTab->lookAheadLexema();
if(nextLexema._tipo == "Reserved" && nextLexema._valor == "else"){
// 15) BloqueE -> else BloqueS
if(!ParseToken(Lexema("Reserved","else"),true)) return 0;
if(!BloqueS()) return 0;
}else if(nextLexema._tipo == "id" ||
nextLexema._tipo == "Output" ||
(nextLexema._tipo == "Agrupation" && nextLexema._valor == "}") ||
(nextLexema._tipo == "Reserved" && nextLexema._valor == "while") ||
(nextLexema._tipo == "Reserved" && nextLexema._valor == "if") ||
(nextLexema._tipo == "Reserved" && nextLexema._valor == "arr") ||
(nextLexema._tipo == "Reserved" && nextLexema._valor == "count")||
nextLexema._tipo == "$"){
// 16) BloqueE -> €
// No hago nada
}else{
std::cout << "Error sintáctico, se esperaba : else, id, }, output, while, if, arr, count y se obtuvo: " << nextLexema._tipo << " ("<< nextLexema._valor <<")["<< this->_symTab->getOffset() <<"]" << std::endl;
return 0;
}
return 1;
}
void CEnvEffectsScript::LoadFromBuffer( const char *scriptfile, const char *buffer )
{
while ( 1 )
{
ParseToken();
if ( !token[0] )
{
break;
}
if ( !Q_stricmp( token, "effect" ) )
{
ParseNewEffect();
}
else
{
Warning( "CEnvEffectsScript: Unknown entry type '%s'\n", token );
break;
}
}
}
wchar_t const *CCloseCaptionPhrase::GetToken( int token_number ) const
{
int count = 0;
static wchar_t token[ 1024 ];
wchar_t const *in = GetStream();
token[ 0 ] = L'\0';
while ( in )
{
in = ParseToken( in, token, sizeof( token ) );
if ( wcslen( token ) > 0 )
{
if ( count == token_number )
break;
count++;
}
if ( !in || *in == L'\0' )
break;
}
return token;
}
asCScriptNode *asCParser::ParseTypeMod(bool isParam)
{
asCScriptNode *node = new asCScriptNode(snDataType);
sToken t;
// Parse possibly byref token
GetToken(&t);
RewindTo(&t);
if( t.type == ttAmp )
{
node->AddChildLast(ParseToken(ttAmp));
if( isSyntaxError ) return node;
if( isParam )
{
int tokens[3] = {ttIn, ttOut, ttInOut};
node->AddChildLast(ParseOneOf(tokens, 3));
}
}
return node;
}
/* Scans the next token and checks that it is the one that's expected */
static int MatchToken( ParseContext* ctx, ConfigToken token )
{
ConfigToken parsed_token;
parsed_token = ParseToken( ctx );
if( parsed_token != token )
{
if( parsed_token != Token_Unknown )
{
sprintf( error_buffer, "%s: unexpected configuration token: found: '%s', expected: '%s'",
ERROR_PREFIX, TokenToString( parsed_token ), TokenToString( token ) );
}
else
{
sprintf( error_buffer, "%s: unknown configuration token: '%s', expected: '%s'",
ERROR_PREFIX, ctx->token, TokenToString( token ) );
}
return CONFIG_PARSE_ERROR;
}
return 0;
}
int Anasin::EControl(){
Lexema nextLexema = this->_symTab->lookAheadLexema();
if(nextLexema._tipo == "Reserved" && nextLexema._valor == "while"){
// 06) EControl -> while(Condicion)BloqueS
if(!ParseToken(Lexema("Reserved","while"),true)) return 0;
if(!ParseToken(Lexema("Agrupation","("),true)) return 0;
if(!Condicion()) return 0;
if(!ParseToken(Lexema("Agrupation",")"),true)) return 0;
if(!BloqueS()) return 0;
}else if(nextLexema._tipo == "Reserved" && nextLexema._valor == "if"){
// 07) EControl -> if(Condicion)BloqueS BloqueE
if(!ParseToken(Lexema("Reserved","if"),true)) return 0;
if(!ParseToken(Lexema("Agrupation","("),true)) return 0;
if(!Condicion()) return 0;
if(!ParseToken(Lexema("Agrupation",")"),true)) return 0;
if(!BloqueS()) return 0;
if(!BloqueE()) return 0;
}else{
std::cout << "Error sintáctico, se esperaba : while, if y se obtuvo: " << nextLexema._tipo << " ("<< nextLexema._valor <<")["<< this->_symTab->getOffset() <<"]" << std::endl;
return 0;
}
return 1;
}
// Check whether the specified string is a number
bool IsNum(char *str)
{
char c;
UINT i, len;
UINT n = 0;
char tmp[MAX_SIZE];
TOKEN_LIST *t;
// Validate arguments
if (str == NULL)
{
return false;
}
StrCpy(tmp, sizeof(tmp), str);
Trim(tmp);
if (StrLen(tmp) == 0)
{
return false;
}
t = ParseToken(tmp, " ");
if (t->NumTokens >= 1)
{
StrCpy(tmp, sizeof(tmp), t->Token[0]);
}
FreeToken(t);
len = StrLen(tmp);
for (i = 0;i < len;i++)
{
bool b = false;
c = tmp[i];
if (('0' <= c && c <= '9') || (c == '+') || (c == '-') || (c == ','))
{
b = true;
}
if (b == false)
{
return false;
}
}
for (i = 0;i < len;i++)
{
c = tmp[i];
if (c == '-')
{
n++;
}
}
if (n >= 2)
{
return false;
}
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//
// Command - Process text command
//
// Inputs: Line command to process
//
// Outputs: None.
//
void Command(char *Buffer) {
ParseInit(Buffer);
char *Command = ParseToken();
#ifdef USE_MAIN_SCREEN
//
// MA - Show the main screen
//
if( StrEQ(Command,"MA") ) {
ShowScreen('MA');
return;
}
#ifdef USE_MAIN_SCREEN_CMDS
//
// See if the local screen can manage the command
//
if( SelectedScreen == 'MA' ) {
if( MAScreenCommand(Command) )
return;
}
//
// Universally accept <ESC> as an escape to the main screen.
//
if( StrEQ(Command,ESC_CMD) ) {
ShowScreen('MA');
return;
}
#endif
#endif
//////////////////////////////////////////////////////////////////////////////////////////
#ifdef USE_HELP_SCREEN
//
// HE - Help screen
//
if( StrEQ(Command,"HE") ||
StrEQ(Command,"?" ) ) {
ShowScreen('HE');
return;
}
#ifdef USE_HELP_SCREEN_CMDS
//
// See if the local screen can manage the command
//
if( SelectedScreen == 'HE' ) {
if( HEScreenCommand(Command) )
return;
}
#endif
#endif
//////////////////////////////////////////////////////////////////////////////////////////
#ifdef USE_DEBUG_SCREEN
//
// DE - Show the debug screen
//
if( StrEQ(Command,"DE") ) {
ShowScreen('DE');
return;
}
#ifdef USE_DEBUG_SCREEN_CMDS
//
// See if the local screen can manage the command
//
if( SelectedScreen == 'DE' ) {
if( DEScreenCommand(Command) )
return;
}
#endif
#endif
//////////////////////////////////////////////////////////////////////////////////////////
#ifdef USE_MEMORY_SCREEN
//
// ME - Show the memory screen
//
if( StrEQ(Command,"ME") ) {
ShowScreen('ME');
return;
}
#ifdef USE_MEMORY_SCREEN_CMDS
//
// See if the local screen can manage the command
//
if( SelectedScreen == 'ME' ) {
if( MEScreenCommand(Command) )
return;
}
#endif
#endif
#ifdef USE_EEPROM_SCREEN
//
// EE - Show the memory screen
//
if( StrEQ(Command,"EE") ) {
ShowScreen('EE');
return;
}
#ifdef USE_EEPROM_SCREEN_CMDS
//
// See if the local screen can manage the command
//
if( SelectedScreen == 'EE' ) {
if( EEScreenCommand(Command) )
return;
}
#endif
#endif
//
// Not a recognized command. Let the user know he goofed.
//
CursorPos(1,ERROR_ROW);
ClearEOL;
PrintString("Unrecognized command (");
PrintString(Command);
PrintString(")\r\n");
PrintStringP(PSTR(BEEP));
}
RTFStatus RTFReader::Parse(void)
{
RTFStatus t_status;
t_status = kRTFStatusSuccess;
while(t_status == kRTFStatusSuccess)
{
RTFToken t_token;
int4 t_value;
if (m_input_skip_count > 0)
{
while(m_input_skip_count > 0)
{
t_status = ParseToken(t_token, t_value);
if (t_status != kRTFStatusSuccess)
break;
if (t_token == kRTFTokenEnd || t_token == kRTFTokenBeginGroup || t_token == kRTFTokenEndGroup)
{
m_input_skip_count = 0;
break;
}
if ((t_token & kRTFTokenMask) == kRTFTokenBin)
m_input += t_value;
m_input_skip_count -= 1;
}
}
if (t_status == kRTFStatusSuccess)
t_status = ParseToken(t_token, t_value);
if (t_status != kRTFStatusSuccess)
break;
if (t_token == kRTFTokenEnd)
break;
if (t_token == kRTFTokenBeginGroup)
t_status = m_state . Save();
else if (t_token == kRTFTokenEndGroup)
{
// Take into account implementation of 'destinations'.
bool t_was_list;
t_was_list = m_state . GetDestination() == kRTFDestinationLegacyList;
bool t_was_list_text;
t_was_list_text = m_state . GetDestination() == kRTFDestinationListText;
bool t_was_field;
t_was_field = m_state . GetDestination() == kRTFDestinationFldInst;
// MW-2014-01-08: [[ Bug 11627 ]] If the paragraph attributes have changed then
// force a flush so that a new paragraph with said attributes is created. [ This
// isn't 100% correct from my reading of the RTF Spec - really paragraph attrs
// should be set on the current paragraph as the paragraph is parsed, rather than
// before the first text is emitted - however due to the way LiveCode and Word Processors
// generate RTF, this at least makes things roundtrip ].
if (m_state . HasParagraphChanged())
Flush(true);
t_status = m_state . Restore();
if (t_was_list)
{
m_state . SetListStyle(m_list_style);
m_state . SetListLevel(m_list_level);
}
else if (t_was_list_text)
{
if (m_list_skip)
m_state . SetListStyle(kMCTextListStyleSkip);
}
else if (t_was_field && m_state . GetDestination() != kRTFDestinationFldInst)
{
ProcessField();
}
m_attributes_changed = true;
}
else if ((t_token & kRTFTokenMask) == kRTFTokenBin)
{
m_input_binary_count = t_value;
m_input_state = kRTFInputStateBinary;
}
else switch(m_state . GetDestination())
{
case kRTFDestinationSkip:
// If the skipped destination is in fact the 'list' destination then
// handle it. We ignore 'pn' destinations if we have a listtable though.
if (t_token == kRTFTokenLegacyList && m_lists . Count() == 0)
{
m_list_style = kMCTextListStyleNone;
m_list_level = 0;
m_state . SetDestination(kRTFDestinationLegacyList);
}
else if (t_token == kRTFTokenListTable)
m_state . SetDestination(kRTFDestinationListTable);
else if (t_token == kRTFTokenListOverrideTable)
m_state . SetDestination(kRTFDestinationListOverrideTable);
else if (t_token == kRTFTokenFldInst)
m_state . SetDestination(kRTFDestinationFldInst);
break;
case kRTFDestinationNormal:
t_status = ParseDocument(t_token, t_value);
break;
case kRTFDestinationFontTable:
t_status = ParseFontTable(t_token, t_value);
break;
case kRTFDestinationColorTable:
t_status = ParseColorTable(t_token, t_value);
break;
case kRTFDestinationLegacyList:
t_status = ParseLegacyList(t_token, t_value);
break;
case kRTFDestinationLegacyListPrefix:
t_status = ParseLegacyListPrefix(t_token, t_value);
break;
case kRTFDestinationListTable:
t_status = ParseListTable(t_token, t_value);
break;
case kRTFDestinationListTableLevelText:
t_status = ParseListTableLevelText(t_token, t_value);
break;
case kRTFDestinationListOverrideTable:
t_status = ParseListOverrideTable(t_token, t_value);
break;
case kRTFDestinationListText:
t_status = ParseListText(t_token, t_value);
break;
case kRTFDestinationField:
break;
case kRTFDestinationFldInst:
t_status = ParseFldInst(t_token, t_value);
break;
}
}
return t_status;
}
// Read the inf file from the buffer
bool ViLoadInfFromBuf(VI_SETTING *set, BUF *buf)
{
bool ret;
if (set == NULL || buf == NULL)
{
return false;
}
Zero(set, sizeof(VI_SETTING));
SeekBuf(buf, 0, 0);
while (true)
{
char *tmp = CfgReadNextLine(buf);
TOKEN_LIST *tokens;
if (tmp == NULL)
{
break;
}
tokens = ParseToken(tmp, " \t");
if (tokens != NULL)
{
if (tokens->NumTokens >= 2)
{
if (StartWith(tokens->Token[0], "#") == false
|| StartWith(tokens->Token[0], "//") == false)
{
char *name, *value;
name = tokens->Token[0];
value = tokens->Token[1];
if (StrCmpi(name, "VpnInstallBuild") == 0)
{
set->VpnInstallBuild = ToInt(value);
}
else if (StrCmpi(name, "NormalMode") == 0)
{
set->NormalMode = ToBool(value);
}
else if (StrCmpi(name, "VpnSettingPath") == 0)
{
StrCpy(set->SettingPath, sizeof(set->SettingPath), value);
}
else if (StrCmpi(name, "VpnClientBuild") == 0)
{
set->x86.Build = ToInt(value);
}
else if (StrCmpi(name, "VpnClientPath") == 0)
{
StrCpy(set->x86.Path, sizeof(set->x86.Path), value);
}
}
}
FreeToken(tokens);
}
Free(tmp);
}
ret = false;
StrCpy(set->x86.VpnCMgrExeFileName, sizeof(set->x86.VpnCMgrExeFileName), (MsIsX64() ? "vpncmgr_x64.exe" : "vpncmgr.exe"));
if (set->VpnInstallBuild != 0)
{
if (set->x86.Build != 0 && IsEmptyStr(set->x86.Path) == false)
{
set->x86.Supported = true;
ret = true;
}
}
return ret;
}
