void ParserThread::ParseUsing()
{
ConsumeToken();
Token * peek = PeekToken();
if(peek->type_id() == TKN_NAMESPACE)
{
//Handleing using space directive
ConsumeToken(); //consume "namespace"
// simply handling mode: using namespace AAA
peek = PeekToken();
if (peek->type_id() == TKN_IDENTIFIER)
{
ParseFullIdentifer();
DoAddToken(tkUsingNamespace,*peek);
}
else
SkipStatementBlock();
}
else if(peek->type_id() == TKN_IDENTIFIER)
{
SkipStatementBlock();
}
}
void
nsXFormsXPathParser::NodeType()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::COMMENT:
PopToken();
PopToken();
PopToken();
break;
case nsXFormsXPathScanner::TEXT:
PopToken();
PopToken();
PopToken();
break;
case nsXFormsXPathScanner::PI:
PopToken();
if ((t = PeekToken()) == nsXFormsXPathScanner::LPARAN) {
PopToken();
PopToken();
PopToken();
}
break;
case nsXFormsXPathScanner::NODE:
PopToken();
PopToken();
PopToken();
break;
default:
XPathCompilerException("Not a valid NodeType", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
bool ParserThread::ParseScopeQueue(ScopeQueue& scopeQueue)
{
Token * currentToken = ConsumeToken();
assert(currentToken->type_id() == TKN_IDENTIFIER);
ScopeBlock scope;
scope.name = *currentToken;// add the name
ParseArgumentList(scope.templateArgumentList);
scopeQueue.push_back(scope);
while(PeekToken()->type_id()==TKN_DOUBLE_COLON && PeekToken(2)->type_id()==TKN_IDENTIFIER)
{
//scope.name.Clear(); should reset the Token
scope.templateArgumentList.clear();
//Read the Argument list
// fill the *it.templateArgumentList
// if the fill function return false, which, we should skip to ; or }
ConsumeToken(); //consume ::
currentToken = ConsumeToken(); // get id
scope.name = *currentToken;// add the name
bool parseResult = ParseArgumentList(scope.templateArgumentList);
if (!parseResult) // this means we have the format A<......;, this is not a template
{
m_Context.EndStatement();
return false;
}
scopeQueue.push_back(scope);
}
return true;
}
void ParserThread::HandleNamespace()
{
ConsumeToken();
Token *pk = PeekToken();
Token name;
if(pk->type_id()==TKN_IDENTIFIER)
{
name = *pk;
ConsumeToken();
}
else
{
//un-named namespace
}
pk = PeekToken();
if(pk->type_id()==TKN_L_BRACE)
{
ConsumeToken();
Symbol * sym = DoAddToken(tkNamespace,name);
PushContext();
m_Context.parentToken = sym;
DoParse();
PopContext();
TRACE("end of namespace\n");
}
}
void ParserThread::HandleFunction()
{
//TRACE("HandleFunction() : %s %s()",m_Context.type.back().name.get_text().c_str(),name.c_str());
// should always at the ( , so we firstly read the parentheses
if(m_Context.nameQueue.size()==0)
{
m_Context.nameQueue = m_Context.typeQueue;
m_Context.typeQueue.clear();
}
Symbol * sym = DoAddToken(tkFunction, m_Context.nameQueue.back().name);
ArgumentList args;
ReadFunctionArguments(args);
Token * peek = PeekToken();
if(peek->type_id() == TKN_CONST)
ConsumeToken();
// skip the member initialization list
if(PeekToken()->type_id() == TKN_COLON)
{
ConsumeToken();
while(true)
{
if(PeekToken()->type_id()!=TKN_L_BRACE)
ConsumeToken();
else
break;
}
}
peek = PeekToken();
if (peek->type_id() == TKN_L_BRACE) // function definition
{
TRACE("Function definition");
//SkipBrace();
ConsumeToken();
//Symbol * sym = DoAddToken(tkFunction, m_Context.nameQueue.back().name);
PushContext();
m_Context.parentToken = sym;
DoParse();
PopContext();
}
else if (peek->type_id() == TKN_SEMICOLON)
{
TRACE("Function declaration");
//DoAddToken(tkFunction, m_Context.nameQueue.back().name);
//newToken->m_Args = args;
ConsumeToken();
}
m_Context.EndStatement();
}
void
nsXFormsXPathParser::AbsoluteLocationPath()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
nsXFormsXPathScanner::XPATHTOKEN r;
switch (t) {
case nsXFormsXPathScanner::SLASH:
PopToken();
r = PeekToken();
switch (r) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
RelativeLocationPath();
break;
default:
break;
}
break;
case nsXFormsXPathScanner::SLASHSLASH:
PopToken();
if (DoRelative()) {
RelativeLocationPath();
}
break;
default:
XPathCompilerException("Not an absolute location path", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
bool ParserThread::ParseArgumentList(ArgumentList &argumentList)
{
// do nothing on the argumentList, just do the loop
if(PeekToken()->type_id() != TKN_LESS)
return true;
// shoud be a (xxxx) or <xxxxx>
Token * tk = ConsumeToken();
TRACE("ParserThread::ParseArgumentList() Enter...");
int level = 1;
argumentList.clear();
argumentList.push_back(*tk); // push <while(true)
while(true)
{
tk = PeekToken();//
if(tk->type_id() == TKN_LESS)
{
ConsumeToken();
argumentList.push_back(*tk);
level++;
}
else if (tk->type_id() == TKN_GREATER)
{
level--;
ConsumeToken();
argumentList.push_back(*tk);
if(level <= 0)
break;
}
else if(tk->type_id()==TKN_SEMICOLON || tk->type_id()==TKN_R_BRACE)
{
m_Context.EndStatement();
return false;
}
else
{
//std::cout<<*tk<<std::endl;
argumentList.push_back(*tk);
ConsumeToken();
}
}
//cout<<"currentToken"<<*(CurrentToken())<<endl;
TRACE("ParserThread::ParseArgumentList() Leave...");
return true;
}
void
nsXFormsXPathParser::PathExpr()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
case nsXFormsXPathScanner::SLASH:
case nsXFormsXPathScanner::SLASHSLASH:
LocationPath();
break;
default:
PushContext();
FilterExpr();
t = PeekToken();
if (t == nsXFormsXPathScanner::SLASH || t == nsXFormsXPathScanner::SLASHSLASH) {
PopToken();
if (DoRelative()) {
RelativeLocationPath();
} else {
XPathCompilerException("After / in a filter expression it is required to have a relative path expression",
EmptyString());
}
}
PopContext();
}
}
void
nsXFormsXPathParser::RelationalExpression()
{
AdditiveExpression();
PRBool con = PR_TRUE;
while (con) {
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::LESS:
PopToken();
AdditiveExpression();
break;
case nsXFormsXPathScanner::LEQUAL:
PopToken();
AdditiveExpression();
break;
case nsXFormsXPathScanner::GREATER:
PopToken();
AdditiveExpression();
break;
case nsXFormsXPathScanner::GEQUAL:
PopToken();
AdditiveExpression();
break;
default:
con = PR_FALSE;
}
}
}
void ParserThread::HandleEnum()
{
// enums have the following rough definition:
// enum [xxx] { type1 name1 [= 1][, [type2 name2 [= 2]]] };
ConsumeToken();
Token * tk = ConsumeToken(); // the token after "enum"
//Token * newToken = 0;
if (tk->type_id() == TKN_IDENTIFIER) // enum XXX
{
Token *pk = PeekToken();
if(pk->type_id() == TKN_L_BRACE ) //enum XXX {
{
// Do Add Token of enum
TRACE("find enum %s at line(%d)",tk->get_text().c_str(),tk->line_number());
DoAddToken(tkEnum, *tk);
//newToken->m_ImplLineStart = pk->line_number();
ConsumeToken(); //consume {
PushContext();
ReadEnumList();
PopContext();
}
else
{
SkipStatementBlock(); //something wrong
return;
}
}
else if (tk->type_id()== TKN_L_BRACE) // enum {
{
// // Do Add Token of enum
TRACE("find unnamed enum at line(%d)",tk->line_number());
DoAddToken(tkEnum, *tk);
ConsumeToken(); //consume {
PushContext();
ReadEnumList();
PopContext();
}
// Token's implement End line information added
tk = ConsumeToken();
//we are now after the }
// if we find a ;, good, end of definition of enum
// if we find an id, then this is something like enum XXX{...} A,B;
// A,B were the instant of the enum
tk = ConsumeToken();
if(tk->type_id() == TKN_IDENTIFIER)
{
//Add variables list
return;
}
else if(tk->type_id() == TKN_SEMICOLON)
{
//OK, end of enum definition
return;
}
}
void CMD_Send_ConfigInfo(F_CMD_ARGS)
{
struct moduleInfoList *t;
/* matching criteria for module cmds */
char *match;
/* get length once for efficiency */
int match_len = 0;
fmodule *mod = exc->m.module;
send_desktop_geometry(mod);
/* send ImagePath and ColorLimit first */
send_image_path(mod);
send_color_limit(mod);
send_xinerama_state(mod);
send_colorsets(mod);
send_click_time(mod);
send_move_threshold(mod);
match = PeekToken(action, &action);
if (match)
{
match_len = strlen(match);
}
for (t = modlistroot; t != NULL; t = t->next)
{
SendConfigToModule(mod, t, match, match_len);
}
send_desktop_names(mod);
send_ignore_modifiers(mod);
SendPacket(
mod, M_END_CONFIG_INFO, (long)0, (long)0, (long)0, (long)0,
(long)0, (long)0, (long)0, (long)0);
return;
}
bool Tokenizer::ReplaceBufferForReparse(const wxString& target, bool updatePeekToken)
{
if (target.IsEmpty())
return false;
if (m_IsReplaceParsing && ++m_RepeatReplaceCount > s_MaxRepeatReplaceCount)
{
m_TokenIndex = m_BufferLen - m_FirstRemainingLength;
m_PeekAvailable = false;
SkipToEOL(false);
return false;
}
// Keep all in one line
wxString buffer(target);
for (size_t i = 0; i < buffer.Len(); ++i)
{
switch ((wxChar)buffer.GetChar(i))
{
case _T('\\'):
case _T('\r'):
case _T('\n'):
buffer.SetChar(i, _T(' '));
}
}
// Increase memory
const size_t bufferLen = buffer.Len();
if (m_TokenIndex < bufferLen)
{
const size_t diffLen = bufferLen - m_TokenIndex;
m_Buffer.insert(0, wxString(_T(' '), diffLen));
m_BufferLen += diffLen;
m_TokenIndex += diffLen;
}
// Set replace parsing state, and save first replace token index
if (!m_IsReplaceParsing)
{
m_FirstRemainingLength = m_BufferLen - m_TokenIndex;
m_IsReplaceParsing = true;
}
// Replacement back
wxChar* p = const_cast<wxChar*>((const wxChar*)m_Buffer) + m_TokenIndex - bufferLen;
TRACE(_T("ReplacetargetForReparse() : <FROM>%s<TO>%s"), wxString(p, bufferLen).wx_str(), buffer.wx_str());
memcpy(p, (const wxChar*)target, bufferLen * sizeof(wxChar));
// Fix token index
m_TokenIndex -= bufferLen;
// Update the peek token
if (m_PeekAvailable && updatePeekToken)
{
m_PeekAvailable = false;
PeekToken();
}
return true;
}
void CMD_AddToMenu(F_CMD_ARGS)
{
MenuRoot *mr;
MenuRoot *mrPrior;
char *token, *rest,*item;
token = PeekToken(action, &rest);
if (!token)
{
return;
}
mr = menus_find_menu(token);
if (mr && MR_MAPPED_COPIES(mr) != 0)
{
fvwm_msg(ERR,"add_item_to_menu", "menu %s is in use", token);
return;
}
mr = FollowMenuContinuations(menus_find_menu(token), &mrPrior);
if (mr == NULL)
{
mr = NewMenuRoot(token);
}
/* Set + state to last menu */
set_last_added_item(ADDED_MENU, mr);
rest = GetNextToken(rest, &item);
AddToMenu(mr, item, rest, True /* pixmap scan */, True, False);
if (item)
{
free(item);
}
return;
}
void
nsXFormsXPathParser::AdditiveExpression()
{
PRBool con = PR_TRUE;
MultiplicationExpr();
while (con) {
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::PLUS:
PopToken();
MultiplicationExpr();
break;
case nsXFormsXPathScanner::MINUS:
PopToken();
MultiplicationExpr();
break;
default:
con = PR_FALSE;
}
}
}
void ParserThread::HandleTypedef()
{
ConsumeToken();
TRACE("Typedef find");
//find the token before semicolon
Token * cur;
Token * peek;
while(true)
{
peek = PeekToken();
if(peek->type_id() == TKN_SEMICOLON)
{
ConsumeToken();
break;
}
else
cur = ConsumeToken();
}
DoAddToken(tkTypedef,*cur);
//SkipStatementBlock();
}
void
nsXFormsXPathParser::AxisSpecifier()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
PopToken();
case nsXFormsXPathScanner::AT:
PopToken();
break;
default:
XPathCompilerException("Not a axis specifier", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
break;
}
}
void ParserThread::HandleForWhile()
{
SymbolKind id;
Token * tok = ConsumeToken(); //eat for or while key word
id = (tok->type_id()==TKN_FOR)? tkFor:tkWhile;
Symbol * sym = DoAddToken(id,*tok);
ConsumeToken(); //eat the left parenthesis
PushContext(); //save the old context
m_Context.parentToken=sym;
DoParse(); // do a parse, and should returned on an unbalanced right parenthesis
PopContext(); // restore the old context
tok = PeekToken();
if(tok->type_id()==TKN_L_BRACE)
{
ConsumeToken(); //eat {
PushContext(); //save the old context
m_Context.parentToken=sym;
DoParse(); // do a parse, and should returned on an unbalanced right brace
PopContext(); // restore the old context
}
else
SkipStatementBlock();
}
void CMD_ChangeMenuStyle(F_CMD_ARGS)
{
char *name = NULL;
char *menuname = NULL;
MenuStyle *ms = NULL;
MenuRoot *mr = NULL;
name = PeekToken(action, &action);
if (name == NULL)
{
fvwm_msg(ERR,"ChangeMenuStyle",
"needs at least two parameters");
return;
}
ms = menustyle_find(name);
if (ms == NULL)
{
fvwm_msg(ERR,"ChangeMenuStyle", "cannot find style %s", name);
return;
}
menuname = PeekToken(action, &action);
while (menuname && *menuname)
{
mr = menus_find_menu(menuname);
if (mr == NULL)
{
fvwm_msg(ERR, "ChangeMenuStyle", "cannot find menu %s",
menuname);
break;
}
if (MR_MAPPED_COPIES(mr) != 0)
{
fvwm_msg(ERR, "ChangeMenuStyle", "menu %s is in use",
menuname);
}
else
{
MR_STYLE(mr) = ms;
MR_IS_UPDATED(mr) = 1;
}
menuname = PeekToken(action, &action);
}
return;
}
void
nsXFormsXPathParser::UnionExpr()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
case nsXFormsXPathScanner::DOT:
case nsXFormsXPathScanner::DOTDOT:
case nsXFormsXPathScanner::SLASH:
case nsXFormsXPathScanner::SLASHSLASH:
case nsXFormsXPathScanner::VARIABLE:
case nsXFormsXPathScanner::LPARAN:
case nsXFormsXPathScanner::LITERAL:
case nsXFormsXPathScanner::NUMBER:
case nsXFormsXPathScanner::FUNCTIONNAME:
PathExpr();
t = PeekToken();
if (t == nsXFormsXPathScanner::UNION) {
PopToken();
UnionExpr();
}
break;
default:
XPathCompilerException("Unexpected union token", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
static void
ParseBlock (struct LValueArray *lvalues, int amount)
{
int token, i, found;
for (;;)
{
SkipWhiteSpace (TRUE);
token = PeekToken ();
found = FALSE;
for (i = 0; i < amount; i++)
{
if (lvalues[i].token == token)
{
found = TRUE;
break;
}
}
if (!found)
return;
GetNextToken ();
SkipWhiteSpace (FALSE);
token = GetNextToken ();
if (token == TknNONE)
ShowParserError ();
if ((token == TknRETURN) || (token == TknDONE))
continue;
if (token == TknASSIGN)
{
SkipWhiteSpace (FALSE);
token = PeekToken ();
if ((token != TknRETURN) && (token != TknDONE))
lvalues[i].func (GetNextToken ());
}
else
lvalues[i].func (token);
SkipWhiteSpace (FALSE);
if (((token = GetNextToken ()) != TknRETURN) && (token != TknDONE))
ShowParserError ();
}
}
void
nsXFormsXPathParser::Step()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::ANCESTOR:
case nsXFormsXPathScanner::ANCESTOR_OR_SELF:
case nsXFormsXPathScanner::ATTRIBUTE:
case nsXFormsXPathScanner::CHILD:
case nsXFormsXPathScanner::DESCENDANT:
case nsXFormsXPathScanner::DESCENDANT_OR_SELF:
case nsXFormsXPathScanner::FOLLOWING:
case nsXFormsXPathScanner::FOLLOWING_SIBLING:
case nsXFormsXPathScanner::NAMESPACE:
case nsXFormsXPathScanner::PARENT:
case nsXFormsXPathScanner::PRECEDING:
case nsXFormsXPathScanner::PRECEDING_SIBLING:
case nsXFormsXPathScanner::SELF:
case nsXFormsXPathScanner::AT:
AxisSpecifier();
break;
default:
break;
}
t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::STAR:
case nsXFormsXPathScanner::NCNAME:
case nsXFormsXPathScanner::QNAME:
case nsXFormsXPathScanner::COMMENT:
case nsXFormsXPathScanner::TEXT:
case nsXFormsXPathScanner::PI:
case nsXFormsXPathScanner::NODE:
NodeTest();
break;
default:
XPathCompilerException("Expected a NodeTest expression", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
t = PeekToken();
if (t == nsXFormsXPathScanner::LBRACK) {
Predicate(); // set the predicates
}
}
/**************************************************************************
*
* Moves focus to specified window
*
*************************************************************************/
void FocusOn(FvwmWindow *t, Bool FocusByMouse, char *action)
{
int dx,dy;
int cx,cy;
Bool do_not_warp;
if (t == NULL || HAS_NEVER_FOCUS(t))
{
UngrabEm(GRAB_NORMAL);
if (t)
{
/* give the window a chance to take the focus itself */
MoveFocus(t->w, t, FocusByMouse, 1, 0);
}
return;
}
if (!(do_not_warp = StrEquals(PeekToken(action, NULL), "NoWarp")))
{
if (t->Desk != Scr.CurrentDesk)
{
goto_desk(t->Desk);
}
if (IS_ICONIFIED(t))
{
cx = t->icon_xl_loc + t->icon_g.width/2;
cy = t->icon_g.y + t->icon_p_height + ICON_HEIGHT(t) / 2;
}
else
{
cx = t->frame_g.x + t->frame_g.width/2;
cy = t->frame_g.y + t->frame_g.height/2;
}
dx = (cx + Scr.Vx)/Scr.MyDisplayWidth*Scr.MyDisplayWidth;
dy = (cy +Scr.Vy)/Scr.MyDisplayHeight*Scr.MyDisplayHeight;
MoveViewport(dx,dy,True);
/* If the window is still not visible, make it visible! */
if (((t->frame_g.x + t->frame_g.height)< 0)||
(t->frame_g.y + t->frame_g.width < 0)||
(t->frame_g.x >Scr.MyDisplayWidth)||(t->frame_g.y>Scr.MyDisplayHeight))
{
SetupFrame(t, 0, 0, t->frame_g.width, t->frame_g.height, False);
if (HAS_MOUSE_FOCUS(t) || HAS_SLOPPY_FOCUS(t))
{
XWarpPointer(dpy, None, Scr.Root, 0, 0, 0, 0, 2,2);
}
}
}
UngrabEm(GRAB_NORMAL);
if (t->Desk == Scr.CurrentDesk)
{
MoveFocus(t->w, t, FocusByMouse, do_not_warp, 0);
}
return;
}
void
nsXFormsXPathParser::FilterExpr()
{
PrimaryExpr();
if (PeekToken() == nsXFormsXPathScanner::LBRACK) {
Predicate();
}
}
bool rc2wxr::ReadOrs(wxString & w)
{
wxString tok = PeekToken();
if (tok.IsNumber())
return false;
w=GetToken();
return true;
}
void
nsXFormsXPathParser::OrExpr()
{
AndExpr();
if (PeekToken() == nsXFormsXPathScanner::OR) {
PopToken();
OrExpr();
}
}
void
nsXFormsXPathParser::AndExpr()
{
EqualityExpr();
if (PeekToken() == nsXFormsXPathScanner::AND) {
PopToken();
AndExpr();
}
}
Token ScannerSub::GetToken(void){
if(bPeeked){
bPeeked = false;
return token;
}
Token e = PeekToken();
bPeeked = false;
return e;
}
static signed int expand_args_extended(
char *input, char *argument_string, char *output)
{
int rc;
int lower;
int upper;
int i;
size_t len;
rc = __eae_parse_range(input, &lower, &upper);
if (rc == -1)
{
return -1;
}
/* Skip to the start of the requested argument range */
if (lower > 0)
{
argument_string = SkipNTokens(argument_string, lower);
}
if (!argument_string)
{
/* replace with empty string */
return 0;
}
/* TODO: optimise handling of $[0] to $[9] which have already been
* parsed */
for (i = lower, len = 0; i <= upper; i++)
{
char *token;
size_t tlen;
token = PeekToken(argument_string, &argument_string);
if (token == NULL)
{
break;
}
/* copy the token */
if (i > lower)
{
if (output != NULL)
{
*output = ' ';
output++;
}
len++;
}
tlen = strlen(token);
if (output != NULL && tlen > 0)
{
memcpy(output, token, tlen);
output += tlen;
}
len += tlen;
}
return (int)len;
}
void
nsXFormsXPathParser::FunctionCall()
{
nsDependentSubstring fname = Substring(mScanner.Expression(),
mScanner.Offset() + 1,
mScanner.Length());
if (!mUsesDynamicFunc && fname.Equals(NS_LITERAL_STRING("now"))) {
mUsesDynamicFunc = PR_TRUE;
}
PopToken();
PopToken();
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
PRBool con = t == nsXFormsXPathScanner::RPARAN ? PR_FALSE : PR_TRUE;
while (con) {
if (t == nsXFormsXPathScanner::XPATHEOF) {
XPathCompilerException("Expected ) got EOF",
mScanner.Expression(),
mScanner.Offset(),
mScanner.Length());
}
nsXFormsXPathNode* c = JustContext();
Expr();
if (fname.Equals(NS_LITERAL_STRING("index"))) {
c->mIsIndex = PR_TRUE;
}
PushContext(c);
t = PeekToken();
con = (t == nsXFormsXPathScanner::COMMA);
if (con) {
PopToken(); // Another Argument
}
}
if (t != nsXFormsXPathScanner::RPARAN) {
XPathCompilerException("Expected )", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
PopToken();
}
void
nsXFormsXPathParser::PrimaryExpr()
{
nsXFormsXPathScanner::XPATHTOKEN t = PeekToken();
switch (t) {
case nsXFormsXPathScanner::VARIABLE:
PopToken();
break;
case nsXFormsXPathScanner::LPARAN: {
PopToken();
nsXFormsXPathNode* c = JustContext();
Expr();
PushContext(c);
if (PeekToken() == nsXFormsXPathScanner::RPARAN) {
PopToken();
} else {
XPathCompilerException("Expected )", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
break;
case nsXFormsXPathScanner::LITERAL:
mHead->mLiteral = PR_TRUE;
PopToken();
break;
case nsXFormsXPathScanner::NUMBER:
mHead->mLiteral = PR_TRUE;
PopToken();
break;
case nsXFormsXPathScanner::FUNCTIONNAME:
FunctionCall();
break;
default:
XPathCompilerException("Not a primary expression", mScanner.Expression(), mScanner.Offset(), mScanner.Length());
}
}
