DnsProxyListener::DnsProxyListener(UidMarkMap *map) :
FrameworkListener("dnsproxyd") {
registerCmd(new GetAddrInfoCmd(map));
registerCmd(new GetHostByAddrCmd(map));
registerCmd(new GetHostByNameCmd(map));
mUidMarkMap = map;
}
CommandListener::CommandListener() :
FrameworkListener("netd") {
registerCmd(new InterfaceCmd());
registerCmd(new IpFwdCmd());
registerCmd(new TetherCmd());
registerCmd(new NatCmd());
registerCmd(new ListTtysCmd());
registerCmd(new PppdCmd());
registerCmd(new PanCmd());
registerCmd(new SoftapCmd());
registerCmd(new UsbCmd());
registerCmd(new ResolverCmd());
if (!sTetherCtrl)
sTetherCtrl = new TetherController();
if (!sNatCtrl)
sNatCtrl = new NatController();
if (!sPppCtrl)
sPppCtrl = new PppController();
if (!sPanCtrl)
sPanCtrl = new PanController();
if (!sSoftapCtrl)
sSoftapCtrl = new SoftapController();
if (!sUsbCtrl)
sUsbCtrl = new UsbController();
if (!sResolverCtrl)
sResolverCtrl = new ResolverController();
}
void Debugger_LoK::initialize() {
registerCmd("enter", WRAP_METHOD(Debugger_LoK, cmdEnterRoom));
registerCmd("scenes", WRAP_METHOD(Debugger_LoK, cmdListScenes));
registerCmd("give", WRAP_METHOD(Debugger_LoK, cmdGiveItem));
registerCmd("birthstones", WRAP_METHOD(Debugger_LoK, cmdListBirthstones));
Debugger::initialize();
}
CommandListener::CommandListener(LogBuffer *buf, LogReader * /*reader*/,
LogListener * /*swl*/)
: FrameworkListener("logd")
, mBuf(*buf) {
// registerCmd(new ShutdownCmd(buf, writer, swl));
registerCmd(new ClearCmd(buf));
registerCmd(new GetBufSizeCmd(buf));
registerCmd(new GetBufSizeUsedCmd(buf));
}
CCmd::CCmd()
{
resetCmd(_cmd);
registerCmd(HELP_CMDID,"HELP",&helpCmd);
//registerCmd(NOLOG_CMDID,"NOLOG",&noLogCmd);
registerCmd(EXIT_CMDID,"EXIT",&exitCmd);
#if CMD_DEBUG
printf("(C)Copyright ASUSTEK Hunter_Chen 2009.\n");
#endif
}
CommandListener::CommandListener() :
FrameworkListener("arielfw", true) {
setenv("ANDROID_LOG_TAGS", "*:v", 1);
android::base::InitLogging(NULL, android::base::LogdLogger(android::base::SYSTEM));
registerCmd(new StatusCmd());
registerCmd(new DisableWifiCmd());
registerCmd(new DisableNetworkingCmd());
registerCmd(new ClearRulesCmd());
}
Debugger::Debugger(VoyeurEngine *vm) : GUI::Debugger(), _vm(vm) {
// Register methods
registerCmd("continue", WRAP_METHOD(Debugger, cmdExit));
registerCmd("time", WRAP_METHOD(Debugger, Cmd_Time));
registerCmd("hotspots", WRAP_METHOD(Debugger, Cmd_Hotspots));
registerCmd("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
// Set fields
_isTimeActive = true;
_showMousePosition = false;
}
void Debugger::initialize() {
registerCmd("continue", WRAP_METHOD(Debugger, cmdExit));
registerCmd("screen_debug_mode", WRAP_METHOD(Debugger, cmdSetScreenDebug));
registerCmd("load_palette", WRAP_METHOD(Debugger, cmdLoadPalette));
registerCmd("facings", WRAP_METHOD(Debugger, cmdShowFacings));
registerCmd("gamespeed", WRAP_METHOD(Debugger, cmdGameSpeed));
registerCmd("flags", WRAP_METHOD(Debugger, cmdListFlags));
registerCmd("toggleflag", WRAP_METHOD(Debugger, cmdToggleFlag));
registerCmd("queryflag", WRAP_METHOD(Debugger, cmdQueryFlag));
registerCmd("timers", WRAP_METHOD(Debugger, cmdListTimers));
registerCmd("settimercountdown", WRAP_METHOD(Debugger, cmdSetTimerCountdown));
}
void Debugger_EoB::initialize() {
registerCmd("import_savefile", WRAP_METHOD(Debugger_EoB, cmdImportSaveFile));
registerCmd("save_original", WRAP_METHOD(Debugger_EoB, cmdSaveOriginal));
registerCmd("list_monsters", WRAP_METHOD(Debugger_EoB, cmdListMonsters));
registerCmd("show_position", WRAP_METHOD(Debugger_EoB, cmdShowPosition));
registerCmd("set_position", WRAP_METHOD(Debugger_EoB, cmdSetPosition));
registerCmd("open_door", WRAP_METHOD(Debugger_EoB, cmdOpenDoor));
registerCmd("close_door", WRAP_METHOD(Debugger_EoB, cmdCloseDoor));
registerCmd("list_flags", WRAP_METHOD(Debugger_EoB, cmdListFlags));
registerCmd("set_flag", WRAP_METHOD(Debugger_EoB, cmdSetFlag));
registerCmd("clear_flag", WRAP_METHOD(Debugger_EoB, cmdClearFlag));
}
Console::Console(AdlEngine *engine) : GUI::Debugger() {
_engine = engine;
registerCmd("nouns", WRAP_METHOD(Console, Cmd_Nouns));
registerCmd("verbs", WRAP_METHOD(Console, Cmd_Verbs));
registerCmd("dump_scripts", WRAP_METHOD(Console, Cmd_DumpScripts));
registerCmd("valid_cmds", WRAP_METHOD(Console, Cmd_ValidCommands));
registerCmd("region", WRAP_METHOD(Console, Cmd_Region));
registerCmd("room", WRAP_METHOD(Console, Cmd_Room));
registerCmd("items", WRAP_METHOD(Console, Cmd_Items));
registerCmd("give_item", WRAP_METHOD(Console, Cmd_GiveItem));
registerCmd("vars", WRAP_METHOD(Console, Cmd_Vars));
registerCmd("var", WRAP_METHOD(Console, Cmd_Var));
}
CommandListener::CommandListener() :
FrameworkListener("sayeye", true) {
registerCmd(new NormalCmd());
registerCmd(new HomeCmd());
registerCmd(new BootCompleteCmd());
registerCmd(new VideoCmd());
registerCmd(new MusicCmd());
registerCmd(new RotateCmd());
registerCmd(new MonitorCmd());
registerCmd(new BenchMarkCmd());
registerCmd(new ConfigCmd());
}
//Helper to test a command that should return a failure.
//
void DupStatCmdTests::testBadCommand(const char* cmd)
{
registerCmd();
Tcl_Interp* pInterp = m_pNativeInterp;
int stat = Tcl_Eval(pInterp, cmd);
EQ(TCL_ERROR, stat);
}
CSTimeConsole::CSTimeConsole(MohawkEngine_CSTime *vm) : GUI::Debugger(), _vm(vm) {
registerCmd("playSound", WRAP_METHOD(CSTimeConsole, Cmd_PlaySound));
registerCmd("stopSound", WRAP_METHOD(CSTimeConsole, Cmd_StopSound));
registerCmd("drawImage", WRAP_METHOD(CSTimeConsole, Cmd_DrawImage));
registerCmd("drawSubimage", WRAP_METHOD(CSTimeConsole, Cmd_DrawSubimage));
registerCmd("changeCase", WRAP_METHOD(CSTimeConsole, Cmd_ChangeCase));
registerCmd("changeScene", WRAP_METHOD(CSTimeConsole, Cmd_ChangeScene));
registerCmd("caseVariable", WRAP_METHOD(CSTimeConsole, Cmd_CaseVariable));
registerCmd("invItem", WRAP_METHOD(CSTimeConsole, Cmd_InvItem));
}
CommandListener::CommandListener() :
FrameworkListener("vold", true) {
registerCmd(new DumpCmd());
registerCmd(new VolumeCmd());
registerCmd(new AsecCmd());
registerCmd(new ObbCmd());
registerCmd(new StorageCmd());
registerCmd(new XwarpCmd());
registerCmd(new CryptfsCmd());
registerCmd(new FstrimCmd());
}
bool BWHomeLayer::initWithColor(const Color4B& color, GLfloat w, GLfloat h)
{
if(CCCutTouchLayer::initWithColor(color, w, h))
{
setTag(eUILayerId_Home);
registerCmd();
return true;
}
return false;
}
Console::Console(TeenAgentEngine *engine) : _engine(engine) {
registerCmd("enable_object", WRAP_METHOD(Console, enableObject));
registerCmd("disable_object", WRAP_METHOD(Console, enableObject));
registerCmd("set_ons", WRAP_METHOD(Console, setOns));
registerCmd("set_music", WRAP_METHOD(Console, setMusic));
registerCmd("animation", WRAP_METHOD(Console, playAnimation));
registerCmd("actor_animation", WRAP_METHOD(Console, playActorAnimation));
registerCmd("call", WRAP_METHOD(Console, call));
}
int CCmd::registerCmd (char *signature,CCmdCallback *pCallback)
{
int cmdid;
if(!signature) return EOF;
for(cmdid=0;cmdid<CMD_COUNT;cmdid++){
if(UNINITIALIZED==_cmd[cmdid].initFlag) break;
}
if(cmdid<CMD_COUNT){
if(NULL==registerCmd(cmdid,signature,pCallback)) return cmdid;
}
return EOF;
}
//=============================================================
//=============================================================
bool BWCombatLayer::initWithColor(const Color4B& color, GLfloat w, GLfloat h)
{
if(CCCutTouchLayer::initWithColor(color, w, h))
{
setTag(eUILayerId_Combat);
registerCmd();
setTouchEnabled(true);
setTouchMode(Touch::DispatchMode::ONE_BY_ONE);
return true;
}
return false;
}
CommandListener::CommandListener(LogBuffer *buf, LogReader * /*reader*/,
LogListener * /*swl*/)
: FrameworkListener(getLogSocket())
, mBuf(*buf) {
// registerCmd(new ShutdownCmd(buf, writer, swl));
registerCmd(new ClearCmd(buf));
registerCmd(new GetBufSizeCmd(buf));
registerCmd(new SetBufSizeCmd(buf));
registerCmd(new GetBufSizeUsedCmd(buf));
registerCmd(new GetStatisticsCmd(buf));
registerCmd(new SetPruneListCmd(buf));
registerCmd(new GetPruneListCmd(buf));
registerCmd(new ReinitCmd());
}
Debugger::Debugger(SherlockEngine *vm) : GUI::Debugger(), _vm(vm) {
_showAllLocations = LOC_DISABLED;
registerCmd("continue", WRAP_METHOD(Debugger, cmdExit));
registerCmd("scene", WRAP_METHOD(Debugger, cmdScene));
registerCmd("song", WRAP_METHOD(Debugger, cmdSong));
registerCmd("songs", WRAP_METHOD(Debugger, cmdListSongs));
registerCmd("listfiles", WRAP_METHOD(Debugger, cmdListFiles));
registerCmd("dumpfile", WRAP_METHOD(Debugger, cmdDumpFile));
registerCmd("locations", WRAP_METHOD(Debugger, cmdLocations));
}
CommandListener::CommandListener() :
FrameworkListener("nexus") {
registerCmd(new WifiScanResultsCmd());
registerCmd(new WifiListNetworksCmd());
registerCmd(new WifiCreateNetworkCmd());
registerCmd(new WifiRemoveNetworkCmd());
registerCmd(new GetCmd());
registerCmd(new SetCmd());
registerCmd(new ListCmd());
}
void DupStatCmdTests::getempty()
{
registerCmd();
int stat = Tcl_Eval(m_pNativeInterp, "dupstat get");
EQ(TCL_OK, stat);
CTCLObject result(Tcl_GetObjResult(m_pNativeInterp));
result.Bind(m_pInterp);
EQ(2, result.llength());
EQ(0, (int)(result.lindex(0)));
EQ(std::string(""), std::string(result.lindex(1)));
}
void Debugger_v2::initialize() {
registerCmd("character_info", WRAP_METHOD(Debugger_v2, cmdCharacterInfo));
registerCmd("enter", WRAP_METHOD(Debugger_v2, cmdEnterScene));
registerCmd("scenes", WRAP_METHOD(Debugger_v2, cmdListScenes));
registerCmd("scene_info", WRAP_METHOD(Debugger_v2, cmdSceneInfo));
registerCmd("scene_to_facing", WRAP_METHOD(Debugger_v2, cmdSceneToFacing));
registerCmd("give", WRAP_METHOD(Debugger_v2, cmdGiveItem));
Debugger::initialize();
}
bool CCmdCenter::registerCmd(std::string strMoudle , std::string strCmdName , std::string strArgDetail , std::function<bool (std::vector<std::string>& vArg,CClientRobot* pCnter ) > lpInvokeFunc )
{
stCmd* p = new stCmd ;
p->strName = strCmdName;
p->strArgDetail = strArgDetail ;
p->lpFunc = lpInvokeFunc ;
if ( registerCmd(strMoudle,p) == false )
{
delete p ;
p = nullptr ;
return false ;
}
return true ;
}
void DupStatCmdTests::getonedup()
{
registerCmd();
// Send a set of fragments that result in one duplicat on source id 1:
EVB::FlatFragment frag;
frag.s_header.s_timestamp = 100; // nonzero is the key.
frag.s_header.s_sourceId = 1;
frag.s_header.s_size = 0;
frag.s_header.s_barrier = 0;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110; // not duplicate
m_pOrderer->addFragments(sizeof(frag), &frag);
m_pOrderer->addFragments(sizeof(frag), &frag); // duplicate
frag.s_header.s_timestamp = 111; // not duplicate
m_pOrderer->addFragments(sizeof(frag), &frag);
// Flush the queue as that's when duplicates are detected:
m_pOrderer->flushQueues();
EQ(TCL_OK, Tcl_Eval(m_pNativeInterp, "dupstat get"));
CTCLObject result(Tcl_GetObjResult(m_pNativeInterp));
result.Bind(m_pInterp);
// Evaluate the result:
EQ(2, result.llength());
EQ(1, (int)(result.lindex(0))); // There was one dup.
// List of details:
CTCLObject details = result.lindex(1);
details.Bind(m_pInterp);
EQ(1, details.llength()); // Only one source has a duplicate.
checkDetails(1, 1, 110, details.lindex(0));
}
void DupStatCmdTests::clear()
{
registerCmd();
// Make a bunch of dups, then clear/get the stats.
// Data for source 1 ts : 100, 110, 110, 110, 110 120
EVB::FlatFragment frag;
frag.s_header.s_timestamp = 100; // nonzero is the key.
frag.s_header.s_sourceId = 1;
frag.s_header.s_size = 0;
frag.s_header.s_barrier = 0;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110; /// dup 1
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110; // dup 2
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110; // dup 3
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 120; // not a dup.
m_pOrderer->addFragments(sizeof(frag), &frag);
m_pOrderer->flushQueues();
EQ(TCL_OK, Tcl_Eval(m_pNativeInterp, "dupstat clear"));
EQ(TCL_OK, Tcl_Eval(m_pNativeInterp, "dupstat get"));
CTCLObject result(Tcl_GetObjResult(m_pNativeInterp));
result.Bind(m_pInterp);
// totals are 0, and empty list
EQ(0, (int)(result.lindex(0)));
EQ(std::string(""), (std::string)(result.lindex(1)));
}
void DupStatCmdTests::getmixeddups()
{
registerCmd();
// Data for source 1 ts : 100, 110, 110, 110, 110 120
EVB::FlatFragment frag;
frag.s_header.s_timestamp = 100; // nonzero is the key.
frag.s_header.s_sourceId = 1;
frag.s_header.s_size = 0;
frag.s_header.s_barrier = 0;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110; /// dup 1
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110; // dup 2
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 110; // dup 3
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 120; // not a dup.
m_pOrderer->addFragments(sizeof(frag), &frag);
// Data from source 2 is 100 110 120 130 140 150
frag.s_header.s_sourceId = 2;
frag.s_header.s_timestamp = 100; // yeah. could be a loop.
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 120;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 130;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 140;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 150;
m_pOrderer->addFragments(sizeof(frag), &frag);
// Data from source 3 is 112, 112, 120, 125, 130, 132
frag.s_header.s_sourceId = 3;
frag.s_header.s_timestamp = 112;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 112;
m_pOrderer->addFragments(sizeof(frag), &frag); // dup 1 (and only)
frag.s_header.s_timestamp = 120;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 125;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 130;
m_pOrderer->addFragments(sizeof(frag), &frag);
frag.s_header.s_timestamp = 132;
m_pOrderer->addFragments(sizeof(frag), &frag);
// flush the data:
m_pOrderer->flushQueues();
// Run the command and analyze the results:
EQ(TCL_OK, Tcl_Eval(m_pNativeInterp, "dupstat get"));
CTCLObject result(Tcl_GetObjResult(m_pNativeInterp));
result.Bind(m_pInterp);
// Should have a 2 element list, element 0 is the integer 4
// (sum of all dups over all sources.
EQ(2, result.llength());
EQ(4, int(result.lindex(0)));
// The details should be a 2 element list:
CTCLObject details(result.lindex(1));
details.Bind(m_pInterp);
EQ(2, details.llength());
checkDetails(1, 3, 110, details.lindex(0));
checkDetails(3, 1, 112, details.lindex(1));
}
Console::Console(ZVision *engine) : GUI::Debugger(), _engine(engine) {
registerCmd("loadvideo", WRAP_METHOD(Console, cmdLoadVideo));
registerCmd("loadsound", WRAP_METHOD(Console, cmdLoadSound));
registerCmd("raw2wav", WRAP_METHOD(Console, cmdRawToWav));
registerCmd("setrenderstate", WRAP_METHOD(Console, cmdSetRenderState));
registerCmd("generaterendertable", WRAP_METHOD(Console, cmdGenerateRenderTable));
registerCmd("setpanoramafov", WRAP_METHOD(Console, cmdSetPanoramaFoV));
registerCmd("setpanoramascale", WRAP_METHOD(Console, cmdSetPanoramaScale));
registerCmd("location", WRAP_METHOD(Console, cmdLocation));
registerCmd("dumpfile", WRAP_METHOD(Console, cmdDumpFile));
registerCmd("dumpfiles", WRAP_METHOD(Console, cmdDumpFiles));
registerCmd("dumpimage", WRAP_METHOD(Console, cmdDumpImage));
registerCmd("statevalue", WRAP_METHOD(Console, cmdStateValue));
registerCmd("stateflag", WRAP_METHOD(Console, cmdStateFlag));
}
void DupStatCmdTests::cmdregisters() {
registerCmd();
Tcl_CmdInfo info;
int status = Tcl_GetCommandInfo(m_pInterp->getInterpreter(), "dupstat", &info);
EQ(1, status); // Status is not TCL_OK for this :-()
}
ScummDebugger::ScummDebugger(ScummEngine *s)
: GUI::Debugger() {
_vm = s;
// Register variables
registerVar("scumm_speed", &_vm->_fastMode);
registerVar("scumm_room", &_vm->_currentRoom);
registerVar("scumm_roomresource", &_vm->_roomResource);
registerVar("scumm_vars", &_vm->_scummVars, _vm->_numVariables);
// Register commands
registerCmd("continue", WRAP_METHOD(ScummDebugger, cmdExit));
registerCmd("restart", WRAP_METHOD(ScummDebugger, Cmd_Restart));
registerCmd("actor", WRAP_METHOD(ScummDebugger, Cmd_Actor));
registerCmd("actors", WRAP_METHOD(ScummDebugger, Cmd_PrintActor));
registerCmd("box", WRAP_METHOD(ScummDebugger, Cmd_PrintBox));
registerCmd("matrix", WRAP_METHOD(ScummDebugger, Cmd_PrintBoxMatrix));
registerCmd("camera", WRAP_METHOD(ScummDebugger, Cmd_Camera));
registerCmd("room", WRAP_METHOD(ScummDebugger, Cmd_Room));
registerCmd("objects", WRAP_METHOD(ScummDebugger, Cmd_PrintObjects));
registerCmd("object", WRAP_METHOD(ScummDebugger, Cmd_Object));
registerCmd("script", WRAP_METHOD(ScummDebugger, Cmd_Script));
registerCmd("scr", WRAP_METHOD(ScummDebugger, Cmd_Script));
registerCmd("scripts", WRAP_METHOD(ScummDebugger, Cmd_PrintScript));
registerCmd("importres", WRAP_METHOD(ScummDebugger, Cmd_ImportRes));
if (_vm->_game.id == GID_LOOM)
registerCmd("drafts", WRAP_METHOD(ScummDebugger, Cmd_PrintDraft));
if (_vm->_game.id == GID_MONKEY && _vm->_game.platform == Common::kPlatformSegaCD)
registerCmd("passcode", WRAP_METHOD(ScummDebugger, Cmd_Passcode));
registerCmd("loadgame", WRAP_METHOD(ScummDebugger, Cmd_LoadGame));
registerCmd("savegame", WRAP_METHOD(ScummDebugger, Cmd_SaveGame));
registerCmd("debug", WRAP_METHOD(ScummDebugger, Cmd_Debug));
registerCmd("show", WRAP_METHOD(ScummDebugger, Cmd_Show));
registerCmd("hide", WRAP_METHOD(ScummDebugger, Cmd_Hide));
registerCmd("imuse", WRAP_METHOD(ScummDebugger, Cmd_IMuse));
registerCmd("resetcursors", WRAP_METHOD(ScummDebugger, Cmd_ResetCursors));
}
