You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
350 lines
8.9 KiB
350 lines
8.9 KiB
//=============================================================================
|
|
//
|
|
// File : kvi_kvs_treenode_specialcommandswitch.cpp
|
|
// Created on Fri 02 Jan 2004 14:09:00 by Szymon Stefanek
|
|
//
|
|
// This file is part of the KVIrc IRC client distribution
|
|
// Copyright (C) 2004 Szymon Stefanek <pragma at kvirc dot net>
|
|
//
|
|
// This program is FREE software. You can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your opinion) any later version.
|
|
//
|
|
// This program is distributed in the HOPE that it will be USEFUL,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, write to the Free Software Foundation,
|
|
// Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
//
|
|
//=============================================================================
|
|
|
|
#define __KVIRC__
|
|
|
|
#include "kvi_kvs_treenode_specialcommandswitch.h"
|
|
#include "kvi_kvs_treenode_expression.h"
|
|
#include "kvi_kvs_treenode_instruction.h"
|
|
#include "kvi_kvs_runtimecontext.h"
|
|
#include "kvi_locale.h"
|
|
|
|
#include <tqregexp.h>
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabel::KviKvsTreeNodeSpecialCommandSwitchLabel(const TQChar * pLocation)
|
|
: KviKvsTreeNode(pLocation)
|
|
{
|
|
m_pParameter = 0;
|
|
m_pInstruction = 0;
|
|
m_bHasTerminatingBreak = false;
|
|
}
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabel::~KviKvsTreeNodeSpecialCommandSwitchLabel()
|
|
{
|
|
if(m_pParameter)delete m_pParameter;
|
|
if(m_pInstruction)delete m_pInstruction;
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabel::setParameter(KviKvsTreeNodeData * pParameter)
|
|
{
|
|
if(m_pParameter)delete m_pParameter;
|
|
m_pParameter = pParameter;
|
|
if(m_pParameter)m_pParameter->setParent(this);
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabel::setInstruction(KviKvsTreeNodeInstruction * pInstruction)
|
|
{
|
|
if(m_pInstruction)delete m_pInstruction;
|
|
m_pInstruction = pInstruction;
|
|
if(m_pInstruction)m_pInstruction->setParent(this);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelCase::KviKvsTreeNodeSpecialCommandSwitchLabelCase(const TQChar * pLocation)
|
|
: KviKvsTreeNodeSpecialCommandSwitchLabel(pLocation)
|
|
{
|
|
}
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelCase::~KviKvsTreeNodeSpecialCommandSwitchLabelCase()
|
|
{
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelCase::contextDescription(TQString &szBuffer)
|
|
{
|
|
szBuffer = "Label \"case\" For Special Command \"switch\"";
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelCase::dump(const char * prefix)
|
|
{
|
|
tqDebug("%s SpecialCommandSwitchLabelCase",prefix);
|
|
TQString tmp = prefix;
|
|
tmp.append(" ");
|
|
if(m_pParameter)m_pParameter->dump(tmp.utf8().data());
|
|
if(m_pInstruction)m_pInstruction->dump(tmp.utf8().data());
|
|
}
|
|
|
|
bool KviKvsTreeNodeSpecialCommandSwitchLabelCase::execute(KviKvsRunTimeContext * c,KviKvsVariant * pRealParameter)
|
|
{
|
|
KviKvsVariant v;
|
|
if(!m_pParameter->evaluateReadOnly(c,&v))return false;
|
|
|
|
KviKvsNumber num;
|
|
if(pRealParameter->asNumber(num))
|
|
{
|
|
KviKvsNumber num2;
|
|
if(!v.asNumber(num2))return true; // a number an a non number can't match
|
|
if(num.isInteger())
|
|
{
|
|
if(num2.isInteger())
|
|
{
|
|
if(num.integer() != num2.integer())return true;
|
|
} else {
|
|
if(((double)(num.integer())) != num2.real())return true;
|
|
}
|
|
} else {
|
|
if(num2.isInteger())
|
|
{
|
|
if(num.real() != ((double)(num2.integer())))return true;
|
|
} else {
|
|
if(num.real() != num2.real())return true;
|
|
}
|
|
}
|
|
} else {
|
|
// string comparision, case insensitive
|
|
TQString reg;
|
|
v.asString(reg);
|
|
|
|
TQString val;
|
|
pRealParameter->asString(val);
|
|
|
|
if(reg.lower() != val.lower())return true;
|
|
}
|
|
|
|
if(m_pInstruction)
|
|
{
|
|
if(!m_pInstruction->execute(c))return false; // might be a break too
|
|
}
|
|
if(m_bHasTerminatingBreak)
|
|
{
|
|
c->setBreakPending();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelMatch::KviKvsTreeNodeSpecialCommandSwitchLabelMatch(const TQChar * pLocation)
|
|
: KviKvsTreeNodeSpecialCommandSwitchLabel(pLocation)
|
|
{
|
|
}
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelMatch::~KviKvsTreeNodeSpecialCommandSwitchLabelMatch()
|
|
{
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelMatch::contextDescription(TQString &szBuffer)
|
|
{
|
|
szBuffer = "Label \"match\" For Special Command \"switch\"";
|
|
}
|
|
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelMatch::dump(const char * prefix)
|
|
{
|
|
tqDebug("%s SpecialCommandSwitchLabelMatch",prefix);
|
|
TQString tmp = prefix;
|
|
tmp.append(" ");
|
|
if(m_pParameter)m_pParameter->dump(tmp.utf8().data());
|
|
if(m_pInstruction)m_pInstruction->dump(tmp.utf8().data());
|
|
}
|
|
|
|
bool KviKvsTreeNodeSpecialCommandSwitchLabelMatch::execute(KviKvsRunTimeContext * c,KviKvsVariant * pRealParameter)
|
|
{
|
|
KviKvsVariant v;
|
|
if(!m_pParameter->evaluateReadOnly(c,&v))return false;
|
|
|
|
TQString reg;
|
|
v.asString(reg);
|
|
|
|
TQRegExp rx(reg,false,true);
|
|
|
|
TQString val;
|
|
pRealParameter->asString(val);
|
|
|
|
if(!rx.exactMatch(val))return true; // no match
|
|
|
|
if(m_pInstruction)
|
|
{
|
|
if(!m_pInstruction->execute(c))return false; // might be a break too
|
|
}
|
|
if(m_bHasTerminatingBreak)
|
|
{
|
|
c->setBreakPending();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelRegexp::KviKvsTreeNodeSpecialCommandSwitchLabelRegexp(const TQChar * pLocation)
|
|
: KviKvsTreeNodeSpecialCommandSwitchLabel(pLocation)
|
|
{
|
|
}
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelRegexp::~KviKvsTreeNodeSpecialCommandSwitchLabelRegexp()
|
|
{
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelRegexp::contextDescription(TQString &szBuffer)
|
|
{
|
|
szBuffer = "Label \"regexp\" For Special Command \"switch\"";
|
|
}
|
|
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelRegexp::dump(const char * prefix)
|
|
{
|
|
tqDebug("%s SpecialCommandSwitchLabelRegexp",prefix);
|
|
TQString tmp = prefix;
|
|
tmp.append(" ");
|
|
if(m_pParameter)m_pParameter->dump(tmp.utf8().data());
|
|
if(m_pInstruction)m_pInstruction->dump(tmp.utf8().data());
|
|
}
|
|
|
|
bool KviKvsTreeNodeSpecialCommandSwitchLabelRegexp::execute(KviKvsRunTimeContext * c,KviKvsVariant * pRealParameter)
|
|
{
|
|
KviKvsVariant v;
|
|
if(!m_pParameter->evaluateReadOnly(c,&v))return false;
|
|
|
|
TQString reg;
|
|
v.asString(reg);
|
|
|
|
TQRegExp rx(reg,false,false);
|
|
|
|
TQString val;
|
|
pRealParameter->asString(val);
|
|
|
|
if(!rx.exactMatch(val))return true; // no match
|
|
|
|
if(m_pInstruction)
|
|
{
|
|
if(!m_pInstruction->execute(c))return false; // might be a break too
|
|
}
|
|
if(m_bHasTerminatingBreak)
|
|
{
|
|
c->setBreakPending();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelDefault::KviKvsTreeNodeSpecialCommandSwitchLabelDefault(const TQChar * pLocation)
|
|
: KviKvsTreeNodeSpecialCommandSwitchLabel(pLocation)
|
|
{
|
|
}
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitchLabelDefault::~KviKvsTreeNodeSpecialCommandSwitchLabelDefault()
|
|
{
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelDefault::contextDescription(TQString &szBuffer)
|
|
{
|
|
szBuffer = "Label \"default\" For Special Command \"switch\"";
|
|
}
|
|
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitchLabelDefault::dump(const char * prefix)
|
|
{
|
|
tqDebug("%s SpecialCommandSwitchLabelDefault",prefix);
|
|
TQString tmp = prefix;
|
|
tmp.append(" ");
|
|
if(m_pInstruction)m_pInstruction->dump(tmp.utf8().data());
|
|
}
|
|
|
|
bool KviKvsTreeNodeSpecialCommandSwitchLabelDefault::execute(KviKvsRunTimeContext * c,KviKvsVariant * pRealParameter)
|
|
{
|
|
if(m_pInstruction)
|
|
{
|
|
if(!m_pInstruction->execute(c))return false; // might be a break too
|
|
}
|
|
if(m_bHasTerminatingBreak)
|
|
{
|
|
c->setBreakPending();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitch::KviKvsTreeNodeSpecialCommandSwitch(const TQChar * pLocation,KviKvsTreeNodeExpression * e)
|
|
: KviKvsTreeNodeSpecialCommand(pLocation,"switch")
|
|
{
|
|
m_pExpression = e;
|
|
m_pExpression->setParent(this);
|
|
m_pLabels = new KviPointerList<KviKvsTreeNodeSpecialCommandSwitchLabel>;
|
|
m_pLabels->setAutoDelete(true);
|
|
}
|
|
|
|
KviKvsTreeNodeSpecialCommandSwitch::~KviKvsTreeNodeSpecialCommandSwitch()
|
|
{
|
|
delete m_pExpression;
|
|
delete m_pLabels;
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitch::addLabel(KviKvsTreeNodeSpecialCommandSwitchLabel * l)
|
|
{
|
|
m_pLabels->append(l);
|
|
l->setParent(this);
|
|
}
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitch::contextDescription(TQString &szBuffer)
|
|
{
|
|
szBuffer = "Special Command \"switch\"";
|
|
}
|
|
|
|
|
|
void KviKvsTreeNodeSpecialCommandSwitch::dump(const char * prefix)
|
|
{
|
|
tqDebug("%s SpecialCommandSwitch",prefix);
|
|
TQString tmp = prefix;
|
|
tmp.append(" ");
|
|
m_pExpression->dump(tmp.utf8().data());
|
|
for(KviKvsTreeNodeSpecialCommandSwitchLabel * l = m_pLabels->first();l;l = m_pLabels->next())
|
|
l->dump(tmp.utf8().data());
|
|
}
|
|
|
|
bool KviKvsTreeNodeSpecialCommandSwitch::execute(KviKvsRunTimeContext * c)
|
|
{
|
|
KviKvsVariant v;
|
|
if(!m_pExpression->evaluateReadOnly(c,&v))return false;
|
|
|
|
for(KviKvsTreeNodeSpecialCommandSwitchLabel * l = m_pLabels->first();l;l = m_pLabels->next())
|
|
{
|
|
if(!l->execute(c,&v))
|
|
{
|
|
if(c->error())return false;
|
|
// break ?
|
|
if(c->breakPending())
|
|
{
|
|
c->handleBreak();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|